From e053cdcaf63d6ecc9763a31bbfbc9027d2f9abf7 Mon Sep 17 00:00:00 2001 From: Felix Hammer Date: Sun, 20 Sep 2015 14:01:51 +0200 Subject: [PATCH] Move the listView data to the c++ context --- pokerth_qml-client.pro | 3 +- src/gui/qml/components/MyAbstractSelector.qml | 16 +- .../MyBlindsRaiseIntervalSelector.qml | 4 +- .../components/MyBlindsRaiseModeSelector.qml | 239 +- src/gui/qml/components/MyComboBoxSelector.qml | 38 +- .../components/MyListViewDelegateFactory.qml | 38 +- src/gui/qml/components/MySpinBoxSelector.qml | 3 +- src/gui/qml/components/styles/AppStyle.qml | 2 + src/gui/qml/cpp/createlocalgameviewimpl.cpp | 109 +- src/gui/qml/cpp/createlocalgameviewimpl.h | 18 +- src/gui/qml/cpp/mylistviewitemdata.h | 371 + src/gui/qml/cpp/qmlwrapper.cpp | 17 +- src/gui/qml/cpp/qmlwrapper.h | 4 +- src/gui/qml/cpp/startviewimpl.cpp | 7 + src/gui/qml/cpp/startviewimpl.h | 7 +- src/gui/qml/js/tools.js | 9 +- .../CreateLocalGameView.qml | 123 +- src/third_party/protobuf/pokerth.pb.cc | 7165 ++++++++++++----- src/third_party/protobuf/pokerth.pb.h | 3020 +++++-- 19 files changed, 8241 insertions(+), 2952 deletions(-) create mode 100644 src/gui/qml/cpp/mylistviewitemdata.h diff --git a/pokerth_qml-client.pro b/pokerth_qml-client.pro index eec1febc..16fdfc16 100644 --- a/pokerth_qml-client.pro +++ b/pokerth_qml-client.pro @@ -54,7 +54,8 @@ HEADERS += \ src/gui/qml/cpp/qmlwrapper.h \ src/gui/qml/cpp/qmlconfig.h \ src/gui/qml/cpp/startviewimpl.h \ - src/gui/qml/cpp/createlocalgameviewimpl.h + src/gui/qml/cpp/createlocalgameviewimpl.h \ + src/gui/qml/cpp/mylistviewitemdata.h SOURCES += \ diff --git a/src/gui/qml/components/MyAbstractSelector.qml b/src/gui/qml/components/MyAbstractSelector.qml index acad9fd6..84cac90a 100644 --- a/src/gui/qml/components/MyAbstractSelector.qml +++ b/src/gui/qml/components/MyAbstractSelector.qml @@ -13,6 +13,7 @@ Rectangle { color: "#88000000" //dark transparent background property alias container: ctr.children + property alias containerSelf: ctr property string titleText: "" property string button1Text: "" @@ -76,7 +77,7 @@ Rectangle { width: parent.width anchors.right: parent.right anchors.bottom: parent.bottom - spacing: AppStyle.rowLayoutSpacing + spacing: AppStyle.selectorBoxButtonRowLayoutSpacing Layout.preferredHeight: btn1.contentHeight Text { @@ -86,12 +87,17 @@ Rectangle { width: button1Text == "" ? 0 : contentWidth text: button1Text - signal buttonClicked MouseArea { id: mouse1 anchors.fill: parent + anchors.margins: AppStyle.selectorBoxButtonMouseAreaMargin onClicked: selector.button1Clicked() + + Rectangle { + anchors.fill: parent + color: mouse1.pressed ? "#55555555" : "#00ffffff" + } } } Text { @@ -104,7 +110,13 @@ Rectangle { MouseArea { id: mouse2 anchors.fill: parent + anchors.margins: AppStyle.selectorBoxButtonMouseAreaMargin onClicked: selector.button2Clicked() + + Rectangle { + anchors.fill: parent + color: mouse2.pressed ? "#55555555" : "#00ffffff" + } } } } diff --git a/src/gui/qml/components/MyBlindsRaiseIntervalSelector.qml b/src/gui/qml/components/MyBlindsRaiseIntervalSelector.qml index e6fb8442..e7a11088 100644 --- a/src/gui/qml/components/MyBlindsRaiseIntervalSelector.qml +++ b/src/gui/qml/components/MyBlindsRaiseIntervalSelector.qml @@ -31,11 +31,11 @@ Item { mySelector.show() if(raiseOnHandsType == "1") { - textFieldHandsInterval.focus = true; +// textFieldHandsInterval.focus = true; radioBtnRaiseOnHands.checked = true; } else { - textFieldMinutesInterval.focus = true; +// textFieldMinutesInterval.focus = true; radioBtnRaiseOnMinutes.checked = true; } } diff --git a/src/gui/qml/components/MyBlindsRaiseModeSelector.qml b/src/gui/qml/components/MyBlindsRaiseModeSelector.qml index c88a4cbb..c192fa29 100644 --- a/src/gui/qml/components/MyBlindsRaiseModeSelector.qml +++ b/src/gui/qml/components/MyBlindsRaiseModeSelector.qml @@ -13,39 +13,93 @@ Item { property string titleString: "" property bool alwaysDoubleBlinds: false property var manualBlindsList + property ListModel internalManualBlindsList: ListModel {} property bool afterMBAlwaysDoubleBlinds: false property bool afterMBAlwaysRaiseAbout: false property bool afterMBStayAtLastBlind: false - property int afterMBAlwaysRaiseValue: 0 + property string afterMBAlwaysRaiseValue: "0" + property var parentListViewModel + property var parentListViewRoot + property int addBlindTextFieldMinValue: 5 + property int addBlindTextFieldMaxValue: 1000000 + property bool ready: false signal accepted - function show(title, doubleBlinds, list, afterMBDouble, afterMBRaise, afterMBRaiseValue, afterMBStay) { + function show(title, doubleBlinds, list, afterMBDouble, afterMBRaise, afterMBRaiseValue, afterMBStay, parentListModel, parentListRoot) { + //initial the class values titleString = title alwaysDoubleBlinds = doubleBlinds; manualBlindsList = list; + //to easily edit the array put it into an temporary listmodel + internalManualBlindsList.clear(); + for (var i=0; i < list.length; i++) { + internalManualBlindsList.append({"value": list[i]}); + } + afterMBAlwaysDoubleBlinds = afterMBDouble; afterMBAlwaysRaiseAbout = afterMBRaise; afterMBAlwaysRaiseValue = afterMBRaiseValue; afterMBStayAtLastBlind = afterMBStay; + parentListViewModel = parentListModel; + parentListViewRoot = parentListRoot; + //show the abstract selector with below defined specific content mySelector.show() - // if(raiseOnHandsType == "1") { - // textFieldHandsInterval.focus = true; - // radioBtnRaiseOnHands.checked = true; - // } - // else { - // textFieldMinutesInterval.focus = true; - // radioBtnRaiseOnMinutes.checked = true; - // } + //set the config options to radiobuttons and textfields + if(alwaysDoubleBlinds) { + radioBtnBlindsRaiseModeAlwaysDouble.checked = true; + radioBtnBlindsRaiseModeManualBlindsList.checked = false; + } + else { + radioBtnBlindsRaiseModeManualBlindsList.checked = true; + radioBtnBlindsRaiseModeAlwaysDouble.checked = false; + } + + //if we are in a createLocalGameView Dialog set min and max from corresponding values in the same list + if(parentListViewRoot.myReadableId == "createLocalGameViewRoot") { + //get current start blind as minimum and cash as maximum for the textfield + var currentStartBlind = 0; + var startCash = 0; + for (var i=0; i < parentListViewModel.length; i++) { + if(parentListViewModel[i].myId == "spinBox_FirstSmallBlind") { + currentStartBlind = parentListViewModel[i].myValue; + } + else if (parentListViewModel[i].myId == "spinBox_StartCash") { + startCash = parentListViewModel[i].myValue; + + } + } + addBlindTextFieldMinValue = currentStartBlind; + addBlindTextFieldMaxValue = startCash; + + textFieldAddListBlind.text = addBlindTextFieldMinValue; + } + + if(afterMBAlwaysDoubleBlinds) { + radioBtnAfterMBAlwaysDouble.checked = true + radioBtnAfterMBAlwaysRaiseAbout.checked = false + radioBtnAfterMBKeepLastBlind.checked = false + } + else if (afterMBAlwaysRaiseAbout) { + radioBtnAfterMBAlwaysDouble.checked = false + radioBtnAfterMBAlwaysRaiseAbout.checked = true + radioBtnAfterMBKeepLastBlind.checked = false + } + else { + radioBtnAfterMBAlwaysDouble.checked = false + radioBtnAfterMBAlwaysRaiseAbout.checked = false + radioBtnAfterMBKeepLastBlind.checked = true + } + + textFieldAfterMBAlwaysRaiseAboutValue.text = afterMBAlwaysRaiseValue } - function selected(doubleBlinds, list, afterMBDouble, afterMBRaise, afterMBRaiseValue, afterMBStay) { + function selected(doubleBlinds, afterMBDouble, afterMBRaise, afterMBRaiseValue, afterMBStay) { alwaysDoubleBlinds = doubleBlinds; - manualBlindsList = list; afterMBAlwaysDoubleBlinds = afterMBDouble; afterMBAlwaysRaiseAbout = afterMBRaise; afterMBAlwaysRaiseValue = afterMBRaiseValue; @@ -63,20 +117,169 @@ Item { onButton1Clicked: hide() button2Text: qsTr("OK") onButton2Clicked: { - // textFieldHandsInterval.correctValue(); - // textFieldMinutesInterval.correctValue(); + textFieldAfterMBAlwaysRaiseAboutValue.correctValue(); + //copy editable internal listmodel to returnable list + manualBlindsList = new Array(); //clear at first + for (var i=0; i < internalManualBlindsList.count; i++) { + manualBlindsList.push(internalManualBlindsList.get(i).value.toString()); + } //return values - // root.selected(radioBtnRaiseOnHands.checked ? "1": "0", textFieldHandsInterval.text, textFieldMinutesInterval.text); + root.selected(radioBtnBlindsRaiseModeAlwaysDouble.checked, radioBtnAfterMBAlwaysDouble.checked, radioBtnAfterMBAlwaysRaiseAbout.checked, textFieldAfterMBAlwaysRaiseAboutValue.text, radioBtnAfterMBKeepLastBlind.checked); } container: ScrollView { + id: scrollView anchors.fill: parent ColumnLayout { width: parent.width -// TODO Hier gehts mit dem Inhalt weiter + spacing: AppStyle.columnLayoutSpacing + ExclusiveGroup { id: blindsRaiseModeGroup } + RadioButton { + id: radioBtnBlindsRaiseModeAlwaysDouble + exclusiveGroup: blindsRaiseModeGroup + style: MyRadioButtonStyle { + myRadioBtn: radioBtnBlindsRaiseModeAlwaysDouble + labelString: qsTr("Always double blinds"); + } + } + RadioButton { + id: radioBtnBlindsRaiseModeManualBlindsList + exclusiveGroup: blindsRaiseModeGroup + style: MyRadioButtonStyle { + myRadioBtn: radioBtnBlindsRaiseModeManualBlindsList + labelString: qsTr("Manual blinds list"); + } + } + RowLayout { + id: listControlsRow + width: parent.width + spacing: AppStyle.rowLayoutSpacing + TextField { + id: textFieldAddListBlind + anchors.left: parent.left + //make space for the prefix + anchors.leftMargin: AppStyle.spinBoxSelectorTextFieldPrefixExtraLeftMargin + width: Math.round(listControlsRow.width * 0.5) + style: MyTextFieldStyle { + prefix: "$" + myTextField: textFieldAddListBlind + } + function correctValue() { + text = GlobalTools.correctTextFieldIntegerValue(root, text, addBlindTextFieldMinValue, addBlindTextFieldMaxValue); + } + onFocusChanged: { if(root.ready && !focus) correctValue(); } + onEditingFinished: { if(root.ready) correctValue(); } + } + Text { + id: btnAddNewListBlind + font.pixelSize: AppStyle.selectorBoxButtonFontSize + font.bold: true + width: Math.round(listControlsRow.width * 0.5) + text: qsTr("ADD BLIND") + + MouseArea { + id: mouseAddNewListBlind + anchors.fill: parent + anchors.margins: AppStyle.selectorBoxButtonMouseAreaMargin + onClicked: { + textFieldAddListBlind.correctValue(); + internalManualBlindsList.append({"value": textFieldAddListBlind.text.toString()}) + } + Rectangle { + anchors.fill: parent + color: mouseAddNewListBlind.pressed ? "#55555555" : "#00ffffff" + } + } + } + } + Repeater { + id: manualBlindListRepeater + width: parent.width + model: internalManualBlindsList + delegate: RowLayout { + spacing: AppStyle.rowLayoutSpacing + Text { + id: blindInList + anchors.verticalCenter: parent.verticalCenter + font.pixelSize: AppStyle.radioButtonLabelFontSize + text: "$"+model.value + } + Text { + id: btnRemoveListBlind + anchors.verticalCenter: parent.verticalCenter + property int modelIndex: model.index + font.pixelSize: AppStyle.selectorBoxButtonFontSize + font.bold: true + width: Math.round(listControlsRow.width * 0.5) + text: qsTr("REMOVE") + + MouseArea { + id: mouseRemoveListBlind + anchors.fill: parent + anchors.margins: AppStyle.selectorBoxButtonMouseAreaMargin + onClicked: { + internalManualBlindsList.remove(btnRemoveListBlind.modelIndex) + } + Rectangle { + anchors.fill: parent + color: mouseRemoveListBlind.pressed ? "#55555555" : "#00ffffff" + } + } + } + } + } + + Text { + font.pixelSize: AppStyle.selectorBoxValueFontSize + text: qsTr("Afterwards:") + } + + ExclusiveGroup { id: afterMBModeGroup } + RadioButton { + id: radioBtnAfterMBAlwaysDouble + exclusiveGroup: afterMBModeGroup + style: MyRadioButtonStyle { + myRadioBtn: radioBtnAfterMBAlwaysDouble + labelString: qsTr("always double blinds"); + } + } + RadioButton { + id: radioBtnAfterMBAlwaysRaiseAbout + exclusiveGroup: afterMBModeGroup + style: MyRadioButtonStyle { + myRadioBtn: radioBtnAfterMBAlwaysRaiseAbout + labelString: qsTr("always raise about"); + } + } + TextField { + id: textFieldAfterMBAlwaysRaiseAboutValue + //make space for the prefix + anchors.left: parent.left + anchors.leftMargin: AppStyle.spinBoxSelectorTextFieldPrefixExtraLeftMargin + width: radioBtnAfterMBAlwaysRaiseAbout.width + style: MyTextFieldStyle { + prefix: "$" + myTextField: textFieldAfterMBAlwaysRaiseAboutValue + } + function correctValue() { + text = GlobalTools.correctTextFieldIntegerValue(root, text, addBlindTextFieldMinValue, addBlindTextFieldMaxValue); + } + onFocusChanged: { if(root.ready && !focus) correctValue(); } + onEditingFinished: { if(root.ready) correctValue(); } + } + + RadioButton { + id: radioBtnAfterMBKeepLastBlind + exclusiveGroup: afterMBModeGroup + style: MyRadioButtonStyle { + myRadioBtn: radioBtnAfterMBKeepLastBlind + labelString: qsTr("keep last blind"); + } + } } } - } - Component.onCompleted: ready = true; + Component.onCompleted: { + ready = true; + } } diff --git a/src/gui/qml/components/MyComboBoxSelector.qml b/src/gui/qml/components/MyComboBoxSelector.qml index bf1b49b0..5a8a91c9 100644 --- a/src/gui/qml/components/MyComboBoxSelector.qml +++ b/src/gui/qml/components/MyComboBoxSelector.qml @@ -1,6 +1,7 @@ -import QtQuick 2.0 -import QtQuick.Layouts 1.1 +import QtQuick 2.5 import QtQuick.Controls 1.2 +import QtGraphicalEffects 1.0 +import QtQuick.Layouts 1.1 import QtQuick.Controls.Styles 1.2 import "../js/colors.js" as GlobalColors import "styles" @@ -9,7 +10,7 @@ Item { id: root anchors.fill: parent - property ListModel selectionModel: ListModel {} + property ListModel internalValuesList: ListModel {} property string valueFromParent property string titleString property string returnValue @@ -23,9 +24,9 @@ Item { returnValue = vl; // <-- initial the returnValue with the preselection to prevent a NULL return when pressing Cancel valueIsIndex = valueIndex; //fill the model - selectionModel.clear(); - for (var i=0; i < list.count; i++) { - selectionModel.append({"valueString": list.get(i).value}); + internalValuesList.clear(); + for (var i=0; i < list.length; i++) { + internalValuesList.append({"value": list[i]}); } mySelector.show() } @@ -48,22 +49,39 @@ Item { onButton1Clicked: hide() container: ScrollView { + id: scrollView anchors.fill:parent + property int yOfCheckedRadioButton: 0 ListView { + id:listView anchors.fill: parent spacing: Math.round(appWindow.height*0.05) - model: selectionModel + model: internalValuesList delegate: RadioButton { id: radioBtn //check of value is index type and do the corresponding checked? test - checked: valueIsIndex ? (parseInt(valueFromParent) == index ? true : false) : (valueFromParent == valueString ? true : false) + checked: valueIsIndex ? (parseInt(valueFromParent) == index ? true : false) : (valueFromParent == value ? true : false) onClicked: { - root.selected(valueString, index) + root.selected(value, index) } style: MyRadioButtonStyle { myRadioBtn: radioBtn - labelString: valueString + labelString: value } + Component.onCompleted: { + //set the position of the checked RadioButton to scroll to it later onContentHeightChange + if(checked) { + var checkedRadioBtnPositionY = Math.round((radioBtn.height + listView.spacing) * index - radioBtn.height * 1.5) + if( checkedRadioBtnPositionY > 0) + scrollView.yOfCheckedRadioButton = checkedRadioBtnPositionY + else + scrollView.yOfCheckedRadioButton = 0 + } + } + } + onContentHeightChanged: { + //scroll to the checked RadioButton + contentY = scrollView.yOfCheckedRadioButton } } } diff --git a/src/gui/qml/components/MyListViewDelegateFactory.qml b/src/gui/qml/components/MyListViewDelegateFactory.qml index 813a0d9e..a61e0698 100644 --- a/src/gui/qml/components/MyListViewDelegateFactory.qml +++ b/src/gui/qml/components/MyListViewDelegateFactory.qml @@ -15,9 +15,9 @@ Item { property var componentMap: { "ComboBox": myComboBox, - "SpinBox": mySpinBox, - "BlindsRaiseInterval": myBlindsRaiseInterval, - "BlindsRaiseMode": myBlindsRaiseMode + "SpinBox": mySpinBox, + "BlindsRaiseInterval": myBlindsRaiseInterval, + "BlindsRaiseMode": myBlindsRaiseMode } width: myListViewsWidth @@ -35,7 +35,7 @@ Item { MyComboBoxSelector { id: myComboBoxSelector parent: myListViewRoot // this needs to be parent to display the selector over the whole ListView - onAccepted: myListViewModel.setProperty(myComboBoxContent.modelIndex, "myValue", myComboBoxSelector.returnValue); + onAccepted: myListViewModel[myComboBoxContent.modelIndex].myValue = myComboBoxSelector.returnValue; } id: myComboBoxContent @@ -63,7 +63,7 @@ Item { color: "grey" font.pixelSize: myValue != "" ? AppStyle.listViewDelegateValueFontSize : 0 //setup value from Index if necessary - text: myValueIsIndex ? myValuesList.get(parseInt(myValue)).value : myValue + text: myValueIsIndex ? myValuesList[parseInt(myValue)].value : myValue Layout.preferredHeight: contentHeight } } @@ -96,7 +96,7 @@ Item { MySpinBoxSelector { id: mySpinBoxSelector parent: myListViewRoot // this needs to be parent to display the selector over the whole ListView - onAccepted: myListViewModel.setProperty(mySpinBoxContent.modelIndex, "myValue", mySpinBoxSelector.returnValue); + onAccepted: myListViewModel[mySpinBoxContent.modelIndex].myValue = mySpinBoxSelector.returnValue; } id: mySpinBoxContent @@ -159,9 +159,9 @@ Item { parent: myListViewRoot // this needs to be parent to display the selector over the whole ListView onAccepted: { //call update the currentItem with selection from the comboBox selector - myListViewModel.setProperty(myBlindsRaiseIntervalContent.modelIndex, "myRaiseOnHandsType", myBlindsRaiseIntervalSelector.raiseOnHandsType); - myListViewModel.setProperty(myBlindsRaiseIntervalContent.modelIndex, "myRaiseOnHandsInterval", myBlindsRaiseIntervalSelector.raiseOnHandsInterval); - myListViewModel.setProperty(myBlindsRaiseIntervalContent.modelIndex, "myRaiseOnMinutesInterval", myBlindsRaiseIntervalSelector.raiseOnMinutesInterval); + myListViewModel[myBlindsRaiseIntervalContent.modelIndex].myRaiseOnHandsType = myBlindsRaiseIntervalSelector.raiseOnHandsType; + myListViewModel[myBlindsRaiseIntervalContent.modelIndex].myRaiseOnHandsInterval = myBlindsRaiseIntervalSelector.raiseOnHandsInterval; + myListViewModel[myBlindsRaiseIntervalContent.modelIndex].myRaiseOnMinutesInterval = myBlindsRaiseIntervalSelector.raiseOnMinutesInterval; //here we also need to trigger the textStringBuild from the model again blindsRaiseIntevalValue.buildTextString(); } @@ -215,7 +215,7 @@ Item { anchors.fill: parent onClicked: { //call selector overlay and set inital values - myBlindsRaiseIntervalSelector.show(myTitle, myRaiseOnHandsType, myRaiseOnHandsInterval, myRaiseOnMinutesInterval) + myBlindsRaiseIntervalSelector.show(myTitle, myRaiseOnHandsType, myRaiseOnHandsInterval, myRaiseOnMinutesInterval, myListViewModel) } } @@ -234,7 +234,15 @@ Item { id: myBlindsRaiseModeSelector parent: myListViewRoot // this needs to be parent to display the selector over the whole ListView onAccepted: { - //TODO update model + //call update the currentItem with selection from the comboBox selector + myListViewModel[myBlindsRaiseModeContent.modelIndex].myAlwaysDoubleBlinds = (myBlindsRaiseModeSelector.alwaysDoubleBlinds ? "1" : "0"); + myListViewModel[myBlindsRaiseModeContent.modelIndex].myManualBlindsList = (myBlindsRaiseModeSelector.manualBlindsList); + myListViewModel[myBlindsRaiseModeContent.modelIndex].myAfterMBAlwaysDoubleBlinds = (myBlindsRaiseModeSelector.afterMBAlwaysDoubleBlinds ? "1" : "0"); + myListViewModel[myBlindsRaiseModeContent.modelIndex].myAfterMBAlwaysRaiseAbout = (myBlindsRaiseModeSelector.afterMBAlwaysRaiseAbout ? "1" : "0"); + myListViewModel[myBlindsRaiseModeContent.modelIndex].myAfterMBAlwaysRaiseValue = (myBlindsRaiseModeSelector.afterMBAlwaysRaiseValue); + myListViewModel[myBlindsRaiseModeContent.modelIndex].myAfterMBStayAtLastBlind = (myBlindsRaiseModeSelector.afterMBStayAtLastBlind ? "1" : "0"); + //here we also need to trigger the textStringBuild from the model again + blindsRaiseModeValue.buildTextString(); } } @@ -272,8 +280,8 @@ Item { else { //build manual blindsList var tempString = "" - for (var i=0; i < myManualBlindsList.count; i++) { - tempString = tempString + "$" + myManualBlindsList.get(i).blindValue.toString() + ", "; + for (var i=0; i < myManualBlindsList.length; i++) { + tempString = tempString + "$" + myManualBlindsList[i] + ", "; } text = tempString.substring(0, tempString.length - 2); if(myAfterMBAlwaysDoubleBlinds == "1") { @@ -304,8 +312,8 @@ Item { id: mouse anchors.fill: parent onClicked: { - // call selector overlay and set inital values - myBlindsRaiseModeSelector.show(myTitle, myAlwaysDoubleBlinds, myManualBlindsList, myAfterMBAlwaysDoubleBlinds, myAfterMBAlwaysRaiseAbout, myAfterMBAlwaysRaiseValue, myAfterMBStayAtLastBlind); + //call selector overlay and set inital values + myBlindsRaiseModeSelector.show(myTitle, myAlwaysDoubleBlinds == "1", myManualBlindsList, myAfterMBAlwaysDoubleBlinds == "1", myAfterMBAlwaysRaiseAbout == "1", myAfterMBAlwaysRaiseValue, myAfterMBStayAtLastBlind == "1", myListViewModel, myListViewRoot); } } diff --git a/src/gui/qml/components/MySpinBoxSelector.qml b/src/gui/qml/components/MySpinBoxSelector.qml index 4e4c15b2..94ed30e5 100644 --- a/src/gui/qml/components/MySpinBoxSelector.qml +++ b/src/gui/qml/components/MySpinBoxSelector.qml @@ -32,12 +32,11 @@ Item { prefix = myPrefix; mySelector.show() - textField.focus = true; +// textField.focus = true; } function selected(newSelection) { returnValue = newSelection; - mySelector.hide() root.accepted() } diff --git a/src/gui/qml/components/styles/AppStyle.qml b/src/gui/qml/components/styles/AppStyle.qml index aeac5aa2..0eade6fb 100644 --- a/src/gui/qml/components/styles/AppStyle.qml +++ b/src/gui/qml/components/styles/AppStyle.qml @@ -30,6 +30,8 @@ QtObject { property int selectorBoxTitleTopMargin: -Math.round(appHeight*0.02) property int selectorBoxValueFontSize: fontSizeH5 property int selectorBoxButtonFontSize: fontSizeH5 + property int selectorBoxButtonMouseAreaMargin: -Math.round(appHeight*0.02) + property int selectorBoxButtonRowLayoutSpacing: Math.round(appHeight*0.10) property bool selectorBoxButtonFontBold: false property int selectorBoxContentMargins: Math.round(appHeight*0.05) property int selectorBoxRealContentLeftMargin: Math.round(appHeight*0.05) diff --git a/src/gui/qml/cpp/createlocalgameviewimpl.cpp b/src/gui/qml/cpp/createlocalgameviewimpl.cpp index 45663529..2cc125d9 100644 --- a/src/gui/qml/cpp/createlocalgameviewimpl.cpp +++ b/src/gui/qml/cpp/createlocalgameviewimpl.cpp @@ -1,7 +1,114 @@ #include "createlocalgameviewimpl.h" +#include "configfile.h" +#include "mylistviewitemdata.h" +#include -CreateLocalGameViewImpl::CreateLocalGameViewImpl(QObject *parent) : QObject(parent) +CreateLocalGameViewImpl::CreateLocalGameViewImpl(QObject *parent, QQmlApplicationEngine *e, boost::shared_ptr c) + : QObject(parent) ,myQmlEngine(e), myConfig(c) +{ + //Build the listView data structure + MyListViewItemData *item = NULL; + + //ComboBox number of players + item = new MyListViewItemData; + item->setMyId("comboBox_NumberOfPlayers"); + item->setMyTitle(tr("Number of players")); + item->setMyType("ComboBox"); + const int n = 9; + for (int i = 10; i > (10-n); --i) item->appendToMyValuesList(QString::number(i)); + item->setMyValueIsIndex(false); + myListData.append(item); + + //SpinBox start cash- + item = new MyListViewItemData; + item->setMyId("spinBox_StartCash"); + item->setMyTitle(tr("Start cash")); + item->setMyType("SpinBox"); + item->setMyMaxValue("1000000"); + item->setMyMinValue("1000"); + item->setMyPrefix("$"); + myListData.append(item); + + //SpinBox start blind + item = new MyListViewItemData; + item->setMyId("spinBox_FirstSmallBlind"); + item->setMyTitle(tr("First small blind")); + item->setMyType("SpinBox"); + item->setMyMaxValue("20000"); + item->setMyMinValue("5"); + item->setMyPrefix("$"); + myListData.append(item); + + //Blinds raise interval selector + item = new MyListViewItemData; + item->setMyId("selector_BlindsRaiseInterval"); + item->setMyTitle(tr("Blinds raise interval")); + item->setMyType("BlindsRaiseInterval"); + myListData.append(item); + + //Blinds raise mode selector + item = new MyListViewItemData; + item->setMyId("selector_BlindsRaiseMode"); + item->setMyTitle(tr("Blinds raise mode")); + item->setMyType("BlindsRaiseMode"); + myListData.append(item); + + //ComboBox game speed + item = new MyListViewItemData; + item->setMyId("comboBox_GameSpeed"); + item->setMyTitle(tr("Game speed")); + item->setMyType("ComboBox"); + const int m = 11; + for (int i = 11; i > (11-m); --i) item->appendToMyValuesList(QString::number(i)); + item->setMyValueIsIndex(false); + myListData.append(item); + + myQmlEngine->rootContext()->setContextProperty("CreateLocalGameViewData", QVariant::fromValue(myListData)); +} + +CreateLocalGameViewImpl::~CreateLocalGameViewImpl() { } +MyListViewItemData* CreateLocalGameViewImpl::listItem(QString id) +{ + for (int i = 0; i < myListData.size(); ++i) { + if (static_cast(myListData.at(i))->myId() == id) + return static_cast(myListData.at(i)); + } + qDebug("ERROR: listItem in createLocalGameViewImpl could not be found"); + return NULL; +} + + +void CreateLocalGameViewImpl::readConfigValues() +{ + listItem("comboBox_NumberOfPlayers")->setMyValue(QString::number(myConfig->readConfigInt("NumberOfPlayers"))); + listItem("spinBox_StartCash")->setMyValue(QString::number(myConfig->readConfigInt("StartCash"))); + listItem("spinBox_FirstSmallBlind")->setMyValue(QString::number(myConfig->readConfigInt("FirstSmallBlind"))); + listItem("selector_BlindsRaiseInterval")->setMyRaiseOnHandsType(QString::number(myConfig->readConfigInt("RaiseBlindsAtHands"))); + listItem("selector_BlindsRaiseInterval")->setMyRaiseOnHandsInterval(QString::number(myConfig->readConfigInt("RaiseSmallBlindEveryHands"))); + listItem("selector_BlindsRaiseInterval")->setMyRaiseOnMinutesInterval(QString::number(myConfig->readConfigInt("RaiseSmallBlindEveryMinutes"))); + listItem("selector_BlindsRaiseMode")->setMyAlwaysDoubleBlinds(QString::number(myConfig->readConfigInt("AlwaysDoubleBlinds"))); + + std::list myList = myConfig->readConfigIntList("ManualBlindsList"); + std::list::iterator it1; + listItem("selector_BlindsRaiseMode")->clearMyManualBlindsList(); + for(it1= myList.begin(); it1 != myList.end(); ++it1) { + listItem("selector_BlindsRaiseMode")->appendToMyManualBlindsList(QString::number(*it1)); + } + + listItem("selector_BlindsRaiseMode")->setMyAfterMBAlwaysDoubleBlinds(QString::number(myConfig->readConfigInt("AfterMBAlwaysDoubleBlinds"))); + listItem("selector_BlindsRaiseMode")->setMyAfterMBAlwaysRaiseAbout(QString::number(myConfig->readConfigInt("AfterMBAlwaysRaiseAbout"))); + listItem("selector_BlindsRaiseMode")->setMyAfterMBAlwaysRaiseValue(QString::number(myConfig->readConfigInt("AfterMBAlwaysRaiseValue"))); + listItem("selector_BlindsRaiseMode")->setMyAfterMBStayAtLastBlind(QString::number(myConfig->readConfigInt("AfterMBStayAtLastBlind"))); + listItem("comboBox_GameSpeed")->setMyValue(QString::number(myConfig->readConfigInt("GameSpeed"))); + +} + +void CreateLocalGameViewImpl::startGame() +{ + qDebug() << "Start Game from CreateLocalGameViewImpl:"; + qDebug() << "Number of players: " << listItem("comboBox_NumberOfPlayers")->myValue(); +} diff --git a/src/gui/qml/cpp/createlocalgameviewimpl.h b/src/gui/qml/cpp/createlocalgameviewimpl.h index d01ea094..dd30ddd3 100644 --- a/src/gui/qml/cpp/createlocalgameviewimpl.h +++ b/src/gui/qml/cpp/createlocalgameviewimpl.h @@ -1,16 +1,32 @@ #ifndef CREATELOCALGAMEVIEWIMPL_H #define CREATELOCALGAMEVIEWIMPL_H +#include "boost/shared_ptr.hpp" #include +#include +#include + +class ConfigFile; +class MyListViewItemData; class CreateLocalGameViewImpl : public QObject { Q_OBJECT public: - explicit CreateLocalGameViewImpl(QObject *parent = 0); + Q_INVOKABLE void readConfigValues(); + Q_INVOKABLE void startGame(); + + CreateLocalGameViewImpl(QObject *parent, QQmlApplicationEngine *engine, boost::shared_ptr); + ~CreateLocalGameViewImpl(); + + MyListViewItemData* listItem(QString id); signals: public slots: +private: + QQmlApplicationEngine *myQmlEngine; + QList myListData; + boost::shared_ptr myConfig; }; #endif // CREATELOCALGAMEVIEWIMPL_H diff --git a/src/gui/qml/cpp/mylistviewitemdata.h b/src/gui/qml/cpp/mylistviewitemdata.h new file mode 100644 index 00000000..f312eff8 --- /dev/null +++ b/src/gui/qml/cpp/mylistviewitemdata.h @@ -0,0 +1,371 @@ +#ifndef MYLISTVIEWITEMDATA_H +#define MYLISTVIEWITEMDATA_H + +#include +#include + +class MyListViewItemData : public QObject +{ + Q_OBJECT + Q_PROPERTY(QString myId READ myId WRITE setMyId NOTIFY myIdChanged) + Q_PROPERTY(QString myTitle READ myTitle WRITE setMyTitle NOTIFY myTitleChanged) + Q_PROPERTY(QString myType READ myType WRITE setMyType NOTIFY myTypeChanged) + Q_PROPERTY(QString myValue READ myValue WRITE setMyValue NOTIFY myValueChanged) + + //ComboBox special + Q_PROPERTY(QStringList myValuesList READ myValuesList WRITE setMyValuesList NOTIFY myValuesListChanged) + Q_PROPERTY(bool myValueIsIndex READ myValueIsIndex WRITE setMyValueIsIndex NOTIFY myValueIsIndexChanged) + + //SpinBox special + Q_PROPERTY(QString myMaxValue READ myMaxValue WRITE setMyMaxValue NOTIFY myMaxValueChanged) + Q_PROPERTY(QString myMinValue READ myMinValue WRITE setMyMinValue NOTIFY myMinValueChanged) + Q_PROPERTY(QString myPrefix READ myPrefix WRITE setMyPrefix NOTIFY myPrefixChanged) + + //BlindsRaiseInterval-Selector special + Q_PROPERTY(QString myRaiseOnHandsType READ myRaiseOnHandsType WRITE setMyRaiseOnHandsType NOTIFY myRaiseOnHandsTypeChanged) + Q_PROPERTY(QString myRaiseOnHandsInterval READ myRaiseOnHandsInterval WRITE setMyRaiseOnHandsInterval NOTIFY myRaiseOnHandsIntervalChanged) + Q_PROPERTY(QString myRaiseOnMinutesInterval READ myRaiseOnMinutesInterval WRITE setMyRaiseOnMinutesInterval NOTIFY myRaiseOnMinutesIntervalChanged) + + //BlindsRaiseMode-Selector special + Q_PROPERTY(QString myAlwaysDoubleBlinds READ myAlwaysDoubleBlinds WRITE setMyAlwaysDoubleBlinds NOTIFY myAlwaysDoubleBlindsChanged) + Q_PROPERTY(QStringList myManualBlindsList READ myManualBlindsList WRITE setMyManualBlindsList NOTIFY myManualBlindsListChanged) + Q_PROPERTY(QString myAfterMBAlwaysDoubleBlinds READ myAfterMBAlwaysDoubleBlinds WRITE setMyAfterMBAlwaysDoubleBlinds NOTIFY myAfterMBAlwaysDoubleBlindsChanged) + Q_PROPERTY(QString myAfterMBAlwaysRaiseAbout READ myAfterMBAlwaysRaiseAbout WRITE setMyAfterMBAlwaysRaiseAbout NOTIFY myAfterMBAlwaysRaiseAboutChanged) + Q_PROPERTY(QString myAfterMBAlwaysRaiseValue READ myAfterMBAlwaysRaiseValue WRITE setMyAfterMBAlwaysRaiseValue NOTIFY myAfterMBAlwaysRaiseValueChanged) + Q_PROPERTY(QString myAfterMBStayAtLastBlind READ myAfterMBStayAtLastBlind WRITE setMyAfterMBStayAtLastBlind NOTIFY myAfterMBStayAtLastBlindChanged) + + QString m_myId; + + QString m_myTitle; + + QString m_myType; + + QString m_myValue; + + bool m_myValueIsIndex; + + QString m_myMaxValue; + + QString m_myMinValue; + + QString m_myPrefix; + + QString m_myRaiseOnHandsType; + + QString m_myRaiseOnHandsInterval; + + QString m_myRaiseOnMinutesInterval; + + QString m_myAlwaysDoubleBlinds; + + QString m_myAfterMBAlwaysDoubleBlinds; + + QString m_myAfterMBAlwaysRaiseAbout; + + QString m_myAfterMBStayAtLastBlind; + + QString m_myAfterMBAlwaysRaiseValue; + + QStringList m_myManualBlindsList; + + QStringList m_myValuesList; + +public: + inline MyListViewItemData(QObject *parent = 0) : QObject(parent) {} + inline ~MyListViewItemData() {} + + QString myId() const + { + return m_myId; + } + + QString myTitle() const + { + return m_myTitle; + } + + QString myType() const + { + return m_myType; + } + + QString myValue() const + { + return m_myValue; + } + + bool myValueIsIndex() const + { + return m_myValueIsIndex; + } + + QString myMaxValue() const + { + return m_myMaxValue; + } + + QString myMinValue() const + { + return m_myMinValue; + } + + QString myPrefix() const + { + return m_myPrefix; + } + + QString myRaiseOnHandsType() const + { + return m_myRaiseOnHandsType; + } + + QString myRaiseOnHandsInterval() const + { + return m_myRaiseOnHandsInterval; + } + + QString myRaiseOnMinutesInterval() const + { + return m_myRaiseOnMinutesInterval; + } + + QString myAlwaysDoubleBlinds() const + { + return m_myAlwaysDoubleBlinds; + } + + QString myAfterMBAlwaysDoubleBlinds() const + { + return m_myAfterMBAlwaysDoubleBlinds; + } + + QString myAfterMBAlwaysRaiseAbout() const + { + return m_myAfterMBAlwaysRaiseAbout; + } + + QString myAfterMBStayAtLastBlind() const + { + return m_myAfterMBStayAtLastBlind; + } + + QString myAfterMBAlwaysRaiseValue() const + { + return m_myAfterMBAlwaysRaiseValue; + } + + QStringList myManualBlindsList() const + { + return m_myManualBlindsList; + } + + void appendToMyManualBlindsList(QString str) + { + m_myManualBlindsList.append(str); + } + + void clearMyManualBlindsList() + { + m_myManualBlindsList.clear(); + } + + QStringList myValuesList() const + { + return m_myValuesList; + } + + void appendToMyValuesList(QString str) + { + m_myValuesList.append(str); + } + + void clearMyValuesList() + { + m_myValuesList.clear(); + } +signals: + + void myIdChanged(QString myId); + + void myTitleChanged(QString myTitle); + + void myTypeChanged(QString myType); + + void myValueChanged(QString myValue); + + void myValueIsIndexChanged(bool myValueIsIndex); + + void myMaxValueChanged(QString myMaxValue); + + void myMinValueChanged(QString myMinValue); + + void myPrefixChanged(QString myPrefix); + + void myRaiseOnHandsTypeChanged(QString myRaiseOnHandsType); + + void myRaiseOnHandsIntervalChanged(QString myRaiseOnHandsInterval); + + void myRaiseOnMinutesIntervalChanged(QString myRaiseOnMinutesInterval); + + void myAlwaysDoubleBlindsChanged(QString myAlwaysDoubleBlinds); + + void myAfterMBAlwaysDoubleBlindsChanged(QString myAfterMBAlwaysDoubleBlinds); + + void myAfterMBAlwaysRaiseAboutChanged(QString myAfterMBAlwaysRaiseAbout); + + void myAfterMBAlwaysRaiseValueChanged(QString myAfterMBAlwaysRaiseValue); + + void myAfterMBStayAtLastBlindChanged(QString myAfterMBStayAtLastBlind); + + void myManualBlindsListChanged(QStringList myManualBlindsList); + + void myValuesListChanged(QStringList myValuesList); + +public slots: + void setMyId(QString myId) + { + if (m_myId == myId) + return; + + m_myId = myId; + emit myIdChanged(myId); + } + void setMyTitle(QString myTitle) + { + if (m_myTitle == myTitle) + return; + + m_myTitle = myTitle; + emit myTitleChanged(myTitle); + } + void setMyType(QString myType) + { + if (m_myType == myType) + return; + + m_myType = myType; + emit myTypeChanged(myType); + } + void setMyValue(QString myValue) + { + if (m_myValue == myValue) + return; + + m_myValue = myValue; + emit myValueChanged(myValue); + } + void setMyValueIsIndex(bool myValueIsIndex) + { + if (m_myValueIsIndex == myValueIsIndex) + return; + + m_myValueIsIndex = myValueIsIndex; + emit myValueIsIndexChanged(myValueIsIndex); + } + void setMyMaxValue(QString myMaxValue) + { + if (m_myMaxValue == myMaxValue) + return; + + m_myMaxValue = myMaxValue; + emit myMaxValueChanged(myMaxValue); + } + void setMyMinValue(QString myMinValue) + { + if (m_myMinValue == myMinValue) + return; + + m_myMinValue = myMinValue; + emit myMinValueChanged(myMinValue); + } + void setMyPrefix(QString myPrefix) + { + if (m_myPrefix == myPrefix) + return; + + m_myPrefix = myPrefix; + emit myPrefixChanged(myPrefix); + } + void setMyRaiseOnHandsType(QString myRaiseOnHandsType) + { + if (m_myRaiseOnHandsType == myRaiseOnHandsType) + return; + + m_myRaiseOnHandsType = myRaiseOnHandsType; + emit myRaiseOnHandsTypeChanged(myRaiseOnHandsType); + } + void setMyRaiseOnHandsInterval(QString myRaiseOnHandsInterval) + { + if (m_myRaiseOnHandsInterval == myRaiseOnHandsInterval) + return; + + m_myRaiseOnHandsInterval = myRaiseOnHandsInterval; + emit myRaiseOnHandsIntervalChanged(myRaiseOnHandsInterval); + } + void setMyRaiseOnMinutesInterval(QString myRaiseOnMinutesInterval) + { + if (m_myRaiseOnMinutesInterval == myRaiseOnMinutesInterval) + return; + + m_myRaiseOnMinutesInterval = myRaiseOnMinutesInterval; + emit myRaiseOnMinutesIntervalChanged(myRaiseOnMinutesInterval); + } + void setMyAlwaysDoubleBlinds(QString myAlwaysDoubleBlinds) + { + if (m_myAlwaysDoubleBlinds == myAlwaysDoubleBlinds) + return; + + m_myAlwaysDoubleBlinds = myAlwaysDoubleBlinds; + emit myAlwaysDoubleBlindsChanged(myAlwaysDoubleBlinds); + } + void setMyAfterMBAlwaysDoubleBlinds(QString myAfterMBAlwaysDoubleBlinds) + { + if (m_myAfterMBAlwaysDoubleBlinds == myAfterMBAlwaysDoubleBlinds) + return; + + m_myAfterMBAlwaysDoubleBlinds = myAfterMBAlwaysDoubleBlinds; + emit myAfterMBAlwaysDoubleBlindsChanged(myAfterMBAlwaysDoubleBlinds); + } + void setMyAfterMBAlwaysRaiseAbout(QString myAfterMBAlwaysRaiseAbout) + { + if (m_myAfterMBAlwaysRaiseAbout == myAfterMBAlwaysRaiseAbout) + return; + + m_myAfterMBAlwaysRaiseAbout = myAfterMBAlwaysRaiseAbout; + emit myAfterMBAlwaysRaiseAboutChanged(myAfterMBAlwaysRaiseAbout); + } + void setMyAfterMBAlwaysRaiseValue(QString myAfterMBAlwaysRaiseValue) + { + if (m_myAfterMBAlwaysRaiseValue == myAfterMBAlwaysRaiseValue) + return; + + m_myAfterMBAlwaysRaiseValue = myAfterMBAlwaysRaiseValue; + emit myAfterMBAlwaysRaiseValueChanged(myAfterMBAlwaysRaiseValue); + } void setMyAfterMBStayAtLastBlind(QString myAfterMBStayAtLastBlind) + { + if (m_myAfterMBStayAtLastBlind == myAfterMBStayAtLastBlind) + return; + + m_myAfterMBStayAtLastBlind = myAfterMBStayAtLastBlind; + emit myAfterMBStayAtLastBlindChanged(myAfterMBStayAtLastBlind); + } + + void setMyManualBlindsList(QStringList myManualBlindsList) + { + if (m_myManualBlindsList == myManualBlindsList) + return; + + m_myManualBlindsList = myManualBlindsList; + emit myManualBlindsListChanged(myManualBlindsList); + } + void setMyValuesList(QStringList myValuesList) + { + if (m_myValuesList == myValuesList) + return; + + m_myValuesList = myValuesList; + emit myValuesListChanged(myValuesList); + } +}; + +#endif // MYLISTVIEWITEMDATA_H diff --git a/src/gui/qml/cpp/qmlwrapper.cpp b/src/gui/qml/cpp/qmlwrapper.cpp index a54a2a95..cfcf2c18 100644 --- a/src/gui/qml/cpp/qmlwrapper.cpp +++ b/src/gui/qml/cpp/qmlwrapper.cpp @@ -1,8 +1,8 @@ #include +#include #include #include #include -#include #include "qmlconfig.h" #include "qmlwrapper.h" @@ -12,24 +12,25 @@ QmlWrapper::QmlWrapper(boost::shared_ptr c) :QObject(), myConfig(c) { - myEngine.reset(new QQmlApplicationEngine); - myQmlConfig = new QmlConfig(myConfig); //need to be a default pointer because QML doesnt support shared_ptr() + myQmlEngine = new QQmlApplicationEngine; + myQmlConfig = new QmlConfig(myConfig); //TODO create Session and Log here myStartViewImpl = new StartViewImpl(this); - myCreateLocalGameViewImpl = new CreateLocalGameViewImpl(this); + myCreateLocalGameViewImpl = new CreateLocalGameViewImpl(this, myQmlEngine, myConfig); //Add c++ content to QML here - myEngine->rootContext()->setContextProperty("Config", myQmlConfig); - myEngine->rootContext()->setContextProperty("StartViewImpl", myStartViewImpl); + myQmlEngine->rootContext()->setContextProperty("Config", myQmlConfig); + myQmlEngine->rootContext()->setContextProperty("StartViewImpl", myStartViewImpl); + myQmlEngine->rootContext()->setContextProperty("CreateLocalGameViewImpl", myCreateLocalGameViewImpl); - myEngine->load(QUrl(QStringLiteral("qrc:/main.qml"))); + myQmlEngine->load(QUrl(QStringLiteral("qrc:/main.qml"))); } QmlWrapper::~QmlWrapper() { - myEngine->deleteLater(); + myQmlEngine->deleteLater(); } QmlWrapper::QmlWrapper(const QmlWrapper&) diff --git a/src/gui/qml/cpp/qmlwrapper.h b/src/gui/qml/cpp/qmlwrapper.h index 1b07ef90..0803a1b8 100644 --- a/src/gui/qml/cpp/qmlwrapper.h +++ b/src/gui/qml/cpp/qmlwrapper.h @@ -1,7 +1,7 @@ #ifndef QMLWRAPPER_H #define QMLWRAPPER_H #include -#include +#include "boost/shared_ptr.hpp" class QQmlApplicationEngine; class ConfigFile; @@ -20,7 +20,7 @@ public: public slots: private: - boost::shared_ptr myEngine; + QQmlApplicationEngine *myQmlEngine; boost::shared_ptr myConfig; QmlConfig *myQmlConfig; CreateLocalGameViewImpl *myCreateLocalGameViewImpl; diff --git a/src/gui/qml/cpp/startviewimpl.cpp b/src/gui/qml/cpp/startviewimpl.cpp index c2a5f9b1..fe0f02aa 100644 --- a/src/gui/qml/cpp/startviewimpl.cpp +++ b/src/gui/qml/cpp/startviewimpl.cpp @@ -1,10 +1,17 @@ #include "startviewimpl.h" +#include "mylistviewitemdata.h" StartViewImpl::StartViewImpl(QObject *parent) : QObject(parent) { } +StartViewImpl::~StartViewImpl() +{ + +} + + void StartViewImpl::startLocalGame() { qDebug("startLocalGame im c++"); diff --git a/src/gui/qml/cpp/startviewimpl.h b/src/gui/qml/cpp/startviewimpl.h index 5816d328..d92799ed 100644 --- a/src/gui/qml/cpp/startviewimpl.h +++ b/src/gui/qml/cpp/startviewimpl.h @@ -2,17 +2,22 @@ #define STARTVIEWIMPL_H #include +class CreateLocalGameViewImpl; + class StartViewImpl : public QObject { Q_OBJECT public: - explicit StartViewImpl(QObject *parent = 0); + StartViewImpl(QObject *parent = 0); + ~StartViewImpl(); signals: public slots: Q_INVOKABLE void startLocalGame(); +private: + }; #endif // STARTVIEWIMPL_H diff --git a/src/gui/qml/js/tools.js b/src/gui/qml/js/tools.js index 8cc8dc20..b5d9d93c 100644 --- a/src/gui/qml/js/tools.js +++ b/src/gui/qml/js/tools.js @@ -1,10 +1,13 @@ //global tools definition -function correctTextFieldIntegerValue(readyComponent, textValue, minValue) { +function correctTextFieldIntegerValue(readyComponent, textValue, minValue, maxValue) { if(readyComponent.ready) { var returnValue = ""; - if(textValue == "" || parseInt(textValue) == 0 || parseInt(textValue) < minValue) { - returnValue = minValue; + if(textValue == "" || parseInt(textValue) == 0 || isNaN(parseInt(textValue)) || parseInt(textValue) < parseInt(minValue)) { + returnValue = parseInt(minValue); + } + else if(maxValue && parseInt(textValue) > parseInt(maxValue)) { + returnValue = parseInt(maxValue); } else { returnValue = parseInt(textValue); //remove leading "0000" diff --git a/src/gui/qml/views/createlocalgameview/CreateLocalGameView.qml b/src/gui/qml/views/createlocalgameview/CreateLocalGameView.qml index 526df336..297f010f 100644 --- a/src/gui/qml/views/createlocalgameview/CreateLocalGameView.qml +++ b/src/gui/qml/views/createlocalgameview/CreateLocalGameView.qml @@ -6,6 +6,7 @@ import "../../components" Rectangle { id: createLocalGameViewRoot + property string myReadableId: "createLocalGameViewRoot" width: parent.width height: parent.height color: "#FAFAFA" @@ -17,124 +18,24 @@ Rectangle { ListView { id: createLocalGameViewList anchors.fill: parent - model: ListModel { - id: createLocalGameViewModel - ListElement { - myId: "comboBox_NumberOfPlayers" - myTitle: qsTr("Number of players") - myType: "ComboBox" - myValuesList: [ - ListElement { value: "10" }, - ListElement { value: "9" }, - ListElement { value: "8" }, - ListElement { value: "7" }, - ListElement { value: "6" }, - ListElement { value: "5" }, - ListElement { value: "4" }, - ListElement { value: "3" }, - ListElement { value: "2" } - ] - myValueIsIndex: false - myValue: "" - } - ListElement { - myId: "spinBox_StartCash" - myTitle: qsTr("Start cash") - myType: "SpinBox" - myMaxValue: "1000000" - myMinValue: "1000" - myPrefix: "$" - myValue: "" - } - ListElement { - myId: "spinBox_StartBlind" - myTitle: qsTr("Start blind") - myType: "SpinBox" - myMaxValue: "20000" - myMinValue: "5" - myPrefix: "$" - myValue: "" - } - ListElement { - myId: "selector_BlindsRaiseInterval" - myTitle: qsTr("Blinds raise interval") - myType: "BlindsRaiseInterval" - myRaiseOnHandsType: "" //if false it is raise on minutes type - myRaiseOnHandsInterval: "" - myRaiseOnMinutesInterval: "" - } - ListElement { - myId: "selector_BlindsRaiseMode" - myTitle: qsTr("Blinds raise mode") - myType: "BlindsRaiseMode" - myAlwaysDoubleBlinds: "" //if false it is "Manual Blinds Order" - myManualBlindsList: [] - myAfterMBAlwaysDoubleBlinds: "" - myAfterMBAlwaysRaiseAbout: "" - myAfterMBAlwaysRaiseValue: "" - myAfterMBStayAtLastBlind: "" - } - ListElement { - myId: "comboBox_GameSpeed" - myTitle: qsTr("Game speed") - myType: "ComboBox" - myValuesList: [ - ListElement { value: "11" }, - ListElement { value: "10" }, - ListElement { value: "9" }, - ListElement { value: "8" }, - ListElement { value: "7" }, - ListElement { value: "6" }, - ListElement { value: "5" }, - ListElement { value: "4" }, - ListElement { value: "3" }, - ListElement { value: "2" }, - ListElement { value: "1" } - ] - myValue: "" - myValueIsIndex: false - } - - Component.onCompleted: { - //set Config Values from config file - createLocalGameViewModel.setProperty(0, "myValue", Config.readConfigIntString("NumberOfPlayers")); - createLocalGameViewModel.setProperty(1, "myValue", Config.readConfigIntString("StartCash")); - createLocalGameViewModel.setProperty(2, "myValue", Config.readConfigIntString("FirstSmallBlind")); - createLocalGameViewModel.setProperty(3, "myRaiseOnHandsType", Config.readConfigIntString("RaiseBlindsAtHands")); - createLocalGameViewModel.setProperty(3, "myRaiseOnHandsInterval", Config.readConfigIntString("RaiseSmallBlindEveryHands")); - createLocalGameViewModel.setProperty(3, "myRaiseOnMinutesInterval", Config.readConfigIntString("RaiseSmallBlindEveryMinutes")); - createLocalGameViewModel.setProperty(4, "myAlwaysDoubleBlinds", Config.readConfigIntString("AlwaysDoubleBlinds")); - - var tempList = Config.readConfigIntStringList("ManualBlindsList"); - for(var i=0; i < tempList.length; i++) { - createLocalGameViewModel.get(4).myManualBlindsList.append({"blindValue": tempList[i].toString()}) - } - - createLocalGameViewModel.setProperty(4, "myAfterMBAlwaysDoubleBlinds", Config.readConfigIntString("AfterMBAlwaysDoubleBlinds")); - createLocalGameViewModel.setProperty(4, "myAfterMBAlwaysRaiseAbout", Config.readConfigIntString("AfterMBAlwaysRaiseAbout")); - createLocalGameViewModel.setProperty(4, "myAfterMBAlwaysRaiseValue", Config.readConfigIntString("AfterMBAlwaysRaiseValue")); - createLocalGameViewModel.setProperty(4, "myAfterMBStayAtLastBlind", Config.readConfigIntString("AfterMBStayAtLastBlind")); - createLocalGameViewModel.setProperty(5, "myValue", Config.readConfigIntString("GameSpeed")); - } - } + model: CreateLocalGameViewData delegate: MyListViewDelegateFactory { myListViewsHeight: createLocalGameViewList.height myListViewsWidth: createLocalGameViewList.width - myListViewRoot: createLocalGameViewRoot - myListViewModel: createLocalGameViewModel - -// TODO --> Blindsfelder immer mit anzeigen spezialfeld manual blinds settings direkt hier inline implementieren - - + myListViewRoot: createLocalGameViewRoot //set this to be able to display the selector over the whole view + myListViewModel: CreateLocalGameViewData + } + Component.onCompleted: { + CreateLocalGameViewImpl.readConfigValues() } } } function getListElementValueString(elementName) { //read model and check for the elementName - for (var i = 0; i < createLocalGameViewModel.count; i++ ) { - if(createLocalGameViewModel.get(i).myId == elementName) { - return createLocalGameViewModel.get(i).myValue; + for (var i = 0; i < CreateLocalGameViewData.lenght; i++ ) { + if(CreateLocalGameViewData[i].myId == elementName) { + return CreateLocalGameViewDat[i].myValue; } } } @@ -144,11 +45,11 @@ Rectangle { toolBarRightButton.myIconName = "accept"; toolBarLeftButton.myIconName = "back"; //send start signal to the session - toolBarRightButton.clicked.connect(StartViewImpl.startLocalGame); + toolBarRightButton.clicked.connect(CreateLocalGameViewImpl.startGame); } function clearToolBar() { - toolBarRightButton.clicked.disconnect(StartViewImpl.startLocalGame); + toolBarRightButton.clicked.disconnect(CreateLocalGameViewImpl.startGame); } Component.onCompleted: { diff --git a/src/third_party/protobuf/pokerth.pb.cc b/src/third_party/protobuf/pokerth.pb.cc index 8f66d0d5..26a96e4b 100644 --- a/src/third_party/protobuf/pokerth.pb.cc +++ b/src/third_party/protobuf/pokerth.pb.cc @@ -10,6 +10,7 @@ #include #include #include +#include // @@protoc_insertion_point(includes) void protobuf_ShutdownFile_pokerth_2eproto() { @@ -327,7 +328,7 @@ void protobuf_AddDesc_pokerth_2eproto() { #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_pokerth_2eproto_once_); void protobuf_AddDesc_pokerth_2eproto() { - ::google::protobuf::::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_pokerth_2eproto_once_, + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_pokerth_2eproto_once_, &protobuf_AddDesc_pokerth_2eproto_impl); } #else @@ -492,6 +493,7 @@ const int NetGameInfo::kAllowSpectatorsFieldNumber; NetGameInfo::NetGameInfo() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:NetGameInfo) } void NetGameInfo::InitAsDefaultInstance() { @@ -501,11 +503,13 @@ NetGameInfo::NetGameInfo(const NetGameInfo& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:NetGameInfo) } void NetGameInfo::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; - gamename_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + gamename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); netgametype_ = 1; maxnumplayers_ = 0u; raiseintervalmode_ = 1; @@ -523,11 +527,12 @@ void NetGameInfo::SharedCtor() { } NetGameInfo::~NetGameInfo() { + // @@protoc_insertion_point(destructor:NetGameInfo) SharedDtor(); } void NetGameInfo::SharedDtor() { - if (gamename_ != &::google::protobuf::internal::kEmptyString) { + if (gamename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete gamename_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -559,46 +564,63 @@ NetGameInfo* NetGameInfo::New() const { } void NetGameInfo::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 255) { + ZR_(raiseeveryhands_, raiseeveryminutes_); if (has_gamename()) { - if (gamename_ != &::google::protobuf::internal::kEmptyString) { + if (gamename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { gamename_->clear(); } } netgametype_ = 1; maxnumplayers_ = 0u; raiseintervalmode_ = 1; - raiseeveryhands_ = 0u; - raiseeveryminutes_ = 0u; endraisemode_ = 1; endraisesmallblindvalue_ = 0u; } - if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { - proposedguispeed_ = 0u; - delaybetweenhands_ = 0u; - playeractiontimeout_ = 0u; - firstsmallblind_ = 0u; - startmoney_ = 0u; + if (_has_bits_[8 / 32] & 24320) { + ZR_(proposedguispeed_, startmoney_); allowspectators_ = true; } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + manualblinds_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool NetGameInfo::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:NetGameInfo) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required string gameName = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_gamename())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_netGameType; break; @@ -606,8 +628,7 @@ bool NetGameInfo::MergePartialFromCodedStream( // required .NetGameInfo.NetGameType netGameType = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_netGameType: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -615,9 +636,12 @@ bool NetGameInfo::MergePartialFromCodedStream( input, &value))); if (::NetGameInfo_NetGameType_IsValid(value)) { set_netgametype(static_cast< ::NetGameInfo_NetGameType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_maxNumPlayers; break; @@ -625,15 +649,14 @@ bool NetGameInfo::MergePartialFromCodedStream( // required uint32 maxNumPlayers = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_maxNumPlayers: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &maxnumplayers_))); set_has_maxnumplayers(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_raiseIntervalMode; break; @@ -641,8 +664,7 @@ bool NetGameInfo::MergePartialFromCodedStream( // required .NetGameInfo.RaiseIntervalMode raiseIntervalMode = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_raiseIntervalMode: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -650,9 +672,12 @@ bool NetGameInfo::MergePartialFromCodedStream( input, &value))); if (::NetGameInfo_RaiseIntervalMode_IsValid(value)) { set_raiseintervalmode(static_cast< ::NetGameInfo_RaiseIntervalMode >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(40)) goto parse_raiseEveryHands; break; @@ -660,15 +685,14 @@ bool NetGameInfo::MergePartialFromCodedStream( // optional uint32 raiseEveryHands = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 40) { parse_raiseEveryHands: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &raiseeveryhands_))); set_has_raiseeveryhands(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(48)) goto parse_raiseEveryMinutes; break; @@ -676,15 +700,14 @@ bool NetGameInfo::MergePartialFromCodedStream( // optional uint32 raiseEveryMinutes = 6; case 6: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 48) { parse_raiseEveryMinutes: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &raiseeveryminutes_))); set_has_raiseeveryminutes(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(56)) goto parse_endRaiseMode; break; @@ -692,8 +715,7 @@ bool NetGameInfo::MergePartialFromCodedStream( // required .NetGameInfo.EndRaiseMode endRaiseMode = 7; case 7: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 56) { parse_endRaiseMode: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -701,9 +723,12 @@ bool NetGameInfo::MergePartialFromCodedStream( input, &value))); if (::NetGameInfo_EndRaiseMode_IsValid(value)) { set_endraisemode(static_cast< ::NetGameInfo_EndRaiseMode >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(64)) goto parse_endRaiseSmallBlindValue; break; @@ -711,15 +736,14 @@ bool NetGameInfo::MergePartialFromCodedStream( // optional uint32 endRaiseSmallBlindValue = 8; case 8: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 64) { parse_endRaiseSmallBlindValue: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &endraisesmallblindvalue_))); set_has_endraisesmallblindvalue(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(72)) goto parse_proposedGuiSpeed; break; @@ -727,15 +751,14 @@ bool NetGameInfo::MergePartialFromCodedStream( // required uint32 proposedGuiSpeed = 9; case 9: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 72) { parse_proposedGuiSpeed: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &proposedguispeed_))); set_has_proposedguispeed(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(80)) goto parse_delayBetweenHands; break; @@ -743,15 +766,14 @@ bool NetGameInfo::MergePartialFromCodedStream( // required uint32 delayBetweenHands = 10; case 10: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 80) { parse_delayBetweenHands: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &delaybetweenhands_))); set_has_delaybetweenhands(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(88)) goto parse_playerActionTimeout; break; @@ -759,15 +781,14 @@ bool NetGameInfo::MergePartialFromCodedStream( // required uint32 playerActionTimeout = 11; case 11: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 88) { parse_playerActionTimeout: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playeractiontimeout_))); set_has_playeractiontimeout(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(96)) goto parse_firstSmallBlind; break; @@ -775,15 +796,14 @@ bool NetGameInfo::MergePartialFromCodedStream( // required uint32 firstSmallBlind = 12; case 12: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 96) { parse_firstSmallBlind: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &firstsmallblind_))); set_has_firstsmallblind(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(104)) goto parse_startMoney; break; @@ -791,15 +811,14 @@ bool NetGameInfo::MergePartialFromCodedStream( // required uint32 startMoney = 13; case 13: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 104) { parse_startMoney: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &startmoney_))); set_has_startmoney(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(114)) goto parse_manualBlinds; break; @@ -807,20 +826,17 @@ bool NetGameInfo::MergePartialFromCodedStream( // repeated uint32 manualBlinds = 14 [packed = true]; case 14: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 114) { parse_manualBlinds: DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, this->mutable_manualblinds()))); - } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) - == ::google::protobuf::internal::WireFormatLite:: - WIRETYPE_VARINT) { + } else if (tag == 112) { DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( 1, 114, input, this->mutable_manualblinds()))); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(120)) goto parse_allowSpectators; break; @@ -828,40 +844,47 @@ bool NetGameInfo::MergePartialFromCodedStream( // optional bool allowSpectators = 15 [default = true]; case 15: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 120) { parse_allowSpectators: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &allowspectators_))); set_has_allowspectators(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:NetGameInfo) return true; +failure: + // @@protoc_insertion_point(parse_failure:NetGameInfo) + return false; #undef DO_ } void NetGameInfo::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:NetGameInfo) // required string gameName = 1; if (has_gamename()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 1, this->gamename(), output); } @@ -943,6 +966,9 @@ void NetGameInfo::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->allowspectators(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:NetGameInfo) } int NetGameInfo::ByteSize() const { @@ -1062,6 +1088,8 @@ int NetGameInfo::ByteSize() const { total_size += data_size; } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -1122,6 +1150,7 @@ void NetGameInfo::MergeFrom(const NetGameInfo& from) { set_allowspectators(from.allowspectators()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void NetGameInfo::CopyFrom(const NetGameInfo& from) { @@ -1154,6 +1183,7 @@ void NetGameInfo::Swap(NetGameInfo* other) { manualblinds_.Swap(&other->manualblinds_); std::swap(allowspectators_, other->allowspectators_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -1178,6 +1208,7 @@ const int PlayerResult::kCardsValueFieldNumber; PlayerResult::PlayerResult() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PlayerResult) } void PlayerResult::InitAsDefaultInstance() { @@ -1187,6 +1218,7 @@ PlayerResult::PlayerResult(const PlayerResult& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PlayerResult) } void PlayerResult::SharedCtor() { @@ -1201,6 +1233,7 @@ void PlayerResult::SharedCtor() { } PlayerResult::~PlayerResult() { + // @@protoc_insertion_point(destructor:PlayerResult) SharedDtor(); } @@ -1234,34 +1267,52 @@ PlayerResult* PlayerResult::New() const { } void PlayerResult::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - resultcard1_ = 0u; - resultcard2_ = 0u; - moneywon_ = 0u; - playermoney_ = 0u; - cardsvalue_ = 0u; +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 119) { + ZR_(playerid_, resultcard1_); + ZR_(resultcard2_, cardsvalue_); } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + besthandposition_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PlayerResult::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PlayerResult) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_resultCard1; break; @@ -1269,15 +1320,14 @@ bool PlayerResult::MergePartialFromCodedStream( // required uint32 resultCard1 = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_resultCard1: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &resultcard1_))); set_has_resultcard1(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_resultCard2; break; @@ -1285,15 +1335,14 @@ bool PlayerResult::MergePartialFromCodedStream( // required uint32 resultCard2 = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_resultCard2: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &resultcard2_))); set_has_resultcard2(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_bestHandPosition; break; @@ -1301,20 +1350,17 @@ bool PlayerResult::MergePartialFromCodedStream( // repeated uint32 bestHandPosition = 4 [packed = true]; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_bestHandPosition: DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, this->mutable_besthandposition()))); - } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) - == ::google::protobuf::internal::WireFormatLite:: - WIRETYPE_VARINT) { + } else if (tag == 32) { DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( 1, 34, input, this->mutable_besthandposition()))); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(40)) goto parse_moneyWon; break; @@ -1322,15 +1368,14 @@ bool PlayerResult::MergePartialFromCodedStream( // required uint32 moneyWon = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 40) { parse_moneyWon: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &moneywon_))); set_has_moneywon(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(48)) goto parse_playerMoney; break; @@ -1338,15 +1383,14 @@ bool PlayerResult::MergePartialFromCodedStream( // required uint32 playerMoney = 6; case 6: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 48) { parse_playerMoney: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playermoney_))); set_has_playermoney(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(56)) goto parse_cardsValue; break; @@ -1354,37 +1398,44 @@ bool PlayerResult::MergePartialFromCodedStream( // optional uint32 cardsValue = 7; case 7: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 56) { parse_cardsValue: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &cardsvalue_))); set_has_cardsvalue(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PlayerResult) return true; +failure: + // @@protoc_insertion_point(parse_failure:PlayerResult) + return false; #undef DO_ } void PlayerResult::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PlayerResult) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -1425,6 +1476,9 @@ void PlayerResult::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->cardsvalue(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PlayerResult) } int PlayerResult::ByteSize() const { @@ -1491,6 +1545,8 @@ int PlayerResult::ByteSize() const { total_size += data_size; } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -1525,6 +1581,7 @@ void PlayerResult::MergeFrom(const PlayerResult& from) { set_cardsvalue(from.cardsvalue()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void PlayerResult::CopyFrom(const PlayerResult& from) { @@ -1549,6 +1606,7 @@ void PlayerResult::Swap(PlayerResult* other) { std::swap(playermoney_, other->playermoney_); std::swap(cardsvalue_, other->cardsvalue_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -1587,6 +1645,7 @@ const int AnnounceMessage_Version::kMinorVersionFieldNumber; AnnounceMessage_Version::AnnounceMessage_Version() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AnnounceMessage.Version) } void AnnounceMessage_Version::InitAsDefaultInstance() { @@ -1596,6 +1655,7 @@ AnnounceMessage_Version::AnnounceMessage_Version(const AnnounceMessage_Version& : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AnnounceMessage.Version) } void AnnounceMessage_Version::SharedCtor() { @@ -1606,6 +1666,7 @@ void AnnounceMessage_Version::SharedCtor() { } AnnounceMessage_Version::~AnnounceMessage_Version() { + // @@protoc_insertion_point(destructor:AnnounceMessage.Version) SharedDtor(); } @@ -1639,29 +1700,48 @@ AnnounceMessage_Version* AnnounceMessage_Version::New() const { } void AnnounceMessage_Version::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - majorversion_ = 0u; - minorversion_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(majorversion_, minorversion_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AnnounceMessage_Version::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AnnounceMessage.Version) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 majorVersion = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &majorversion_))); set_has_majorversion(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_minorVersion; break; @@ -1669,37 +1749,44 @@ bool AnnounceMessage_Version::MergePartialFromCodedStream( // required uint32 minorVersion = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_minorVersion: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &minorversion_))); set_has_minorversion(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AnnounceMessage.Version) return true; +failure: + // @@protoc_insertion_point(parse_failure:AnnounceMessage.Version) + return false; #undef DO_ } void AnnounceMessage_Version::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AnnounceMessage.Version) // required uint32 majorVersion = 1; if (has_majorversion()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->majorversion(), output); @@ -1710,6 +1797,9 @@ void AnnounceMessage_Version::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->minorversion(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AnnounceMessage.Version) } int AnnounceMessage_Version::ByteSize() const { @@ -1731,6 +1821,8 @@ int AnnounceMessage_Version::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -1752,6 +1844,7 @@ void AnnounceMessage_Version::MergeFrom(const AnnounceMessage_Version& from) { set_minorversion(from.minorversion()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AnnounceMessage_Version::CopyFrom(const AnnounceMessage_Version& from) { @@ -1771,6 +1864,7 @@ void AnnounceMessage_Version::Swap(AnnounceMessage_Version* other) { std::swap(majorversion_, other->majorversion_); std::swap(minorversion_, other->minorversion_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -1793,6 +1887,7 @@ const int AnnounceMessage::kNumPlayersOnServerFieldNumber; AnnounceMessage::AnnounceMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AnnounceMessage) } void AnnounceMessage::InitAsDefaultInstance() { @@ -1814,6 +1909,7 @@ AnnounceMessage::AnnounceMessage(const AnnounceMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AnnounceMessage) } void AnnounceMessage::SharedCtor() { @@ -1827,6 +1923,7 @@ void AnnounceMessage::SharedCtor() { } AnnounceMessage::~AnnounceMessage() { + // @@protoc_insertion_point(destructor:AnnounceMessage) SharedDtor(); } @@ -1862,34 +1959,54 @@ AnnounceMessage* AnnounceMessage::New() const { } void AnnounceMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 31) { + ZR_(latestbetarevision_, numplayersonserver_); if (has_protocolversion()) { if (protocolversion_ != NULL) protocolversion_->::AnnounceMessage_Version::Clear(); } if (has_latestgameversion()) { if (latestgameversion_ != NULL) latestgameversion_->::AnnounceMessage_Version::Clear(); } - latestbetarevision_ = 0u; - servertype_ = 0; - numplayersonserver_ = 0u; } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AnnounceMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AnnounceMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .AnnounceMessage.Version protocolVersion = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_protocolversion())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_latestGameVersion; break; @@ -1897,13 +2014,12 @@ bool AnnounceMessage::MergePartialFromCodedStream( // required .AnnounceMessage.Version latestGameVersion = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_latestGameVersion: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_latestgameversion())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_latestBetaRevision; break; @@ -1911,15 +2027,14 @@ bool AnnounceMessage::MergePartialFromCodedStream( // required uint32 latestBetaRevision = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_latestBetaRevision: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &latestbetarevision_))); set_has_latestbetarevision(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_serverType; break; @@ -1927,8 +2042,7 @@ bool AnnounceMessage::MergePartialFromCodedStream( // required .AnnounceMessage.ServerType serverType = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_serverType: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -1936,9 +2050,12 @@ bool AnnounceMessage::MergePartialFromCodedStream( input, &value))); if (::AnnounceMessage_ServerType_IsValid(value)) { set_servertype(static_cast< ::AnnounceMessage_ServerType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(40)) goto parse_numPlayersOnServer; break; @@ -1946,37 +2063,44 @@ bool AnnounceMessage::MergePartialFromCodedStream( // required uint32 numPlayersOnServer = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 40) { parse_numPlayersOnServer: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &numplayersonserver_))); set_has_numplayersonserver(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AnnounceMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AnnounceMessage) + return false; #undef DO_ } void AnnounceMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AnnounceMessage) // required .AnnounceMessage.Version protocolVersion = 1; if (has_protocolversion()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( @@ -2005,6 +2129,9 @@ void AnnounceMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->numplayersonserver(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AnnounceMessage) } int AnnounceMessage::ByteSize() const { @@ -2046,6 +2173,8 @@ int AnnounceMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -2076,6 +2205,7 @@ void AnnounceMessage::MergeFrom(const AnnounceMessage& from) { set_numplayersonserver(from.numplayersonserver()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AnnounceMessage::CopyFrom(const AnnounceMessage& from) { @@ -2104,6 +2234,7 @@ void AnnounceMessage::Swap(AnnounceMessage* other) { std::swap(servertype_, other->servertype_); std::swap(numplayersonserver_, other->numplayersonserver_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -2148,6 +2279,7 @@ const int AuthClientRequestMessage::kAvatarHashFieldNumber; AuthClientRequestMessage::AuthClientRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AuthClientRequestMessage) } void AuthClientRequestMessage::InitAsDefaultInstance() { @@ -2163,39 +2295,42 @@ AuthClientRequestMessage::AuthClientRequestMessage(const AuthClientRequestMessag : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AuthClientRequestMessage) } void AuthClientRequestMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; requestedversion_ = NULL; buildid_ = 0u; login_ = 0; - authserverpassword_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - clientuserdata_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - mylastsessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + authserverpassword_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clientuserdata_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + mylastsessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } AuthClientRequestMessage::~AuthClientRequestMessage() { + // @@protoc_insertion_point(destructor:AuthClientRequestMessage) SharedDtor(); } void AuthClientRequestMessage::SharedDtor() { - if (authserverpassword_ != &::google::protobuf::internal::kEmptyString) { + if (authserverpassword_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete authserverpassword_; } - if (nickname_ != &::google::protobuf::internal::kEmptyString) { + if (nickname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete nickname_; } - if (clientuserdata_ != &::google::protobuf::internal::kEmptyString) { + if (clientuserdata_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete clientuserdata_; } - if (mylastsessionid_ != &::google::protobuf::internal::kEmptyString) { + if (mylastsessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete mylastsessionid_; } - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete avatarhash_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2228,55 +2363,76 @@ AuthClientRequestMessage* AuthClientRequestMessage::New() const { } void AuthClientRequestMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 255) { + ZR_(buildid_, login_); if (has_requestedversion()) { if (requestedversion_ != NULL) requestedversion_->::AnnounceMessage_Version::Clear(); } - buildid_ = 0u; - login_ = 0; if (has_authserverpassword()) { - if (authserverpassword_ != &::google::protobuf::internal::kEmptyString) { + if (authserverpassword_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { authserverpassword_->clear(); } } if (has_nickname()) { - if (nickname_ != &::google::protobuf::internal::kEmptyString) { + if (nickname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { nickname_->clear(); } } if (has_clientuserdata()) { - if (clientuserdata_ != &::google::protobuf::internal::kEmptyString) { + if (clientuserdata_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientuserdata_->clear(); } } if (has_mylastsessionid()) { - if (mylastsessionid_ != &::google::protobuf::internal::kEmptyString) { + if (mylastsessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { mylastsessionid_->clear(); } } if (has_avatarhash()) { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_->clear(); } } } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AuthClientRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AuthClientRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .AnnounceMessage.Version requestedVersion = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_requestedversion())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_buildId; break; @@ -2284,15 +2440,14 @@ bool AuthClientRequestMessage::MergePartialFromCodedStream( // required uint32 buildId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_buildId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &buildid_))); set_has_buildid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_login; break; @@ -2300,8 +2455,7 @@ bool AuthClientRequestMessage::MergePartialFromCodedStream( // required .AuthClientRequestMessage.LoginType login = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_login: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -2309,9 +2463,12 @@ bool AuthClientRequestMessage::MergePartialFromCodedStream( input, &value))); if (::AuthClientRequestMessage_LoginType_IsValid(value)) { set_login(static_cast< ::AuthClientRequestMessage_LoginType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_authServerPassword; break; @@ -2319,13 +2476,12 @@ bool AuthClientRequestMessage::MergePartialFromCodedStream( // optional string authServerPassword = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_authServerPassword: DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_authserverpassword())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(42)) goto parse_nickName; break; @@ -2333,13 +2489,12 @@ bool AuthClientRequestMessage::MergePartialFromCodedStream( // optional string nickName = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 42) { parse_nickName: DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_nickname())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(50)) goto parse_clientUserData; break; @@ -2347,13 +2502,12 @@ bool AuthClientRequestMessage::MergePartialFromCodedStream( // optional bytes clientUserData = 6; case 6: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 50) { parse_clientUserData: DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_clientuserdata())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(58)) goto parse_myLastSessionId; break; @@ -2361,13 +2515,12 @@ bool AuthClientRequestMessage::MergePartialFromCodedStream( // optional bytes myLastSessionId = 7; case 7: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 58) { parse_myLastSessionId: DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_mylastsessionid())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(66)) goto parse_avatarHash; break; @@ -2375,35 +2528,42 @@ bool AuthClientRequestMessage::MergePartialFromCodedStream( // optional bytes avatarHash = 8; case 8: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 66) { parse_avatarHash: DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_avatarhash())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AuthClientRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AuthClientRequestMessage) + return false; #undef DO_ } void AuthClientRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AuthClientRequestMessage) // required .AnnounceMessage.Version requestedVersion = 1; if (has_requestedversion()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( @@ -2423,34 +2583,37 @@ void AuthClientRequestMessage::SerializeWithCachedSizes( // optional string authServerPassword = 4; if (has_authserverpassword()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 4, this->authserverpassword(), output); } // optional string nickName = 5; if (has_nickname()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 5, this->nickname(), output); } // optional bytes clientUserData = 6; if (has_clientuserdata()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 6, this->clientuserdata(), output); } // optional bytes myLastSessionId = 7; if (has_mylastsessionid()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 7, this->mylastsessionid(), output); } // optional bytes avatarHash = 8; if (has_avatarhash()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 8, this->avatarhash(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AuthClientRequestMessage) } int AuthClientRequestMessage::ByteSize() const { @@ -2513,6 +2676,8 @@ int AuthClientRequestMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -2552,6 +2717,7 @@ void AuthClientRequestMessage::MergeFrom(const AuthClientRequestMessage& from) { set_avatarhash(from.avatarhash()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AuthClientRequestMessage::CopyFrom(const AuthClientRequestMessage& from) { @@ -2580,6 +2746,7 @@ void AuthClientRequestMessage::Swap(AuthClientRequestMessage* other) { std::swap(mylastsessionid_, other->mylastsessionid_); std::swap(avatarhash_, other->avatarhash_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -2598,6 +2765,7 @@ const int AuthServerChallengeMessage::kServerChallengeFieldNumber; AuthServerChallengeMessage::AuthServerChallengeMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AuthServerChallengeMessage) } void AuthServerChallengeMessage::InitAsDefaultInstance() { @@ -2607,20 +2775,23 @@ AuthServerChallengeMessage::AuthServerChallengeMessage(const AuthServerChallenge : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AuthServerChallengeMessage) } void AuthServerChallengeMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; - serverchallenge_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + serverchallenge_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } AuthServerChallengeMessage::~AuthServerChallengeMessage() { + // @@protoc_insertion_point(destructor:AuthServerChallengeMessage) SharedDtor(); } void AuthServerChallengeMessage::SharedDtor() { - if (serverchallenge_ != &::google::protobuf::internal::kEmptyString) { + if (serverchallenge_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete serverchallenge_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2652,58 +2823,75 @@ AuthServerChallengeMessage* AuthServerChallengeMessage::New() const { } void AuthServerChallengeMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - if (has_serverchallenge()) { - if (serverchallenge_ != &::google::protobuf::internal::kEmptyString) { - serverchallenge_->clear(); - } + if (has_serverchallenge()) { + if (serverchallenge_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + serverchallenge_->clear(); } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AuthServerChallengeMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AuthServerChallengeMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required bytes serverChallenge = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_serverchallenge())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AuthServerChallengeMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AuthServerChallengeMessage) + return false; #undef DO_ } void AuthServerChallengeMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AuthServerChallengeMessage) // required bytes serverChallenge = 1; if (has_serverchallenge()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 1, this->serverchallenge(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AuthServerChallengeMessage) } int AuthServerChallengeMessage::ByteSize() const { @@ -2718,6 +2906,8 @@ int AuthServerChallengeMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -2736,6 +2926,7 @@ void AuthServerChallengeMessage::MergeFrom(const AuthServerChallengeMessage& fro set_serverchallenge(from.serverchallenge()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AuthServerChallengeMessage::CopyFrom(const AuthServerChallengeMessage& from) { @@ -2754,6 +2945,7 @@ void AuthServerChallengeMessage::Swap(AuthServerChallengeMessage* other) { if (other != this) { std::swap(serverchallenge_, other->serverchallenge_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -2772,6 +2964,7 @@ const int AuthClientResponseMessage::kClientResponseFieldNumber; AuthClientResponseMessage::AuthClientResponseMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AuthClientResponseMessage) } void AuthClientResponseMessage::InitAsDefaultInstance() { @@ -2781,20 +2974,23 @@ AuthClientResponseMessage::AuthClientResponseMessage(const AuthClientResponseMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AuthClientResponseMessage) } void AuthClientResponseMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; - clientresponse_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clientresponse_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } AuthClientResponseMessage::~AuthClientResponseMessage() { + // @@protoc_insertion_point(destructor:AuthClientResponseMessage) SharedDtor(); } void AuthClientResponseMessage::SharedDtor() { - if (clientresponse_ != &::google::protobuf::internal::kEmptyString) { + if (clientresponse_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete clientresponse_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2826,58 +3022,75 @@ AuthClientResponseMessage* AuthClientResponseMessage::New() const { } void AuthClientResponseMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - if (has_clientresponse()) { - if (clientresponse_ != &::google::protobuf::internal::kEmptyString) { - clientresponse_->clear(); - } + if (has_clientresponse()) { + if (clientresponse_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + clientresponse_->clear(); } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AuthClientResponseMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AuthClientResponseMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required bytes clientResponse = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_clientresponse())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AuthClientResponseMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AuthClientResponseMessage) + return false; #undef DO_ } void AuthClientResponseMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AuthClientResponseMessage) // required bytes clientResponse = 1; if (has_clientresponse()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 1, this->clientresponse(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AuthClientResponseMessage) } int AuthClientResponseMessage::ByteSize() const { @@ -2892,6 +3105,8 @@ int AuthClientResponseMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -2910,6 +3125,7 @@ void AuthClientResponseMessage::MergeFrom(const AuthClientResponseMessage& from) set_clientresponse(from.clientresponse()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AuthClientResponseMessage::CopyFrom(const AuthClientResponseMessage& from) { @@ -2928,6 +3144,7 @@ void AuthClientResponseMessage::Swap(AuthClientResponseMessage* other) { if (other != this) { std::swap(clientresponse_, other->clientresponse_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -2946,6 +3163,7 @@ const int AuthServerVerificationMessage::kServerVerificationFieldNumber; AuthServerVerificationMessage::AuthServerVerificationMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AuthServerVerificationMessage) } void AuthServerVerificationMessage::InitAsDefaultInstance() { @@ -2955,20 +3173,23 @@ AuthServerVerificationMessage::AuthServerVerificationMessage(const AuthServerVer : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AuthServerVerificationMessage) } void AuthServerVerificationMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; - serververification_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + serververification_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } AuthServerVerificationMessage::~AuthServerVerificationMessage() { + // @@protoc_insertion_point(destructor:AuthServerVerificationMessage) SharedDtor(); } void AuthServerVerificationMessage::SharedDtor() { - if (serververification_ != &::google::protobuf::internal::kEmptyString) { + if (serververification_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete serververification_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3000,58 +3221,75 @@ AuthServerVerificationMessage* AuthServerVerificationMessage::New() const { } void AuthServerVerificationMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - if (has_serververification()) { - if (serververification_ != &::google::protobuf::internal::kEmptyString) { - serververification_->clear(); - } + if (has_serververification()) { + if (serververification_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + serververification_->clear(); } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AuthServerVerificationMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AuthServerVerificationMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required bytes serverVerification = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_serververification())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AuthServerVerificationMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AuthServerVerificationMessage) + return false; #undef DO_ } void AuthServerVerificationMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AuthServerVerificationMessage) // required bytes serverVerification = 1; if (has_serververification()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 1, this->serververification(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AuthServerVerificationMessage) } int AuthServerVerificationMessage::ByteSize() const { @@ -3066,6 +3304,8 @@ int AuthServerVerificationMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -3084,6 +3324,7 @@ void AuthServerVerificationMessage::MergeFrom(const AuthServerVerificationMessag set_serververification(from.serververification()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AuthServerVerificationMessage::CopyFrom(const AuthServerVerificationMessage& from) { @@ -3102,6 +3343,7 @@ void AuthServerVerificationMessage::Swap(AuthServerVerificationMessage* other) { if (other != this) { std::swap(serververification_, other->serververification_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -3123,6 +3365,7 @@ const int InitDoneMessage::kRejoinGameIdFieldNumber; InitDoneMessage::InitDoneMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:InitDoneMessage) } void InitDoneMessage::InitAsDefaultInstance() { @@ -3132,26 +3375,29 @@ InitDoneMessage::InitDoneMessage(const InitDoneMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:InitDoneMessage) } void InitDoneMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; - yoursessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + yoursessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); yourplayerid_ = 0u; - youravatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + youravatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); rejoingameid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } InitDoneMessage::~InitDoneMessage() { + // @@protoc_insertion_point(destructor:InitDoneMessage) SharedDtor(); } void InitDoneMessage::SharedDtor() { - if (yoursessionid_ != &::google::protobuf::internal::kEmptyString) { + if (yoursessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete yoursessionid_; } - if (youravatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (youravatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete youravatarhash_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3183,37 +3429,58 @@ InitDoneMessage* InitDoneMessage::New() const { } void InitDoneMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 15) { + ZR_(yourplayerid_, rejoingameid_); if (has_yoursessionid()) { - if (yoursessionid_ != &::google::protobuf::internal::kEmptyString) { + if (yoursessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { yoursessionid_->clear(); } } - yourplayerid_ = 0u; if (has_youravatarhash()) { - if (youravatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (youravatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { youravatarhash_->clear(); } } - rejoingameid_ = 0u; } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool InitDoneMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:InitDoneMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required bytes yourSessionId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_yoursessionid())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_yourPlayerId; break; @@ -3221,15 +3488,14 @@ bool InitDoneMessage::MergePartialFromCodedStream( // required uint32 yourPlayerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_yourPlayerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &yourplayerid_))); set_has_yourplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_yourAvatarHash; break; @@ -3237,13 +3503,12 @@ bool InitDoneMessage::MergePartialFromCodedStream( // optional bytes yourAvatarHash = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_yourAvatarHash: DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_youravatarhash())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_rejoinGameId; break; @@ -3251,40 +3516,47 @@ bool InitDoneMessage::MergePartialFromCodedStream( // optional uint32 rejoinGameId = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_rejoinGameId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &rejoingameid_))); set_has_rejoingameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:InitDoneMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:InitDoneMessage) + return false; #undef DO_ } void InitDoneMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:InitDoneMessage) // required bytes yourSessionId = 1; if (has_yoursessionid()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 1, this->yoursessionid(), output); } @@ -3295,7 +3567,7 @@ void InitDoneMessage::SerializeWithCachedSizes( // optional bytes yourAvatarHash = 3; if (has_youravatarhash()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 3, this->youravatarhash(), output); } @@ -3304,6 +3576,9 @@ void InitDoneMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->rejoingameid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:InitDoneMessage) } int InitDoneMessage::ByteSize() const { @@ -3339,6 +3614,8 @@ int InitDoneMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -3366,6 +3643,7 @@ void InitDoneMessage::MergeFrom(const InitDoneMessage& from) { set_rejoingameid(from.rejoingameid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void InitDoneMessage::CopyFrom(const InitDoneMessage& from) { @@ -3387,6 +3665,7 @@ void InitDoneMessage::Swap(InitDoneMessage* other) { std::swap(youravatarhash_, other->youravatarhash_); std::swap(rejoingameid_, other->rejoingameid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -3406,6 +3685,7 @@ const int AvatarRequestMessage::kAvatarHashFieldNumber; AvatarRequestMessage::AvatarRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AvatarRequestMessage) } void AvatarRequestMessage::InitAsDefaultInstance() { @@ -3415,21 +3695,24 @@ AvatarRequestMessage::AvatarRequestMessage(const AvatarRequestMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AvatarRequestMessage) } void AvatarRequestMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; requestid_ = 0u; - avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } AvatarRequestMessage::~AvatarRequestMessage() { + // @@protoc_insertion_point(destructor:AvatarRequestMessage) SharedDtor(); } void AvatarRequestMessage::SharedDtor() { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete avatarhash_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3461,33 +3744,41 @@ AvatarRequestMessage* AvatarRequestMessage::New() const { } void AvatarRequestMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { requestid_ = 0u; if (has_avatarhash()) { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_->clear(); } } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AvatarRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AvatarRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 requestId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &requestid_))); set_has_requestid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_avatarHash; break; @@ -3495,35 +3786,42 @@ bool AvatarRequestMessage::MergePartialFromCodedStream( // required bytes avatarHash = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_avatarHash: DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_avatarhash())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AvatarRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AvatarRequestMessage) + return false; #undef DO_ } void AvatarRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AvatarRequestMessage) // required uint32 requestId = 1; if (has_requestid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output); @@ -3531,10 +3829,13 @@ void AvatarRequestMessage::SerializeWithCachedSizes( // required bytes avatarHash = 2; if (has_avatarhash()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 2, this->avatarhash(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AvatarRequestMessage) } int AvatarRequestMessage::ByteSize() const { @@ -3556,6 +3857,8 @@ int AvatarRequestMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -3577,6 +3880,7 @@ void AvatarRequestMessage::MergeFrom(const AvatarRequestMessage& from) { set_avatarhash(from.avatarhash()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AvatarRequestMessage::CopyFrom(const AvatarRequestMessage& from) { @@ -3596,6 +3900,7 @@ void AvatarRequestMessage::Swap(AvatarRequestMessage* other) { std::swap(requestid_, other->requestid_); std::swap(avatarhash_, other->avatarhash_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -3616,6 +3921,7 @@ const int AvatarHeaderMessage::kAvatarSizeFieldNumber; AvatarHeaderMessage::AvatarHeaderMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AvatarHeaderMessage) } void AvatarHeaderMessage::InitAsDefaultInstance() { @@ -3625,6 +3931,7 @@ AvatarHeaderMessage::AvatarHeaderMessage(const AvatarHeaderMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AvatarHeaderMessage) } void AvatarHeaderMessage::SharedCtor() { @@ -3636,6 +3943,7 @@ void AvatarHeaderMessage::SharedCtor() { } AvatarHeaderMessage::~AvatarHeaderMessage() { + // @@protoc_insertion_point(destructor:AvatarHeaderMessage) SharedDtor(); } @@ -3669,30 +3977,38 @@ AvatarHeaderMessage* AvatarHeaderMessage::New() const { } void AvatarHeaderMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 7) { requestid_ = 0u; avatartype_ = 1; avatarsize_ = 0u; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AvatarHeaderMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AvatarHeaderMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 requestId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &requestid_))); set_has_requestid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_avatarType; break; @@ -3700,8 +4016,7 @@ bool AvatarHeaderMessage::MergePartialFromCodedStream( // required .NetAvatarType avatarType = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_avatarType: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -3709,9 +4024,12 @@ bool AvatarHeaderMessage::MergePartialFromCodedStream( input, &value))); if (::NetAvatarType_IsValid(value)) { set_avatartype(static_cast< ::NetAvatarType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_avatarSize; break; @@ -3719,37 +4037,44 @@ bool AvatarHeaderMessage::MergePartialFromCodedStream( // required uint32 avatarSize = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_avatarSize: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &avatarsize_))); set_has_avatarsize(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AvatarHeaderMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AvatarHeaderMessage) + return false; #undef DO_ } void AvatarHeaderMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AvatarHeaderMessage) // required uint32 requestId = 1; if (has_requestid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output); @@ -3766,6 +4091,9 @@ void AvatarHeaderMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->avatarsize(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AvatarHeaderMessage) } int AvatarHeaderMessage::ByteSize() const { @@ -3793,6 +4121,8 @@ int AvatarHeaderMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -3817,6 +4147,7 @@ void AvatarHeaderMessage::MergeFrom(const AvatarHeaderMessage& from) { set_avatarsize(from.avatarsize()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AvatarHeaderMessage::CopyFrom(const AvatarHeaderMessage& from) { @@ -3837,6 +4168,7 @@ void AvatarHeaderMessage::Swap(AvatarHeaderMessage* other) { std::swap(avatartype_, other->avatartype_); std::swap(avatarsize_, other->avatarsize_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -3856,6 +4188,7 @@ const int AvatarDataMessage::kAvatarBlockFieldNumber; AvatarDataMessage::AvatarDataMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AvatarDataMessage) } void AvatarDataMessage::InitAsDefaultInstance() { @@ -3865,21 +4198,24 @@ AvatarDataMessage::AvatarDataMessage(const AvatarDataMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AvatarDataMessage) } void AvatarDataMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; requestid_ = 0u; - avatarblock_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarblock_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } AvatarDataMessage::~AvatarDataMessage() { + // @@protoc_insertion_point(destructor:AvatarDataMessage) SharedDtor(); } void AvatarDataMessage::SharedDtor() { - if (avatarblock_ != &::google::protobuf::internal::kEmptyString) { + if (avatarblock_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete avatarblock_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3911,33 +4247,41 @@ AvatarDataMessage* AvatarDataMessage::New() const { } void AvatarDataMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { requestid_ = 0u; if (has_avatarblock()) { - if (avatarblock_ != &::google::protobuf::internal::kEmptyString) { + if (avatarblock_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarblock_->clear(); } } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AvatarDataMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AvatarDataMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 requestId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &requestid_))); set_has_requestid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_avatarBlock; break; @@ -3945,35 +4289,42 @@ bool AvatarDataMessage::MergePartialFromCodedStream( // required bytes avatarBlock = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_avatarBlock: DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_avatarblock())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AvatarDataMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AvatarDataMessage) + return false; #undef DO_ } void AvatarDataMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AvatarDataMessage) // required uint32 requestId = 1; if (has_requestid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output); @@ -3981,10 +4332,13 @@ void AvatarDataMessage::SerializeWithCachedSizes( // required bytes avatarBlock = 2; if (has_avatarblock()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 2, this->avatarblock(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AvatarDataMessage) } int AvatarDataMessage::ByteSize() const { @@ -4006,6 +4360,8 @@ int AvatarDataMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -4027,6 +4383,7 @@ void AvatarDataMessage::MergeFrom(const AvatarDataMessage& from) { set_avatarblock(from.avatarblock()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AvatarDataMessage::CopyFrom(const AvatarDataMessage& from) { @@ -4046,6 +4403,7 @@ void AvatarDataMessage::Swap(AvatarDataMessage* other) { std::swap(requestid_, other->requestid_); std::swap(avatarblock_, other->avatarblock_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -4064,6 +4422,7 @@ const int AvatarEndMessage::kRequestIdFieldNumber; AvatarEndMessage::AvatarEndMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AvatarEndMessage) } void AvatarEndMessage::InitAsDefaultInstance() { @@ -4073,6 +4432,7 @@ AvatarEndMessage::AvatarEndMessage(const AvatarEndMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AvatarEndMessage) } void AvatarEndMessage::SharedCtor() { @@ -4082,6 +4442,7 @@ void AvatarEndMessage::SharedCtor() { } AvatarEndMessage::~AvatarEndMessage() { + // @@protoc_insertion_point(destructor:AvatarEndMessage) SharedDtor(); } @@ -4115,55 +4476,72 @@ AvatarEndMessage* AvatarEndMessage::New() const { } void AvatarEndMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - requestid_ = 0u; - } + requestid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AvatarEndMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AvatarEndMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 requestId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &requestid_))); set_has_requestid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AvatarEndMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AvatarEndMessage) + return false; #undef DO_ } void AvatarEndMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AvatarEndMessage) // required uint32 requestId = 1; if (has_requestid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AvatarEndMessage) } int AvatarEndMessage::ByteSize() const { @@ -4178,6 +4556,8 @@ int AvatarEndMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -4196,6 +4576,7 @@ void AvatarEndMessage::MergeFrom(const AvatarEndMessage& from) { set_requestid(from.requestid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AvatarEndMessage::CopyFrom(const AvatarEndMessage& from) { @@ -4214,6 +4595,7 @@ void AvatarEndMessage::Swap(AvatarEndMessage* other) { if (other != this) { std::swap(requestid_, other->requestid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -4232,6 +4614,7 @@ const int UnknownAvatarMessage::kRequestIdFieldNumber; UnknownAvatarMessage::UnknownAvatarMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:UnknownAvatarMessage) } void UnknownAvatarMessage::InitAsDefaultInstance() { @@ -4241,6 +4624,7 @@ UnknownAvatarMessage::UnknownAvatarMessage(const UnknownAvatarMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:UnknownAvatarMessage) } void UnknownAvatarMessage::SharedCtor() { @@ -4250,6 +4634,7 @@ void UnknownAvatarMessage::SharedCtor() { } UnknownAvatarMessage::~UnknownAvatarMessage() { + // @@protoc_insertion_point(destructor:UnknownAvatarMessage) SharedDtor(); } @@ -4283,55 +4668,72 @@ UnknownAvatarMessage* UnknownAvatarMessage::New() const { } void UnknownAvatarMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - requestid_ = 0u; - } + requestid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool UnknownAvatarMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:UnknownAvatarMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 requestId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &requestid_))); set_has_requestid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:UnknownAvatarMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:UnknownAvatarMessage) + return false; #undef DO_ } void UnknownAvatarMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:UnknownAvatarMessage) // required uint32 requestId = 1; if (has_requestid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:UnknownAvatarMessage) } int UnknownAvatarMessage::ByteSize() const { @@ -4346,6 +4748,8 @@ int UnknownAvatarMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -4364,6 +4768,7 @@ void UnknownAvatarMessage::MergeFrom(const UnknownAvatarMessage& from) { set_requestid(from.requestid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void UnknownAvatarMessage::CopyFrom(const UnknownAvatarMessage& from) { @@ -4382,6 +4787,7 @@ void UnknownAvatarMessage::Swap(UnknownAvatarMessage* other) { if (other != this) { std::swap(requestid_, other->requestid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -4418,6 +4824,7 @@ const int PlayerListMessage::kPlayerListNotificationFieldNumber; PlayerListMessage::PlayerListMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PlayerListMessage) } void PlayerListMessage::InitAsDefaultInstance() { @@ -4427,6 +4834,7 @@ PlayerListMessage::PlayerListMessage(const PlayerListMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PlayerListMessage) } void PlayerListMessage::SharedCtor() { @@ -4437,6 +4845,7 @@ void PlayerListMessage::SharedCtor() { } PlayerListMessage::~PlayerListMessage() { + // @@protoc_insertion_point(destructor:PlayerListMessage) SharedDtor(); } @@ -4470,29 +4879,48 @@ PlayerListMessage* PlayerListMessage::New() const { } void PlayerListMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - playerlistnotification_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(playerid_, playerlistnotification_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PlayerListMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PlayerListMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_playerListNotification; break; @@ -4500,8 +4928,7 @@ bool PlayerListMessage::MergePartialFromCodedStream( // required .PlayerListMessage.PlayerListNotification playerListNotification = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_playerListNotification: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -4509,31 +4936,42 @@ bool PlayerListMessage::MergePartialFromCodedStream( input, &value))); if (::PlayerListMessage_PlayerListNotification_IsValid(value)) { set_playerlistnotification(static_cast< ::PlayerListMessage_PlayerListNotification >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PlayerListMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:PlayerListMessage) + return false; #undef DO_ } void PlayerListMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PlayerListMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -4545,6 +4983,9 @@ void PlayerListMessage::SerializeWithCachedSizes( 2, this->playerlistnotification(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PlayerListMessage) } int PlayerListMessage::ByteSize() const { @@ -4565,6 +5006,8 @@ int PlayerListMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -4586,6 +5029,7 @@ void PlayerListMessage::MergeFrom(const PlayerListMessage& from) { set_playerlistnotification(from.playerlistnotification()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void PlayerListMessage::CopyFrom(const PlayerListMessage& from) { @@ -4605,6 +5049,7 @@ void PlayerListMessage::Swap(PlayerListMessage* other) { std::swap(playerid_, other->playerid_); std::swap(playerlistnotification_, other->playerlistnotification_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -4629,6 +5074,7 @@ const int GameListNewMessage::kSpectatorIdsFieldNumber; GameListNewMessage::GameListNewMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameListNewMessage) } void GameListNewMessage::InitAsDefaultInstance() { @@ -4644,6 +5090,7 @@ GameListNewMessage::GameListNewMessage(const GameListNewMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameListNewMessage) } void GameListNewMessage::SharedCtor() { @@ -4657,6 +5104,7 @@ void GameListNewMessage::SharedCtor() { } GameListNewMessage::~GameListNewMessage() { + // @@protoc_insertion_point(destructor:GameListNewMessage) SharedDtor(); } @@ -4691,36 +5139,57 @@ GameListNewMessage* GameListNewMessage::New() const { } void GameListNewMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 55) { + ZR_(isprivate_, adminplayerid_); gameid_ = 0u; gamemode_ = 1; - isprivate_ = false; - adminplayerid_ = 0u; if (has_gameinfo()) { if (gameinfo_ != NULL) gameinfo_->::NetGameInfo::Clear(); } } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + playerids_.Clear(); spectatorids_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameListNewMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameListNewMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_gameMode; break; @@ -4728,8 +5197,7 @@ bool GameListNewMessage::MergePartialFromCodedStream( // required .NetGameMode gameMode = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_gameMode: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -4737,9 +5205,12 @@ bool GameListNewMessage::MergePartialFromCodedStream( input, &value))); if (::NetGameMode_IsValid(value)) { set_gamemode(static_cast< ::NetGameMode >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_isPrivate; break; @@ -4747,15 +5218,14 @@ bool GameListNewMessage::MergePartialFromCodedStream( // required bool isPrivate = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_isPrivate: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &isprivate_))); set_has_isprivate(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_playerIds; break; @@ -4763,20 +5233,17 @@ bool GameListNewMessage::MergePartialFromCodedStream( // repeated uint32 playerIds = 4 [packed = true]; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_playerIds: DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, this->mutable_playerids()))); - } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) - == ::google::protobuf::internal::WireFormatLite:: - WIRETYPE_VARINT) { + } else if (tag == 32) { DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( 1, 34, input, this->mutable_playerids()))); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(40)) goto parse_adminPlayerId; break; @@ -4784,15 +5251,14 @@ bool GameListNewMessage::MergePartialFromCodedStream( // required uint32 adminPlayerId = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 40) { parse_adminPlayerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &adminplayerid_))); set_has_adminplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(50)) goto parse_gameInfo; break; @@ -4800,13 +5266,12 @@ bool GameListNewMessage::MergePartialFromCodedStream( // required .NetGameInfo gameInfo = 6; case 6: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 50) { parse_gameInfo: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gameinfo())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(58)) goto parse_spectatorIds; break; @@ -4814,42 +5279,47 @@ bool GameListNewMessage::MergePartialFromCodedStream( // repeated uint32 spectatorIds = 7 [packed = true]; case 7: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 58) { parse_spectatorIds: DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, this->mutable_spectatorids()))); - } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) - == ::google::protobuf::internal::WireFormatLite:: - WIRETYPE_VARINT) { + } else if (tag == 56) { DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( 1, 58, input, this->mutable_spectatorids()))); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameListNewMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameListNewMessage) + return false; #undef DO_ } void GameListNewMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameListNewMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -4897,6 +5367,9 @@ void GameListNewMessage::SerializeWithCachedSizes( this->spectatorids(i), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameListNewMessage) } int GameListNewMessage::ByteSize() const { @@ -4970,6 +5443,8 @@ int GameListNewMessage::ByteSize() const { total_size += data_size; } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -5002,6 +5477,7 @@ void GameListNewMessage::MergeFrom(const GameListNewMessage& from) { mutable_gameinfo()->::NetGameInfo::MergeFrom(from.gameinfo()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameListNewMessage::CopyFrom(const GameListNewMessage& from) { @@ -5029,6 +5505,7 @@ void GameListNewMessage::Swap(GameListNewMessage* other) { std::swap(gameinfo_, other->gameinfo_); spectatorids_.Swap(&other->spectatorids_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -5048,6 +5525,7 @@ const int GameListUpdateMessage::kGameModeFieldNumber; GameListUpdateMessage::GameListUpdateMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameListUpdateMessage) } void GameListUpdateMessage::InitAsDefaultInstance() { @@ -5057,6 +5535,7 @@ GameListUpdateMessage::GameListUpdateMessage(const GameListUpdateMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameListUpdateMessage) } void GameListUpdateMessage::SharedCtor() { @@ -5067,6 +5546,7 @@ void GameListUpdateMessage::SharedCtor() { } GameListUpdateMessage::~GameListUpdateMessage() { + // @@protoc_insertion_point(destructor:GameListUpdateMessage) SharedDtor(); } @@ -5100,29 +5580,37 @@ GameListUpdateMessage* GameListUpdateMessage::New() const { } void GameListUpdateMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { gameid_ = 0u; gamemode_ = 1; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameListUpdateMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameListUpdateMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_gameMode; break; @@ -5130,8 +5618,7 @@ bool GameListUpdateMessage::MergePartialFromCodedStream( // required .NetGameMode gameMode = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_gameMode: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -5139,31 +5626,42 @@ bool GameListUpdateMessage::MergePartialFromCodedStream( input, &value))); if (::NetGameMode_IsValid(value)) { set_gamemode(static_cast< ::NetGameMode >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameListUpdateMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameListUpdateMessage) + return false; #undef DO_ } void GameListUpdateMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameListUpdateMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -5175,6 +5673,9 @@ void GameListUpdateMessage::SerializeWithCachedSizes( 2, this->gamemode(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameListUpdateMessage) } int GameListUpdateMessage::ByteSize() const { @@ -5195,6 +5696,8 @@ int GameListUpdateMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -5216,6 +5719,7 @@ void GameListUpdateMessage::MergeFrom(const GameListUpdateMessage& from) { set_gamemode(from.gamemode()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameListUpdateMessage::CopyFrom(const GameListUpdateMessage& from) { @@ -5235,6 +5739,7 @@ void GameListUpdateMessage::Swap(GameListUpdateMessage* other) { std::swap(gameid_, other->gameid_); std::swap(gamemode_, other->gamemode_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -5254,6 +5759,7 @@ const int GameListPlayerJoinedMessage::kPlayerIdFieldNumber; GameListPlayerJoinedMessage::GameListPlayerJoinedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameListPlayerJoinedMessage) } void GameListPlayerJoinedMessage::InitAsDefaultInstance() { @@ -5263,6 +5769,7 @@ GameListPlayerJoinedMessage::GameListPlayerJoinedMessage(const GameListPlayerJoi : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameListPlayerJoinedMessage) } void GameListPlayerJoinedMessage::SharedCtor() { @@ -5273,6 +5780,7 @@ void GameListPlayerJoinedMessage::SharedCtor() { } GameListPlayerJoinedMessage::~GameListPlayerJoinedMessage() { + // @@protoc_insertion_point(destructor:GameListPlayerJoinedMessage) SharedDtor(); } @@ -5306,29 +5814,48 @@ GameListPlayerJoinedMessage* GameListPlayerJoinedMessage::New() const { } void GameListPlayerJoinedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - playerid_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, playerid_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameListPlayerJoinedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameListPlayerJoinedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_playerId; break; @@ -5336,37 +5863,44 @@ bool GameListPlayerJoinedMessage::MergePartialFromCodedStream( // required uint32 playerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_playerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameListPlayerJoinedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameListPlayerJoinedMessage) + return false; #undef DO_ } void GameListPlayerJoinedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameListPlayerJoinedMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -5377,6 +5911,9 @@ void GameListPlayerJoinedMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameListPlayerJoinedMessage) } int GameListPlayerJoinedMessage::ByteSize() const { @@ -5398,6 +5935,8 @@ int GameListPlayerJoinedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -5419,6 +5958,7 @@ void GameListPlayerJoinedMessage::MergeFrom(const GameListPlayerJoinedMessage& f set_playerid(from.playerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameListPlayerJoinedMessage::CopyFrom(const GameListPlayerJoinedMessage& from) { @@ -5438,6 +5978,7 @@ void GameListPlayerJoinedMessage::Swap(GameListPlayerJoinedMessage* other) { std::swap(gameid_, other->gameid_); std::swap(playerid_, other->playerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -5457,6 +5998,7 @@ const int GameListPlayerLeftMessage::kPlayerIdFieldNumber; GameListPlayerLeftMessage::GameListPlayerLeftMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameListPlayerLeftMessage) } void GameListPlayerLeftMessage::InitAsDefaultInstance() { @@ -5466,6 +6008,7 @@ GameListPlayerLeftMessage::GameListPlayerLeftMessage(const GameListPlayerLeftMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameListPlayerLeftMessage) } void GameListPlayerLeftMessage::SharedCtor() { @@ -5476,6 +6019,7 @@ void GameListPlayerLeftMessage::SharedCtor() { } GameListPlayerLeftMessage::~GameListPlayerLeftMessage() { + // @@protoc_insertion_point(destructor:GameListPlayerLeftMessage) SharedDtor(); } @@ -5509,29 +6053,48 @@ GameListPlayerLeftMessage* GameListPlayerLeftMessage::New() const { } void GameListPlayerLeftMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - playerid_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, playerid_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameListPlayerLeftMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameListPlayerLeftMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_playerId; break; @@ -5539,37 +6102,44 @@ bool GameListPlayerLeftMessage::MergePartialFromCodedStream( // required uint32 playerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_playerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameListPlayerLeftMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameListPlayerLeftMessage) + return false; #undef DO_ } void GameListPlayerLeftMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameListPlayerLeftMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -5580,6 +6150,9 @@ void GameListPlayerLeftMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameListPlayerLeftMessage) } int GameListPlayerLeftMessage::ByteSize() const { @@ -5601,6 +6174,8 @@ int GameListPlayerLeftMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -5622,6 +6197,7 @@ void GameListPlayerLeftMessage::MergeFrom(const GameListPlayerLeftMessage& from) set_playerid(from.playerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameListPlayerLeftMessage::CopyFrom(const GameListPlayerLeftMessage& from) { @@ -5641,6 +6217,7 @@ void GameListPlayerLeftMessage::Swap(GameListPlayerLeftMessage* other) { std::swap(gameid_, other->gameid_); std::swap(playerid_, other->playerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -5660,6 +6237,7 @@ const int GameListSpectatorJoinedMessage::kPlayerIdFieldNumber; GameListSpectatorJoinedMessage::GameListSpectatorJoinedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameListSpectatorJoinedMessage) } void GameListSpectatorJoinedMessage::InitAsDefaultInstance() { @@ -5669,6 +6247,7 @@ GameListSpectatorJoinedMessage::GameListSpectatorJoinedMessage(const GameListSpe : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameListSpectatorJoinedMessage) } void GameListSpectatorJoinedMessage::SharedCtor() { @@ -5679,6 +6258,7 @@ void GameListSpectatorJoinedMessage::SharedCtor() { } GameListSpectatorJoinedMessage::~GameListSpectatorJoinedMessage() { + // @@protoc_insertion_point(destructor:GameListSpectatorJoinedMessage) SharedDtor(); } @@ -5712,29 +6292,48 @@ GameListSpectatorJoinedMessage* GameListSpectatorJoinedMessage::New() const { } void GameListSpectatorJoinedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - playerid_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, playerid_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameListSpectatorJoinedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameListSpectatorJoinedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_playerId; break; @@ -5742,37 +6341,44 @@ bool GameListSpectatorJoinedMessage::MergePartialFromCodedStream( // required uint32 playerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_playerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameListSpectatorJoinedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameListSpectatorJoinedMessage) + return false; #undef DO_ } void GameListSpectatorJoinedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameListSpectatorJoinedMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -5783,6 +6389,9 @@ void GameListSpectatorJoinedMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameListSpectatorJoinedMessage) } int GameListSpectatorJoinedMessage::ByteSize() const { @@ -5804,6 +6413,8 @@ int GameListSpectatorJoinedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -5825,6 +6436,7 @@ void GameListSpectatorJoinedMessage::MergeFrom(const GameListSpectatorJoinedMess set_playerid(from.playerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameListSpectatorJoinedMessage::CopyFrom(const GameListSpectatorJoinedMessage& from) { @@ -5844,6 +6456,7 @@ void GameListSpectatorJoinedMessage::Swap(GameListSpectatorJoinedMessage* other) std::swap(gameid_, other->gameid_); std::swap(playerid_, other->playerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -5863,6 +6476,7 @@ const int GameListSpectatorLeftMessage::kPlayerIdFieldNumber; GameListSpectatorLeftMessage::GameListSpectatorLeftMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameListSpectatorLeftMessage) } void GameListSpectatorLeftMessage::InitAsDefaultInstance() { @@ -5872,6 +6486,7 @@ GameListSpectatorLeftMessage::GameListSpectatorLeftMessage(const GameListSpectat : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameListSpectatorLeftMessage) } void GameListSpectatorLeftMessage::SharedCtor() { @@ -5882,6 +6497,7 @@ void GameListSpectatorLeftMessage::SharedCtor() { } GameListSpectatorLeftMessage::~GameListSpectatorLeftMessage() { + // @@protoc_insertion_point(destructor:GameListSpectatorLeftMessage) SharedDtor(); } @@ -5915,29 +6531,48 @@ GameListSpectatorLeftMessage* GameListSpectatorLeftMessage::New() const { } void GameListSpectatorLeftMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - playerid_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, playerid_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameListSpectatorLeftMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameListSpectatorLeftMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_playerId; break; @@ -5945,37 +6580,44 @@ bool GameListSpectatorLeftMessage::MergePartialFromCodedStream( // required uint32 playerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_playerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameListSpectatorLeftMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameListSpectatorLeftMessage) + return false; #undef DO_ } void GameListSpectatorLeftMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameListSpectatorLeftMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -5986,6 +6628,9 @@ void GameListSpectatorLeftMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameListSpectatorLeftMessage) } int GameListSpectatorLeftMessage::ByteSize() const { @@ -6007,6 +6652,8 @@ int GameListSpectatorLeftMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -6028,6 +6675,7 @@ void GameListSpectatorLeftMessage::MergeFrom(const GameListSpectatorLeftMessage& set_playerid(from.playerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameListSpectatorLeftMessage::CopyFrom(const GameListSpectatorLeftMessage& from) { @@ -6047,6 +6695,7 @@ void GameListSpectatorLeftMessage::Swap(GameListSpectatorLeftMessage* other) { std::swap(gameid_, other->gameid_); std::swap(playerid_, other->playerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -6066,6 +6715,7 @@ const int GameListAdminChangedMessage::kNewAdminPlayerIdFieldNumber; GameListAdminChangedMessage::GameListAdminChangedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameListAdminChangedMessage) } void GameListAdminChangedMessage::InitAsDefaultInstance() { @@ -6075,6 +6725,7 @@ GameListAdminChangedMessage::GameListAdminChangedMessage(const GameListAdminChan : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameListAdminChangedMessage) } void GameListAdminChangedMessage::SharedCtor() { @@ -6085,6 +6736,7 @@ void GameListAdminChangedMessage::SharedCtor() { } GameListAdminChangedMessage::~GameListAdminChangedMessage() { + // @@protoc_insertion_point(destructor:GameListAdminChangedMessage) SharedDtor(); } @@ -6118,29 +6770,48 @@ GameListAdminChangedMessage* GameListAdminChangedMessage::New() const { } void GameListAdminChangedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - newadminplayerid_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, newadminplayerid_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameListAdminChangedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameListAdminChangedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_newAdminPlayerId; break; @@ -6148,37 +6819,44 @@ bool GameListAdminChangedMessage::MergePartialFromCodedStream( // required uint32 newAdminPlayerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_newAdminPlayerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &newadminplayerid_))); set_has_newadminplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameListAdminChangedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameListAdminChangedMessage) + return false; #undef DO_ } void GameListAdminChangedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameListAdminChangedMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -6189,6 +6867,9 @@ void GameListAdminChangedMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->newadminplayerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameListAdminChangedMessage) } int GameListAdminChangedMessage::ByteSize() const { @@ -6210,6 +6891,8 @@ int GameListAdminChangedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -6231,6 +6914,7 @@ void GameListAdminChangedMessage::MergeFrom(const GameListAdminChangedMessage& f set_newadminplayerid(from.newadminplayerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameListAdminChangedMessage::CopyFrom(const GameListAdminChangedMessage& from) { @@ -6250,6 +6934,7 @@ void GameListAdminChangedMessage::Swap(GameListAdminChangedMessage* other) { std::swap(gameid_, other->gameid_); std::swap(newadminplayerid_, other->newadminplayerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -6268,6 +6953,7 @@ const int PlayerInfoRequestMessage::kPlayerIdFieldNumber; PlayerInfoRequestMessage::PlayerInfoRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PlayerInfoRequestMessage) } void PlayerInfoRequestMessage::InitAsDefaultInstance() { @@ -6277,6 +6963,7 @@ PlayerInfoRequestMessage::PlayerInfoRequestMessage(const PlayerInfoRequestMessag : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PlayerInfoRequestMessage) } void PlayerInfoRequestMessage::SharedCtor() { @@ -6285,6 +6972,7 @@ void PlayerInfoRequestMessage::SharedCtor() { } PlayerInfoRequestMessage::~PlayerInfoRequestMessage() { + // @@protoc_insertion_point(destructor:PlayerInfoRequestMessage) SharedDtor(); } @@ -6320,51 +7008,65 @@ PlayerInfoRequestMessage* PlayerInfoRequestMessage::New() const { void PlayerInfoRequestMessage::Clear() { playerid_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PlayerInfoRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PlayerInfoRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // repeated uint32 playerId = 1 [packed = true]; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, this->mutable_playerid()))); - } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) - == ::google::protobuf::internal::WireFormatLite:: - WIRETYPE_VARINT) { + } else if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( 1, 10, input, this->mutable_playerid()))); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PlayerInfoRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:PlayerInfoRequestMessage) + return false; #undef DO_ } void PlayerInfoRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PlayerInfoRequestMessage) // repeated uint32 playerId = 1 [packed = true]; if (this->playerid_size() > 0) { ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); @@ -6375,6 +7077,9 @@ void PlayerInfoRequestMessage::SerializeWithCachedSizes( this->playerid(i), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PlayerInfoRequestMessage) } int PlayerInfoRequestMessage::ByteSize() const { @@ -6397,6 +7102,8 @@ int PlayerInfoRequestMessage::ByteSize() const { total_size += data_size; } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -6411,6 +7118,7 @@ void PlayerInfoRequestMessage::CheckTypeAndMergeFrom( void PlayerInfoRequestMessage::MergeFrom(const PlayerInfoRequestMessage& from) { GOOGLE_CHECK_NE(&from, this); playerid_.MergeFrom(from.playerid_); + mutable_unknown_fields()->append(from.unknown_fields()); } void PlayerInfoRequestMessage::CopyFrom(const PlayerInfoRequestMessage& from) { @@ -6428,6 +7136,7 @@ void PlayerInfoRequestMessage::Swap(PlayerInfoRequestMessage* other) { if (other != this) { playerid_.Swap(&other->playerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -6447,6 +7156,7 @@ const int PlayerInfoReplyMessage_PlayerInfoData_AvatarData::kAvatarHashFieldNumb PlayerInfoReplyMessage_PlayerInfoData_AvatarData::PlayerInfoReplyMessage_PlayerInfoData_AvatarData() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PlayerInfoReplyMessage.PlayerInfoData.AvatarData) } void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::InitAsDefaultInstance() { @@ -6456,21 +7166,24 @@ PlayerInfoReplyMessage_PlayerInfoData_AvatarData::PlayerInfoReplyMessage_PlayerI : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PlayerInfoReplyMessage.PlayerInfoData.AvatarData) } void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; avatartype_ = 1; - avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } PlayerInfoReplyMessage_PlayerInfoData_AvatarData::~PlayerInfoReplyMessage_PlayerInfoData_AvatarData() { + // @@protoc_insertion_point(destructor:PlayerInfoReplyMessage.PlayerInfoData.AvatarData) SharedDtor(); } void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::SharedDtor() { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete avatarhash_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6502,36 +7215,47 @@ PlayerInfoReplyMessage_PlayerInfoData_AvatarData* PlayerInfoReplyMessage_PlayerI } void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { avatartype_ = 1; if (has_avatarhash()) { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_->clear(); } } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PlayerInfoReplyMessage_PlayerInfoData_AvatarData::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PlayerInfoReplyMessage.PlayerInfoData.AvatarData) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .NetAvatarType avatarType = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::NetAvatarType_IsValid(value)) { set_avatartype(static_cast< ::NetAvatarType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_avatarHash; break; @@ -6539,35 +7263,42 @@ bool PlayerInfoReplyMessage_PlayerInfoData_AvatarData::MergePartialFromCodedStre // required bytes avatarHash = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_avatarHash: DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_avatarhash())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PlayerInfoReplyMessage.PlayerInfoData.AvatarData) return true; +failure: + // @@protoc_insertion_point(parse_failure:PlayerInfoReplyMessage.PlayerInfoData.AvatarData) + return false; #undef DO_ } void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PlayerInfoReplyMessage.PlayerInfoData.AvatarData) // required .NetAvatarType avatarType = 1; if (has_avatartype()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -6576,10 +7307,13 @@ void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::SerializeWithCachedSizes( // required bytes avatarHash = 2; if (has_avatarhash()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 2, this->avatarhash(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PlayerInfoReplyMessage.PlayerInfoData.AvatarData) } int PlayerInfoReplyMessage_PlayerInfoData_AvatarData::ByteSize() const { @@ -6600,6 +7334,8 @@ int PlayerInfoReplyMessage_PlayerInfoData_AvatarData::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -6621,6 +7357,7 @@ void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::MergeFrom(const PlayerInf set_avatarhash(from.avatarhash()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::CopyFrom(const PlayerInfoReplyMessage_PlayerInfoData_AvatarData& from) { @@ -6640,6 +7377,7 @@ void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::Swap(PlayerInfoReplyMessa std::swap(avatartype_, other->avatartype_); std::swap(avatarhash_, other->avatarhash_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -6662,6 +7400,7 @@ const int PlayerInfoReplyMessage_PlayerInfoData::kAvatarDataFieldNumber; PlayerInfoReplyMessage_PlayerInfoData::PlayerInfoReplyMessage_PlayerInfoData() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PlayerInfoReplyMessage.PlayerInfoData) } void PlayerInfoReplyMessage_PlayerInfoData::InitAsDefaultInstance() { @@ -6677,27 +7416,30 @@ PlayerInfoReplyMessage_PlayerInfoData::PlayerInfoReplyMessage_PlayerInfoData(con : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PlayerInfoReplyMessage.PlayerInfoData) } void PlayerInfoReplyMessage_PlayerInfoData::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; - playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ishuman_ = false; playerrights_ = 1; - countrycode_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + countrycode_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); avatardata_ = NULL; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } PlayerInfoReplyMessage_PlayerInfoData::~PlayerInfoReplyMessage_PlayerInfoData() { + // @@protoc_insertion_point(destructor:PlayerInfoReplyMessage.PlayerInfoData) SharedDtor(); } void PlayerInfoReplyMessage_PlayerInfoData::SharedDtor() { - if (playername_ != &::google::protobuf::internal::kEmptyString) { + if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete playername_; } - if (countrycode_ != &::google::protobuf::internal::kEmptyString) { + if (countrycode_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete countrycode_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6730,16 +7472,16 @@ PlayerInfoReplyMessage_PlayerInfoData* PlayerInfoReplyMessage_PlayerInfoData::Ne } void PlayerInfoReplyMessage_PlayerInfoData::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 31) { if (has_playername()) { - if (playername_ != &::google::protobuf::internal::kEmptyString) { + if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { playername_->clear(); } } ishuman_ = false; playerrights_ = 1; if (has_countrycode()) { - if (countrycode_ != &::google::protobuf::internal::kEmptyString) { + if (countrycode_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { countrycode_->clear(); } } @@ -6748,22 +7490,30 @@ void PlayerInfoReplyMessage_PlayerInfoData::Clear() { } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PlayerInfoReplyMessage_PlayerInfoData::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PlayerInfoReplyMessage.PlayerInfoData) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required string playerName = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_playername())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_isHuman; break; @@ -6771,15 +7521,14 @@ bool PlayerInfoReplyMessage_PlayerInfoData::MergePartialFromCodedStream( // required bool isHuman = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_isHuman: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &ishuman_))); set_has_ishuman(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_playerRights; break; @@ -6787,8 +7536,7 @@ bool PlayerInfoReplyMessage_PlayerInfoData::MergePartialFromCodedStream( // required .NetPlayerInfoRights playerRights = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_playerRights: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -6796,9 +7544,12 @@ bool PlayerInfoReplyMessage_PlayerInfoData::MergePartialFromCodedStream( input, &value))); if (::NetPlayerInfoRights_IsValid(value)) { set_playerrights(static_cast< ::NetPlayerInfoRights >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_countryCode; break; @@ -6806,13 +7557,12 @@ bool PlayerInfoReplyMessage_PlayerInfoData::MergePartialFromCodedStream( // optional string countryCode = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_countryCode: DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_countrycode())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(42)) goto parse_avatarData; break; @@ -6820,38 +7570,45 @@ bool PlayerInfoReplyMessage_PlayerInfoData::MergePartialFromCodedStream( // optional .PlayerInfoReplyMessage.PlayerInfoData.AvatarData avatarData = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 42) { parse_avatarData: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_avatardata())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PlayerInfoReplyMessage.PlayerInfoData) return true; +failure: + // @@protoc_insertion_point(parse_failure:PlayerInfoReplyMessage.PlayerInfoData) + return false; #undef DO_ } void PlayerInfoReplyMessage_PlayerInfoData::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PlayerInfoReplyMessage.PlayerInfoData) // required string playerName = 1; if (has_playername()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 1, this->playername(), output); } @@ -6868,7 +7625,7 @@ void PlayerInfoReplyMessage_PlayerInfoData::SerializeWithCachedSizes( // optional string countryCode = 4; if (has_countrycode()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 4, this->countrycode(), output); } @@ -6878,6 +7635,9 @@ void PlayerInfoReplyMessage_PlayerInfoData::SerializeWithCachedSizes( 5, this->avatardata(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PlayerInfoReplyMessage.PlayerInfoData) } int PlayerInfoReplyMessage_PlayerInfoData::ByteSize() const { @@ -6917,6 +7677,8 @@ int PlayerInfoReplyMessage_PlayerInfoData::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -6947,6 +7709,7 @@ void PlayerInfoReplyMessage_PlayerInfoData::MergeFrom(const PlayerInfoReplyMessa mutable_avatardata()->::PlayerInfoReplyMessage_PlayerInfoData_AvatarData::MergeFrom(from.avatardata()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void PlayerInfoReplyMessage_PlayerInfoData::CopyFrom(const PlayerInfoReplyMessage_PlayerInfoData& from) { @@ -6972,6 +7735,7 @@ void PlayerInfoReplyMessage_PlayerInfoData::Swap(PlayerInfoReplyMessage_PlayerIn std::swap(countrycode_, other->countrycode_); std::swap(avatardata_, other->avatardata_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -6991,6 +7755,7 @@ const int PlayerInfoReplyMessage::kPlayerInfoDataFieldNumber; PlayerInfoReplyMessage::PlayerInfoReplyMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PlayerInfoReplyMessage) } void PlayerInfoReplyMessage::InitAsDefaultInstance() { @@ -7006,6 +7771,7 @@ PlayerInfoReplyMessage::PlayerInfoReplyMessage(const PlayerInfoReplyMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PlayerInfoReplyMessage) } void PlayerInfoReplyMessage::SharedCtor() { @@ -7016,6 +7782,7 @@ void PlayerInfoReplyMessage::SharedCtor() { } PlayerInfoReplyMessage::~PlayerInfoReplyMessage() { + // @@protoc_insertion_point(destructor:PlayerInfoReplyMessage) SharedDtor(); } @@ -7050,31 +7817,39 @@ PlayerInfoReplyMessage* PlayerInfoReplyMessage::New() const { } void PlayerInfoReplyMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { playerid_ = 0u; if (has_playerinfodata()) { if (playerinfodata_ != NULL) playerinfodata_->::PlayerInfoReplyMessage_PlayerInfoData::Clear(); } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PlayerInfoReplyMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PlayerInfoReplyMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_playerInfoData; break; @@ -7082,35 +7857,42 @@ bool PlayerInfoReplyMessage::MergePartialFromCodedStream( // optional .PlayerInfoReplyMessage.PlayerInfoData playerInfoData = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_playerInfoData: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_playerinfodata())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PlayerInfoReplyMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:PlayerInfoReplyMessage) + return false; #undef DO_ } void PlayerInfoReplyMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PlayerInfoReplyMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -7122,6 +7904,9 @@ void PlayerInfoReplyMessage::SerializeWithCachedSizes( 2, this->playerinfodata(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PlayerInfoReplyMessage) } int PlayerInfoReplyMessage::ByteSize() const { @@ -7143,6 +7928,8 @@ int PlayerInfoReplyMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -7164,6 +7951,7 @@ void PlayerInfoReplyMessage::MergeFrom(const PlayerInfoReplyMessage& from) { mutable_playerinfodata()->::PlayerInfoReplyMessage_PlayerInfoData::MergeFrom(from.playerinfodata()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void PlayerInfoReplyMessage::CopyFrom(const PlayerInfoReplyMessage& from) { @@ -7186,6 +7974,7 @@ void PlayerInfoReplyMessage::Swap(PlayerInfoReplyMessage* other) { std::swap(playerid_, other->playerid_); std::swap(playerinfodata_, other->playerinfodata_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -7222,6 +8011,7 @@ const int SubscriptionRequestMessage::kSubscriptionActionFieldNumber; SubscriptionRequestMessage::SubscriptionRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:SubscriptionRequestMessage) } void SubscriptionRequestMessage::InitAsDefaultInstance() { @@ -7231,6 +8021,7 @@ SubscriptionRequestMessage::SubscriptionRequestMessage(const SubscriptionRequest : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:SubscriptionRequestMessage) } void SubscriptionRequestMessage::SharedCtor() { @@ -7241,6 +8032,7 @@ void SubscriptionRequestMessage::SharedCtor() { } SubscriptionRequestMessage::~SubscriptionRequestMessage() { + // @@protoc_insertion_point(destructor:SubscriptionRequestMessage) SharedDtor(); } @@ -7274,29 +8066,37 @@ SubscriptionRequestMessage* SubscriptionRequestMessage::New() const { } void SubscriptionRequestMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { requestid_ = 0u; subscriptionaction_ = 1; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool SubscriptionRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:SubscriptionRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 requestId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &requestid_))); set_has_requestid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_subscriptionAction; break; @@ -7304,8 +8104,7 @@ bool SubscriptionRequestMessage::MergePartialFromCodedStream( // required .SubscriptionRequestMessage.SubscriptionAction subscriptionAction = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_subscriptionAction: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -7313,31 +8112,42 @@ bool SubscriptionRequestMessage::MergePartialFromCodedStream( input, &value))); if (::SubscriptionRequestMessage_SubscriptionAction_IsValid(value)) { set_subscriptionaction(static_cast< ::SubscriptionRequestMessage_SubscriptionAction >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:SubscriptionRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:SubscriptionRequestMessage) + return false; #undef DO_ } void SubscriptionRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:SubscriptionRequestMessage) // required uint32 requestId = 1; if (has_requestid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output); @@ -7349,6 +8159,9 @@ void SubscriptionRequestMessage::SerializeWithCachedSizes( 2, this->subscriptionaction(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:SubscriptionRequestMessage) } int SubscriptionRequestMessage::ByteSize() const { @@ -7369,6 +8182,8 @@ int SubscriptionRequestMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -7390,6 +8205,7 @@ void SubscriptionRequestMessage::MergeFrom(const SubscriptionRequestMessage& fro set_subscriptionaction(from.subscriptionaction()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void SubscriptionRequestMessage::CopyFrom(const SubscriptionRequestMessage& from) { @@ -7409,6 +8225,7 @@ void SubscriptionRequestMessage::Swap(SubscriptionRequestMessage* other) { std::swap(requestid_, other->requestid_); std::swap(subscriptionaction_, other->subscriptionaction_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -7428,6 +8245,7 @@ const int SubscriptionReplyMessage::kAckFieldNumber; SubscriptionReplyMessage::SubscriptionReplyMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:SubscriptionReplyMessage) } void SubscriptionReplyMessage::InitAsDefaultInstance() { @@ -7437,6 +8255,7 @@ SubscriptionReplyMessage::SubscriptionReplyMessage(const SubscriptionReplyMessag : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:SubscriptionReplyMessage) } void SubscriptionReplyMessage::SharedCtor() { @@ -7447,6 +8266,7 @@ void SubscriptionReplyMessage::SharedCtor() { } SubscriptionReplyMessage::~SubscriptionReplyMessage() { + // @@protoc_insertion_point(destructor:SubscriptionReplyMessage) SharedDtor(); } @@ -7480,29 +8300,48 @@ SubscriptionReplyMessage* SubscriptionReplyMessage::New() const { } void SubscriptionReplyMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - requestid_ = 0u; - ack_ = false; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(requestid_, ack_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool SubscriptionReplyMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:SubscriptionReplyMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 requestId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &requestid_))); set_has_requestid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_ack; break; @@ -7510,37 +8349,44 @@ bool SubscriptionReplyMessage::MergePartialFromCodedStream( // required bool ack = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_ack: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &ack_))); set_has_ack(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:SubscriptionReplyMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:SubscriptionReplyMessage) + return false; #undef DO_ } void SubscriptionReplyMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:SubscriptionReplyMessage) // required uint32 requestId = 1; if (has_requestid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output); @@ -7551,6 +8397,9 @@ void SubscriptionReplyMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->ack(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:SubscriptionReplyMessage) } int SubscriptionReplyMessage::ByteSize() const { @@ -7570,6 +8419,8 @@ int SubscriptionReplyMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -7591,6 +8442,7 @@ void SubscriptionReplyMessage::MergeFrom(const SubscriptionReplyMessage& from) { set_ack(from.ack()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void SubscriptionReplyMessage::CopyFrom(const SubscriptionReplyMessage& from) { @@ -7610,6 +8462,7 @@ void SubscriptionReplyMessage::Swap(SubscriptionReplyMessage* other) { std::swap(requestid_, other->requestid_); std::swap(ack_, other->ack_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -7631,6 +8484,7 @@ const int CreateGameMessage::kAutoLeaveFieldNumber; CreateGameMessage::CreateGameMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:CreateGameMessage) } void CreateGameMessage::InitAsDefaultInstance() { @@ -7646,23 +8500,26 @@ CreateGameMessage::CreateGameMessage(const CreateGameMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:CreateGameMessage) } void CreateGameMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; requestid_ = 0u; gameinfo_ = NULL; - password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + password_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); autoleave_ = false; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } CreateGameMessage::~CreateGameMessage() { + // @@protoc_insertion_point(destructor:CreateGameMessage) SharedDtor(); } void CreateGameMessage::SharedDtor() { - if (password_ != &::google::protobuf::internal::kEmptyString) { + if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete password_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7695,37 +8552,58 @@ CreateGameMessage* CreateGameMessage::New() const { } void CreateGameMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - requestid_ = 0u; +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 15) { + ZR_(requestid_, autoleave_); if (has_gameinfo()) { if (gameinfo_ != NULL) gameinfo_->::NetGameInfo::Clear(); } if (has_password()) { - if (password_ != &::google::protobuf::internal::kEmptyString) { + if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_->clear(); } } - autoleave_ = false; } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool CreateGameMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:CreateGameMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 requestId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &requestid_))); set_has_requestid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_gameInfo; break; @@ -7733,13 +8611,12 @@ bool CreateGameMessage::MergePartialFromCodedStream( // required .NetGameInfo gameInfo = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_gameInfo: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gameinfo())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_password; break; @@ -7747,13 +8624,12 @@ bool CreateGameMessage::MergePartialFromCodedStream( // optional string password = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_password: DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_password())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_autoLeave; break; @@ -7761,37 +8637,44 @@ bool CreateGameMessage::MergePartialFromCodedStream( // optional bool autoLeave = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_autoLeave: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &autoleave_))); set_has_autoleave(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:CreateGameMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:CreateGameMessage) + return false; #undef DO_ } void CreateGameMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:CreateGameMessage) // required uint32 requestId = 1; if (has_requestid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output); @@ -7805,7 +8688,7 @@ void CreateGameMessage::SerializeWithCachedSizes( // optional string password = 3; if (has_password()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 3, this->password(), output); } @@ -7814,6 +8697,9 @@ void CreateGameMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->autoleave(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:CreateGameMessage) } int CreateGameMessage::ByteSize() const { @@ -7847,6 +8733,8 @@ int CreateGameMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -7874,6 +8762,7 @@ void CreateGameMessage::MergeFrom(const CreateGameMessage& from) { set_autoleave(from.autoleave()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void CreateGameMessage::CopyFrom(const CreateGameMessage& from) { @@ -7898,6 +8787,7 @@ void CreateGameMessage::Swap(CreateGameMessage* other) { std::swap(password_, other->password_); std::swap(autoleave_, other->autoleave_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -7938,6 +8828,7 @@ const int CreateGameFailedMessage::kCreateGameFailureReasonFieldNumber; CreateGameFailedMessage::CreateGameFailedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:CreateGameFailedMessage) } void CreateGameFailedMessage::InitAsDefaultInstance() { @@ -7947,6 +8838,7 @@ CreateGameFailedMessage::CreateGameFailedMessage(const CreateGameFailedMessage& : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:CreateGameFailedMessage) } void CreateGameFailedMessage::SharedCtor() { @@ -7957,6 +8849,7 @@ void CreateGameFailedMessage::SharedCtor() { } CreateGameFailedMessage::~CreateGameFailedMessage() { + // @@protoc_insertion_point(destructor:CreateGameFailedMessage) SharedDtor(); } @@ -7990,29 +8883,37 @@ CreateGameFailedMessage* CreateGameFailedMessage::New() const { } void CreateGameFailedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { requestid_ = 0u; creategamefailurereason_ = 1; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool CreateGameFailedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:CreateGameFailedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 requestId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &requestid_))); set_has_requestid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_createGameFailureReason; break; @@ -8020,8 +8921,7 @@ bool CreateGameFailedMessage::MergePartialFromCodedStream( // required .CreateGameFailedMessage.CreateGameFailureReason createGameFailureReason = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_createGameFailureReason: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -8029,31 +8929,42 @@ bool CreateGameFailedMessage::MergePartialFromCodedStream( input, &value))); if (::CreateGameFailedMessage_CreateGameFailureReason_IsValid(value)) { set_creategamefailurereason(static_cast< ::CreateGameFailedMessage_CreateGameFailureReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:CreateGameFailedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:CreateGameFailedMessage) + return false; #undef DO_ } void CreateGameFailedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:CreateGameFailedMessage) // required uint32 requestId = 1; if (has_requestid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output); @@ -8065,6 +8976,9 @@ void CreateGameFailedMessage::SerializeWithCachedSizes( 2, this->creategamefailurereason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:CreateGameFailedMessage) } int CreateGameFailedMessage::ByteSize() const { @@ -8085,6 +8999,8 @@ int CreateGameFailedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -8106,6 +9022,7 @@ void CreateGameFailedMessage::MergeFrom(const CreateGameFailedMessage& from) { set_creategamefailurereason(from.creategamefailurereason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void CreateGameFailedMessage::CopyFrom(const CreateGameFailedMessage& from) { @@ -8125,6 +9042,7 @@ void CreateGameFailedMessage::Swap(CreateGameFailedMessage* other) { std::swap(requestid_, other->requestid_); std::swap(creategamefailurereason_, other->creategamefailurereason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -8146,6 +9064,7 @@ const int JoinGameMessage::kSpectateOnlyFieldNumber; JoinGameMessage::JoinGameMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:JoinGameMessage) } void JoinGameMessage::InitAsDefaultInstance() { @@ -8155,23 +9074,26 @@ JoinGameMessage::JoinGameMessage(const JoinGameMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:JoinGameMessage) } void JoinGameMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; gameid_ = 0u; - password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + password_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); autoleave_ = false; spectateonly_ = false; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } JoinGameMessage::~JoinGameMessage() { + // @@protoc_insertion_point(destructor:JoinGameMessage) SharedDtor(); } void JoinGameMessage::SharedDtor() { - if (password_ != &::google::protobuf::internal::kEmptyString) { + if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete password_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8203,35 +9125,55 @@ JoinGameMessage* JoinGameMessage::New() const { } void JoinGameMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 15) { + ZR_(gameid_, spectateonly_); if (has_password()) { - if (password_ != &::google::protobuf::internal::kEmptyString) { + if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_->clear(); } } - autoleave_ = false; - spectateonly_ = false; } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool JoinGameMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:JoinGameMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_password; break; @@ -8239,13 +9181,12 @@ bool JoinGameMessage::MergePartialFromCodedStream( // optional string password = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_password: DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_password())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_autoLeave; break; @@ -8253,15 +9194,14 @@ bool JoinGameMessage::MergePartialFromCodedStream( // optional bool autoLeave = 3 [default = false]; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_autoLeave: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &autoleave_))); set_has_autoleave(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_spectateOnly; break; @@ -8269,37 +9209,44 @@ bool JoinGameMessage::MergePartialFromCodedStream( // optional bool spectateOnly = 4 [default = false]; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_spectateOnly: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &spectateonly_))); set_has_spectateonly(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:JoinGameMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:JoinGameMessage) + return false; #undef DO_ } void JoinGameMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:JoinGameMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -8307,7 +9254,7 @@ void JoinGameMessage::SerializeWithCachedSizes( // optional string password = 2; if (has_password()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 2, this->password(), output); } @@ -8321,6 +9268,9 @@ void JoinGameMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->spectateonly(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:JoinGameMessage) } int JoinGameMessage::ByteSize() const { @@ -8352,6 +9302,8 @@ int JoinGameMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -8379,6 +9331,7 @@ void JoinGameMessage::MergeFrom(const JoinGameMessage& from) { set_spectateonly(from.spectateonly()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void JoinGameMessage::CopyFrom(const JoinGameMessage& from) { @@ -8400,6 +9353,7 @@ void JoinGameMessage::Swap(JoinGameMessage* other) { std::swap(autoleave_, other->autoleave_); std::swap(spectateonly_, other->spectateonly_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -8419,6 +9373,7 @@ const int RejoinGameMessage::kAutoLeaveFieldNumber; RejoinGameMessage::RejoinGameMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:RejoinGameMessage) } void RejoinGameMessage::InitAsDefaultInstance() { @@ -8428,6 +9383,7 @@ RejoinGameMessage::RejoinGameMessage(const RejoinGameMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:RejoinGameMessage) } void RejoinGameMessage::SharedCtor() { @@ -8438,6 +9394,7 @@ void RejoinGameMessage::SharedCtor() { } RejoinGameMessage::~RejoinGameMessage() { + // @@protoc_insertion_point(destructor:RejoinGameMessage) SharedDtor(); } @@ -8471,29 +9428,48 @@ RejoinGameMessage* RejoinGameMessage::New() const { } void RejoinGameMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - autoleave_ = false; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, autoleave_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool RejoinGameMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:RejoinGameMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_autoLeave; break; @@ -8501,37 +9477,44 @@ bool RejoinGameMessage::MergePartialFromCodedStream( // optional bool autoLeave = 2 [default = false]; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_autoLeave: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &autoleave_))); set_has_autoleave(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:RejoinGameMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:RejoinGameMessage) + return false; #undef DO_ } void RejoinGameMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:RejoinGameMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -8542,6 +9525,9 @@ void RejoinGameMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->autoleave(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:RejoinGameMessage) } int RejoinGameMessage::ByteSize() const { @@ -8561,6 +9547,8 @@ int RejoinGameMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -8582,6 +9570,7 @@ void RejoinGameMessage::MergeFrom(const RejoinGameMessage& from) { set_autoleave(from.autoleave()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void RejoinGameMessage::CopyFrom(const RejoinGameMessage& from) { @@ -8601,6 +9590,7 @@ void RejoinGameMessage::Swap(RejoinGameMessage* other) { std::swap(gameid_, other->gameid_); std::swap(autoleave_, other->autoleave_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -8622,6 +9612,7 @@ const int JoinGameAckMessage::kSpectateOnlyFieldNumber; JoinGameAckMessage::JoinGameAckMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:JoinGameAckMessage) } void JoinGameAckMessage::InitAsDefaultInstance() { @@ -8637,6 +9628,7 @@ JoinGameAckMessage::JoinGameAckMessage(const JoinGameAckMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:JoinGameAckMessage) } void JoinGameAckMessage::SharedCtor() { @@ -8649,6 +9641,7 @@ void JoinGameAckMessage::SharedCtor() { } JoinGameAckMessage::~JoinGameAckMessage() { + // @@protoc_insertion_point(destructor:JoinGameAckMessage) SharedDtor(); } @@ -8683,33 +9676,53 @@ JoinGameAckMessage* JoinGameAckMessage::New() const { } void JoinGameAckMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - areyougameadmin_ = false; +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 15) { + ZR_(gameid_, spectateonly_); if (has_gameinfo()) { if (gameinfo_ != NULL) gameinfo_->::NetGameInfo::Clear(); } - spectateonly_ = false; } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool JoinGameAckMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:JoinGameAckMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_areYouGameAdmin; break; @@ -8717,15 +9730,14 @@ bool JoinGameAckMessage::MergePartialFromCodedStream( // required bool areYouGameAdmin = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_areYouGameAdmin: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &areyougameadmin_))); set_has_areyougameadmin(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_gameInfo; break; @@ -8733,13 +9745,12 @@ bool JoinGameAckMessage::MergePartialFromCodedStream( // required .NetGameInfo gameInfo = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_gameInfo: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gameinfo())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_spectateOnly; break; @@ -8747,37 +9758,44 @@ bool JoinGameAckMessage::MergePartialFromCodedStream( // optional bool spectateOnly = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_spectateOnly: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &spectateonly_))); set_has_spectateonly(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:JoinGameAckMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:JoinGameAckMessage) + return false; #undef DO_ } void JoinGameAckMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:JoinGameAckMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -8799,6 +9817,9 @@ void JoinGameAckMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->spectateonly(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:JoinGameAckMessage) } int JoinGameAckMessage::ByteSize() const { @@ -8830,6 +9851,8 @@ int JoinGameAckMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -8857,6 +9880,7 @@ void JoinGameAckMessage::MergeFrom(const JoinGameAckMessage& from) { set_spectateonly(from.spectateonly()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void JoinGameAckMessage::CopyFrom(const JoinGameAckMessage& from) { @@ -8881,6 +9905,7 @@ void JoinGameAckMessage::Swap(JoinGameAckMessage* other) { std::swap(gameinfo_, other->gameinfo_); std::swap(spectateonly_, other->spectateonly_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -8931,6 +9956,7 @@ const int JoinGameFailedMessage::kJoinGameFailureReasonFieldNumber; JoinGameFailedMessage::JoinGameFailedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:JoinGameFailedMessage) } void JoinGameFailedMessage::InitAsDefaultInstance() { @@ -8940,6 +9966,7 @@ JoinGameFailedMessage::JoinGameFailedMessage(const JoinGameFailedMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:JoinGameFailedMessage) } void JoinGameFailedMessage::SharedCtor() { @@ -8950,6 +9977,7 @@ void JoinGameFailedMessage::SharedCtor() { } JoinGameFailedMessage::~JoinGameFailedMessage() { + // @@protoc_insertion_point(destructor:JoinGameFailedMessage) SharedDtor(); } @@ -8983,29 +10011,37 @@ JoinGameFailedMessage* JoinGameFailedMessage::New() const { } void JoinGameFailedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { gameid_ = 0u; joingamefailurereason_ = 1; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool JoinGameFailedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:JoinGameFailedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_joinGameFailureReason; break; @@ -9013,8 +10049,7 @@ bool JoinGameFailedMessage::MergePartialFromCodedStream( // required .JoinGameFailedMessage.JoinGameFailureReason joinGameFailureReason = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_joinGameFailureReason: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -9022,31 +10057,42 @@ bool JoinGameFailedMessage::MergePartialFromCodedStream( input, &value))); if (::JoinGameFailedMessage_JoinGameFailureReason_IsValid(value)) { set_joingamefailurereason(static_cast< ::JoinGameFailedMessage_JoinGameFailureReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:JoinGameFailedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:JoinGameFailedMessage) + return false; #undef DO_ } void JoinGameFailedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:JoinGameFailedMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -9058,6 +10104,9 @@ void JoinGameFailedMessage::SerializeWithCachedSizes( 2, this->joingamefailurereason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:JoinGameFailedMessage) } int JoinGameFailedMessage::ByteSize() const { @@ -9078,6 +10127,8 @@ int JoinGameFailedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -9099,6 +10150,7 @@ void JoinGameFailedMessage::MergeFrom(const JoinGameFailedMessage& from) { set_joingamefailurereason(from.joingamefailurereason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void JoinGameFailedMessage::CopyFrom(const JoinGameFailedMessage& from) { @@ -9118,6 +10170,7 @@ void JoinGameFailedMessage::Swap(JoinGameFailedMessage* other) { std::swap(gameid_, other->gameid_); std::swap(joingamefailurereason_, other->joingamefailurereason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -9137,6 +10190,7 @@ const int GamePlayerJoinedMessage::kIsGameAdminFieldNumber; GamePlayerJoinedMessage::GamePlayerJoinedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GamePlayerJoinedMessage) } void GamePlayerJoinedMessage::InitAsDefaultInstance() { @@ -9146,6 +10200,7 @@ GamePlayerJoinedMessage::GamePlayerJoinedMessage(const GamePlayerJoinedMessage& : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GamePlayerJoinedMessage) } void GamePlayerJoinedMessage::SharedCtor() { @@ -9156,6 +10211,7 @@ void GamePlayerJoinedMessage::SharedCtor() { } GamePlayerJoinedMessage::~GamePlayerJoinedMessage() { + // @@protoc_insertion_point(destructor:GamePlayerJoinedMessage) SharedDtor(); } @@ -9189,29 +10245,48 @@ GamePlayerJoinedMessage* GamePlayerJoinedMessage::New() const { } void GamePlayerJoinedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - isgameadmin_ = false; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(playerid_, isgameadmin_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GamePlayerJoinedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GamePlayerJoinedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_isGameAdmin; break; @@ -9219,37 +10294,44 @@ bool GamePlayerJoinedMessage::MergePartialFromCodedStream( // required bool isGameAdmin = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_isGameAdmin: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &isgameadmin_))); set_has_isgameadmin(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GamePlayerJoinedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GamePlayerJoinedMessage) + return false; #undef DO_ } void GamePlayerJoinedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GamePlayerJoinedMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -9260,6 +10342,9 @@ void GamePlayerJoinedMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->isgameadmin(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GamePlayerJoinedMessage) } int GamePlayerJoinedMessage::ByteSize() const { @@ -9279,6 +10364,8 @@ int GamePlayerJoinedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -9300,6 +10387,7 @@ void GamePlayerJoinedMessage::MergeFrom(const GamePlayerJoinedMessage& from) { set_isgameadmin(from.isgameadmin()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GamePlayerJoinedMessage::CopyFrom(const GamePlayerJoinedMessage& from) { @@ -9319,6 +10407,7 @@ void GamePlayerJoinedMessage::Swap(GamePlayerJoinedMessage* other) { std::swap(playerid_, other->playerid_); std::swap(isgameadmin_, other->isgameadmin_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -9357,6 +10446,7 @@ const int GamePlayerLeftMessage::kGamePlayerLeftReasonFieldNumber; GamePlayerLeftMessage::GamePlayerLeftMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GamePlayerLeftMessage) } void GamePlayerLeftMessage::InitAsDefaultInstance() { @@ -9366,6 +10456,7 @@ GamePlayerLeftMessage::GamePlayerLeftMessage(const GamePlayerLeftMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GamePlayerLeftMessage) } void GamePlayerLeftMessage::SharedCtor() { @@ -9376,6 +10467,7 @@ void GamePlayerLeftMessage::SharedCtor() { } GamePlayerLeftMessage::~GamePlayerLeftMessage() { + // @@protoc_insertion_point(destructor:GamePlayerLeftMessage) SharedDtor(); } @@ -9409,29 +10501,48 @@ GamePlayerLeftMessage* GamePlayerLeftMessage::New() const { } void GamePlayerLeftMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - gameplayerleftreason_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(playerid_, gameplayerleftreason_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GamePlayerLeftMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GamePlayerLeftMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_gamePlayerLeftReason; break; @@ -9439,8 +10550,7 @@ bool GamePlayerLeftMessage::MergePartialFromCodedStream( // required .GamePlayerLeftMessage.GamePlayerLeftReason gamePlayerLeftReason = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_gamePlayerLeftReason: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -9448,31 +10558,42 @@ bool GamePlayerLeftMessage::MergePartialFromCodedStream( input, &value))); if (::GamePlayerLeftMessage_GamePlayerLeftReason_IsValid(value)) { set_gameplayerleftreason(static_cast< ::GamePlayerLeftMessage_GamePlayerLeftReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GamePlayerLeftMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GamePlayerLeftMessage) + return false; #undef DO_ } void GamePlayerLeftMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GamePlayerLeftMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -9484,6 +10605,9 @@ void GamePlayerLeftMessage::SerializeWithCachedSizes( 2, this->gameplayerleftreason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GamePlayerLeftMessage) } int GamePlayerLeftMessage::ByteSize() const { @@ -9504,6 +10628,8 @@ int GamePlayerLeftMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -9525,6 +10651,7 @@ void GamePlayerLeftMessage::MergeFrom(const GamePlayerLeftMessage& from) { set_gameplayerleftreason(from.gameplayerleftreason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GamePlayerLeftMessage::CopyFrom(const GamePlayerLeftMessage& from) { @@ -9544,6 +10671,7 @@ void GamePlayerLeftMessage::Swap(GamePlayerLeftMessage* other) { std::swap(playerid_, other->playerid_); std::swap(gameplayerleftreason_, other->gameplayerleftreason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -9562,6 +10690,7 @@ const int GameSpectatorJoinedMessage::kPlayerIdFieldNumber; GameSpectatorJoinedMessage::GameSpectatorJoinedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameSpectatorJoinedMessage) } void GameSpectatorJoinedMessage::InitAsDefaultInstance() { @@ -9571,6 +10700,7 @@ GameSpectatorJoinedMessage::GameSpectatorJoinedMessage(const GameSpectatorJoined : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameSpectatorJoinedMessage) } void GameSpectatorJoinedMessage::SharedCtor() { @@ -9580,6 +10710,7 @@ void GameSpectatorJoinedMessage::SharedCtor() { } GameSpectatorJoinedMessage::~GameSpectatorJoinedMessage() { + // @@protoc_insertion_point(destructor:GameSpectatorJoinedMessage) SharedDtor(); } @@ -9613,55 +10744,72 @@ GameSpectatorJoinedMessage* GameSpectatorJoinedMessage::New() const { } void GameSpectatorJoinedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - } + playerid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameSpectatorJoinedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameSpectatorJoinedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameSpectatorJoinedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameSpectatorJoinedMessage) + return false; #undef DO_ } void GameSpectatorJoinedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameSpectatorJoinedMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameSpectatorJoinedMessage) } int GameSpectatorJoinedMessage::ByteSize() const { @@ -9676,6 +10824,8 @@ int GameSpectatorJoinedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -9694,6 +10844,7 @@ void GameSpectatorJoinedMessage::MergeFrom(const GameSpectatorJoinedMessage& fro set_playerid(from.playerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameSpectatorJoinedMessage::CopyFrom(const GameSpectatorJoinedMessage& from) { @@ -9712,6 +10863,7 @@ void GameSpectatorJoinedMessage::Swap(GameSpectatorJoinedMessage* other) { if (other != this) { std::swap(playerid_, other->playerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -9731,6 +10883,7 @@ const int GameSpectatorLeftMessage::kGameSpectatorLeftReasonFieldNumber; GameSpectatorLeftMessage::GameSpectatorLeftMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameSpectatorLeftMessage) } void GameSpectatorLeftMessage::InitAsDefaultInstance() { @@ -9740,6 +10893,7 @@ GameSpectatorLeftMessage::GameSpectatorLeftMessage(const GameSpectatorLeftMessag : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameSpectatorLeftMessage) } void GameSpectatorLeftMessage::SharedCtor() { @@ -9750,6 +10904,7 @@ void GameSpectatorLeftMessage::SharedCtor() { } GameSpectatorLeftMessage::~GameSpectatorLeftMessage() { + // @@protoc_insertion_point(destructor:GameSpectatorLeftMessage) SharedDtor(); } @@ -9783,29 +10938,48 @@ GameSpectatorLeftMessage* GameSpectatorLeftMessage::New() const { } void GameSpectatorLeftMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - gamespectatorleftreason_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(playerid_, gamespectatorleftreason_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameSpectatorLeftMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameSpectatorLeftMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_gameSpectatorLeftReason; break; @@ -9813,8 +10987,7 @@ bool GameSpectatorLeftMessage::MergePartialFromCodedStream( // required .GamePlayerLeftMessage.GamePlayerLeftReason gameSpectatorLeftReason = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_gameSpectatorLeftReason: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -9822,31 +10995,42 @@ bool GameSpectatorLeftMessage::MergePartialFromCodedStream( input, &value))); if (::GamePlayerLeftMessage_GamePlayerLeftReason_IsValid(value)) { set_gamespectatorleftreason(static_cast< ::GamePlayerLeftMessage_GamePlayerLeftReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameSpectatorLeftMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameSpectatorLeftMessage) + return false; #undef DO_ } void GameSpectatorLeftMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameSpectatorLeftMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -9858,6 +11042,9 @@ void GameSpectatorLeftMessage::SerializeWithCachedSizes( 2, this->gamespectatorleftreason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameSpectatorLeftMessage) } int GameSpectatorLeftMessage::ByteSize() const { @@ -9878,6 +11065,8 @@ int GameSpectatorLeftMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -9899,6 +11088,7 @@ void GameSpectatorLeftMessage::MergeFrom(const GameSpectatorLeftMessage& from) { set_gamespectatorleftreason(from.gamespectatorleftreason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameSpectatorLeftMessage::CopyFrom(const GameSpectatorLeftMessage& from) { @@ -9918,6 +11108,7 @@ void GameSpectatorLeftMessage::Swap(GameSpectatorLeftMessage* other) { std::swap(playerid_, other->playerid_); std::swap(gamespectatorleftreason_, other->gamespectatorleftreason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -9936,6 +11127,7 @@ const int GameAdminChangedMessage::kNewAdminPlayerIdFieldNumber; GameAdminChangedMessage::GameAdminChangedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameAdminChangedMessage) } void GameAdminChangedMessage::InitAsDefaultInstance() { @@ -9945,6 +11137,7 @@ GameAdminChangedMessage::GameAdminChangedMessage(const GameAdminChangedMessage& : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameAdminChangedMessage) } void GameAdminChangedMessage::SharedCtor() { @@ -9954,6 +11147,7 @@ void GameAdminChangedMessage::SharedCtor() { } GameAdminChangedMessage::~GameAdminChangedMessage() { + // @@protoc_insertion_point(destructor:GameAdminChangedMessage) SharedDtor(); } @@ -9987,55 +11181,72 @@ GameAdminChangedMessage* GameAdminChangedMessage::New() const { } void GameAdminChangedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - newadminplayerid_ = 0u; - } + newadminplayerid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameAdminChangedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameAdminChangedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 newAdminPlayerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &newadminplayerid_))); set_has_newadminplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameAdminChangedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameAdminChangedMessage) + return false; #undef DO_ } void GameAdminChangedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameAdminChangedMessage) // required uint32 newAdminPlayerId = 1; if (has_newadminplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->newadminplayerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameAdminChangedMessage) } int GameAdminChangedMessage::ByteSize() const { @@ -10050,6 +11261,8 @@ int GameAdminChangedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -10068,6 +11281,7 @@ void GameAdminChangedMessage::MergeFrom(const GameAdminChangedMessage& from) { set_newadminplayerid(from.newadminplayerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameAdminChangedMessage::CopyFrom(const GameAdminChangedMessage& from) { @@ -10086,6 +11300,7 @@ void GameAdminChangedMessage::Swap(GameAdminChangedMessage* other) { if (other != this) { std::swap(newadminplayerid_, other->newadminplayerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -10131,6 +11346,7 @@ const int RemovedFromGameMessage::kRemovedFromGameReasonFieldNumber; RemovedFromGameMessage::RemovedFromGameMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:RemovedFromGameMessage) } void RemovedFromGameMessage::InitAsDefaultInstance() { @@ -10140,6 +11356,7 @@ RemovedFromGameMessage::RemovedFromGameMessage(const RemovedFromGameMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:RemovedFromGameMessage) } void RemovedFromGameMessage::SharedCtor() { @@ -10149,6 +11366,7 @@ void RemovedFromGameMessage::SharedCtor() { } RemovedFromGameMessage::~RemovedFromGameMessage() { + // @@protoc_insertion_point(destructor:RemovedFromGameMessage) SharedDtor(); } @@ -10182,59 +11400,79 @@ RemovedFromGameMessage* RemovedFromGameMessage::New() const { } void RemovedFromGameMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - removedfromgamereason_ = 0; - } + removedfromgamereason_ = 0; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool RemovedFromGameMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:RemovedFromGameMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .RemovedFromGameMessage.RemovedFromGameReason removedFromGameReason = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::RemovedFromGameMessage_RemovedFromGameReason_IsValid(value)) { set_removedfromgamereason(static_cast< ::RemovedFromGameMessage_RemovedFromGameReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:RemovedFromGameMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:RemovedFromGameMessage) + return false; #undef DO_ } void RemovedFromGameMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:RemovedFromGameMessage) // required .RemovedFromGameMessage.RemovedFromGameReason removedFromGameReason = 1; if (has_removedfromgamereason()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( 1, this->removedfromgamereason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:RemovedFromGameMessage) } int RemovedFromGameMessage::ByteSize() const { @@ -10248,6 +11486,8 @@ int RemovedFromGameMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -10266,6 +11506,7 @@ void RemovedFromGameMessage::MergeFrom(const RemovedFromGameMessage& from) { set_removedfromgamereason(from.removedfromgamereason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void RemovedFromGameMessage::CopyFrom(const RemovedFromGameMessage& from) { @@ -10284,6 +11525,7 @@ void RemovedFromGameMessage::Swap(RemovedFromGameMessage* other) { if (other != this) { std::swap(removedfromgamereason_, other->removedfromgamereason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -10302,6 +11544,7 @@ const int KickPlayerRequestMessage::kPlayerIdFieldNumber; KickPlayerRequestMessage::KickPlayerRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:KickPlayerRequestMessage) } void KickPlayerRequestMessage::InitAsDefaultInstance() { @@ -10311,6 +11554,7 @@ KickPlayerRequestMessage::KickPlayerRequestMessage(const KickPlayerRequestMessag : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:KickPlayerRequestMessage) } void KickPlayerRequestMessage::SharedCtor() { @@ -10320,6 +11564,7 @@ void KickPlayerRequestMessage::SharedCtor() { } KickPlayerRequestMessage::~KickPlayerRequestMessage() { + // @@protoc_insertion_point(destructor:KickPlayerRequestMessage) SharedDtor(); } @@ -10353,55 +11598,72 @@ KickPlayerRequestMessage* KickPlayerRequestMessage::New() const { } void KickPlayerRequestMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - } + playerid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool KickPlayerRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:KickPlayerRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:KickPlayerRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:KickPlayerRequestMessage) + return false; #undef DO_ } void KickPlayerRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:KickPlayerRequestMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:KickPlayerRequestMessage) } int KickPlayerRequestMessage::ByteSize() const { @@ -10416,6 +11678,8 @@ int KickPlayerRequestMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -10434,6 +11698,7 @@ void KickPlayerRequestMessage::MergeFrom(const KickPlayerRequestMessage& from) { set_playerid(from.playerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void KickPlayerRequestMessage::CopyFrom(const KickPlayerRequestMessage& from) { @@ -10452,6 +11717,7 @@ void KickPlayerRequestMessage::Swap(KickPlayerRequestMessage* other) { if (other != this) { std::swap(playerid_, other->playerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -10469,6 +11735,7 @@ void KickPlayerRequestMessage::Swap(KickPlayerRequestMessage* other) { LeaveGameRequestMessage::LeaveGameRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:LeaveGameRequestMessage) } void LeaveGameRequestMessage::InitAsDefaultInstance() { @@ -10478,6 +11745,7 @@ LeaveGameRequestMessage::LeaveGameRequestMessage(const LeaveGameRequestMessage& : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:LeaveGameRequestMessage) } void LeaveGameRequestMessage::SharedCtor() { @@ -10486,6 +11754,7 @@ void LeaveGameRequestMessage::SharedCtor() { } LeaveGameRequestMessage::~LeaveGameRequestMessage() { + // @@protoc_insertion_point(destructor:LeaveGameRequestMessage) SharedDtor(); } @@ -10520,30 +11789,53 @@ LeaveGameRequestMessage* LeaveGameRequestMessage::New() const { void LeaveGameRequestMessage::Clear() { ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool LeaveGameRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:LeaveGameRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); } +success: + // @@protoc_insertion_point(parse_success:LeaveGameRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:LeaveGameRequestMessage) + return false; #undef DO_ } void LeaveGameRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:LeaveGameRequestMessage) + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:LeaveGameRequestMessage) } int LeaveGameRequestMessage::ByteSize() const { int total_size = 0; + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -10557,6 +11849,7 @@ void LeaveGameRequestMessage::CheckTypeAndMergeFrom( void LeaveGameRequestMessage::MergeFrom(const LeaveGameRequestMessage& from) { GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->append(from.unknown_fields()); } void LeaveGameRequestMessage::CopyFrom(const LeaveGameRequestMessage& from) { @@ -10572,6 +11865,7 @@ bool LeaveGameRequestMessage::IsInitialized() const { void LeaveGameRequestMessage::Swap(LeaveGameRequestMessage* other) { if (other != this) { + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -10591,6 +11885,7 @@ const int InvitePlayerToGameMessage::kPlayerIdFieldNumber; InvitePlayerToGameMessage::InvitePlayerToGameMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:InvitePlayerToGameMessage) } void InvitePlayerToGameMessage::InitAsDefaultInstance() { @@ -10600,6 +11895,7 @@ InvitePlayerToGameMessage::InvitePlayerToGameMessage(const InvitePlayerToGameMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:InvitePlayerToGameMessage) } void InvitePlayerToGameMessage::SharedCtor() { @@ -10610,6 +11906,7 @@ void InvitePlayerToGameMessage::SharedCtor() { } InvitePlayerToGameMessage::~InvitePlayerToGameMessage() { + // @@protoc_insertion_point(destructor:InvitePlayerToGameMessage) SharedDtor(); } @@ -10643,29 +11940,48 @@ InvitePlayerToGameMessage* InvitePlayerToGameMessage::New() const { } void InvitePlayerToGameMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - playerid_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, playerid_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool InvitePlayerToGameMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:InvitePlayerToGameMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_playerId; break; @@ -10673,37 +11989,44 @@ bool InvitePlayerToGameMessage::MergePartialFromCodedStream( // required uint32 playerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_playerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:InvitePlayerToGameMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:InvitePlayerToGameMessage) + return false; #undef DO_ } void InvitePlayerToGameMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:InvitePlayerToGameMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -10714,6 +12037,9 @@ void InvitePlayerToGameMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:InvitePlayerToGameMessage) } int InvitePlayerToGameMessage::ByteSize() const { @@ -10735,6 +12061,8 @@ int InvitePlayerToGameMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -10756,6 +12084,7 @@ void InvitePlayerToGameMessage::MergeFrom(const InvitePlayerToGameMessage& from) set_playerid(from.playerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void InvitePlayerToGameMessage::CopyFrom(const InvitePlayerToGameMessage& from) { @@ -10775,6 +12104,7 @@ void InvitePlayerToGameMessage::Swap(InvitePlayerToGameMessage* other) { std::swap(gameid_, other->gameid_); std::swap(playerid_, other->playerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -10795,6 +12125,7 @@ const int InviteNotifyMessage::kPlayerIdByWhomFieldNumber; InviteNotifyMessage::InviteNotifyMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:InviteNotifyMessage) } void InviteNotifyMessage::InitAsDefaultInstance() { @@ -10804,6 +12135,7 @@ InviteNotifyMessage::InviteNotifyMessage(const InviteNotifyMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:InviteNotifyMessage) } void InviteNotifyMessage::SharedCtor() { @@ -10815,6 +12147,7 @@ void InviteNotifyMessage::SharedCtor() { } InviteNotifyMessage::~InviteNotifyMessage() { + // @@protoc_insertion_point(destructor:InviteNotifyMessage) SharedDtor(); } @@ -10848,30 +12181,48 @@ InviteNotifyMessage* InviteNotifyMessage::New() const { } void InviteNotifyMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - playeridwho_ = 0u; - playeridbywhom_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, playeridbywhom_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool InviteNotifyMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:InviteNotifyMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_playerIdWho; break; @@ -10879,15 +12230,14 @@ bool InviteNotifyMessage::MergePartialFromCodedStream( // required uint32 playerIdWho = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_playerIdWho: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playeridwho_))); set_has_playeridwho(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_playerIdByWhom; break; @@ -10895,37 +12245,44 @@ bool InviteNotifyMessage::MergePartialFromCodedStream( // required uint32 playerIdByWhom = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_playerIdByWhom: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playeridbywhom_))); set_has_playeridbywhom(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:InviteNotifyMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:InviteNotifyMessage) + return false; #undef DO_ } void InviteNotifyMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:InviteNotifyMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -10941,6 +12298,9 @@ void InviteNotifyMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->playeridbywhom(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:InviteNotifyMessage) } int InviteNotifyMessage::ByteSize() const { @@ -10969,6 +12329,8 @@ int InviteNotifyMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -10993,6 +12355,7 @@ void InviteNotifyMessage::MergeFrom(const InviteNotifyMessage& from) { set_playeridbywhom(from.playeridbywhom()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void InviteNotifyMessage::CopyFrom(const InviteNotifyMessage& from) { @@ -11013,6 +12376,7 @@ void InviteNotifyMessage::Swap(InviteNotifyMessage* other) { std::swap(playeridwho_, other->playeridwho_); std::swap(playeridbywhom_, other->playeridbywhom_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -11049,6 +12413,7 @@ const int RejectGameInvitationMessage::kMyRejectReasonFieldNumber; RejectGameInvitationMessage::RejectGameInvitationMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:RejectGameInvitationMessage) } void RejectGameInvitationMessage::InitAsDefaultInstance() { @@ -11058,6 +12423,7 @@ RejectGameInvitationMessage::RejectGameInvitationMessage(const RejectGameInvitat : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:RejectGameInvitationMessage) } void RejectGameInvitationMessage::SharedCtor() { @@ -11068,6 +12434,7 @@ void RejectGameInvitationMessage::SharedCtor() { } RejectGameInvitationMessage::~RejectGameInvitationMessage() { + // @@protoc_insertion_point(destructor:RejectGameInvitationMessage) SharedDtor(); } @@ -11101,29 +12468,48 @@ RejectGameInvitationMessage* RejectGameInvitationMessage::New() const { } void RejectGameInvitationMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - myrejectreason_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, myrejectreason_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool RejectGameInvitationMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:RejectGameInvitationMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_myRejectReason; break; @@ -11131,8 +12517,7 @@ bool RejectGameInvitationMessage::MergePartialFromCodedStream( // required .RejectGameInvitationMessage.RejectGameInvReason myRejectReason = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_myRejectReason: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -11140,31 +12525,42 @@ bool RejectGameInvitationMessage::MergePartialFromCodedStream( input, &value))); if (::RejectGameInvitationMessage_RejectGameInvReason_IsValid(value)) { set_myrejectreason(static_cast< ::RejectGameInvitationMessage_RejectGameInvReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:RejectGameInvitationMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:RejectGameInvitationMessage) + return false; #undef DO_ } void RejectGameInvitationMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:RejectGameInvitationMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -11176,6 +12572,9 @@ void RejectGameInvitationMessage::SerializeWithCachedSizes( 2, this->myrejectreason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:RejectGameInvitationMessage) } int RejectGameInvitationMessage::ByteSize() const { @@ -11196,6 +12595,8 @@ int RejectGameInvitationMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -11217,6 +12618,7 @@ void RejectGameInvitationMessage::MergeFrom(const RejectGameInvitationMessage& f set_myrejectreason(from.myrejectreason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void RejectGameInvitationMessage::CopyFrom(const RejectGameInvitationMessage& from) { @@ -11236,6 +12638,7 @@ void RejectGameInvitationMessage::Swap(RejectGameInvitationMessage* other) { std::swap(gameid_, other->gameid_); std::swap(myrejectreason_, other->myrejectreason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -11256,6 +12659,7 @@ const int RejectInvNotifyMessage::kPlayerRejectReasonFieldNumber; RejectInvNotifyMessage::RejectInvNotifyMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:RejectInvNotifyMessage) } void RejectInvNotifyMessage::InitAsDefaultInstance() { @@ -11265,6 +12669,7 @@ RejectInvNotifyMessage::RejectInvNotifyMessage(const RejectInvNotifyMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:RejectInvNotifyMessage) } void RejectInvNotifyMessage::SharedCtor() { @@ -11276,6 +12681,7 @@ void RejectInvNotifyMessage::SharedCtor() { } RejectInvNotifyMessage::~RejectInvNotifyMessage() { + // @@protoc_insertion_point(destructor:RejectInvNotifyMessage) SharedDtor(); } @@ -11309,30 +12715,48 @@ RejectInvNotifyMessage* RejectInvNotifyMessage::New() const { } void RejectInvNotifyMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gameid_ = 0u; - playerid_ = 0u; - playerrejectreason_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(gameid_, playerrejectreason_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool RejectInvNotifyMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:RejectInvNotifyMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 gameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_playerId; break; @@ -11340,15 +12764,14 @@ bool RejectInvNotifyMessage::MergePartialFromCodedStream( // required uint32 playerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_playerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_playerRejectReason; break; @@ -11356,8 +12779,7 @@ bool RejectInvNotifyMessage::MergePartialFromCodedStream( // required .RejectGameInvitationMessage.RejectGameInvReason playerRejectReason = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_playerRejectReason: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -11365,31 +12787,42 @@ bool RejectInvNotifyMessage::MergePartialFromCodedStream( input, &value))); if (::RejectGameInvitationMessage_RejectGameInvReason_IsValid(value)) { set_playerrejectreason(static_cast< ::RejectGameInvitationMessage_RejectGameInvReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:RejectInvNotifyMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:RejectInvNotifyMessage) + return false; #undef DO_ } void RejectInvNotifyMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:RejectInvNotifyMessage) // required uint32 gameId = 1; if (has_gameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); @@ -11406,6 +12839,9 @@ void RejectInvNotifyMessage::SerializeWithCachedSizes( 3, this->playerrejectreason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:RejectInvNotifyMessage) } int RejectInvNotifyMessage::ByteSize() const { @@ -11433,6 +12869,8 @@ int RejectInvNotifyMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -11457,6 +12895,7 @@ void RejectInvNotifyMessage::MergeFrom(const RejectInvNotifyMessage& from) { set_playerrejectreason(from.playerrejectreason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void RejectInvNotifyMessage::CopyFrom(const RejectInvNotifyMessage& from) { @@ -11477,6 +12916,7 @@ void RejectInvNotifyMessage::Swap(RejectInvNotifyMessage* other) { std::swap(playerid_, other->playerid_); std::swap(playerrejectreason_, other->playerrejectreason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -11513,6 +12953,7 @@ const int StartEventMessage::kFillWithComputerPlayersFieldNumber; StartEventMessage::StartEventMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:StartEventMessage) } void StartEventMessage::InitAsDefaultInstance() { @@ -11522,6 +12963,7 @@ StartEventMessage::StartEventMessage(const StartEventMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:StartEventMessage) } void StartEventMessage::SharedCtor() { @@ -11532,6 +12974,7 @@ void StartEventMessage::SharedCtor() { } StartEventMessage::~StartEventMessage() { + // @@protoc_insertion_point(destructor:StartEventMessage) SharedDtor(); } @@ -11565,32 +13008,54 @@ StartEventMessage* StartEventMessage::New() const { } void StartEventMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - starteventtype_ = 0; - fillwithcomputerplayers_ = false; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(starteventtype_, fillwithcomputerplayers_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool StartEventMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:StartEventMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .StartEventMessage.StartEventType startEventType = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::StartEventMessage_StartEventType_IsValid(value)) { set_starteventtype(static_cast< ::StartEventMessage_StartEventType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_fillWithComputerPlayers; break; @@ -11598,37 +13063,44 @@ bool StartEventMessage::MergePartialFromCodedStream( // optional bool fillWithComputerPlayers = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_fillWithComputerPlayers: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &fillwithcomputerplayers_))); set_has_fillwithcomputerplayers(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:StartEventMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:StartEventMessage) + return false; #undef DO_ } void StartEventMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:StartEventMessage) // required .StartEventMessage.StartEventType startEventType = 1; if (has_starteventtype()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -11640,6 +13112,9 @@ void StartEventMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->fillwithcomputerplayers(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:StartEventMessage) } int StartEventMessage::ByteSize() const { @@ -11658,6 +13133,8 @@ int StartEventMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -11679,6 +13156,7 @@ void StartEventMessage::MergeFrom(const StartEventMessage& from) { set_fillwithcomputerplayers(from.fillwithcomputerplayers()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void StartEventMessage::CopyFrom(const StartEventMessage& from) { @@ -11698,6 +13176,7 @@ void StartEventMessage::Swap(StartEventMessage* other) { std::swap(starteventtype_, other->starteventtype_); std::swap(fillwithcomputerplayers_, other->fillwithcomputerplayers_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -11715,6 +13194,7 @@ void StartEventMessage::Swap(StartEventMessage* other) { StartEventAckMessage::StartEventAckMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:StartEventAckMessage) } void StartEventAckMessage::InitAsDefaultInstance() { @@ -11724,6 +13204,7 @@ StartEventAckMessage::StartEventAckMessage(const StartEventAckMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:StartEventAckMessage) } void StartEventAckMessage::SharedCtor() { @@ -11732,6 +13213,7 @@ void StartEventAckMessage::SharedCtor() { } StartEventAckMessage::~StartEventAckMessage() { + // @@protoc_insertion_point(destructor:StartEventAckMessage) SharedDtor(); } @@ -11766,30 +13248,53 @@ StartEventAckMessage* StartEventAckMessage::New() const { void StartEventAckMessage::Clear() { ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool StartEventAckMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:StartEventAckMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); } +success: + // @@protoc_insertion_point(parse_success:StartEventAckMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:StartEventAckMessage) + return false; #undef DO_ } void StartEventAckMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:StartEventAckMessage) + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:StartEventAckMessage) } int StartEventAckMessage::ByteSize() const { int total_size = 0; + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -11803,6 +13308,7 @@ void StartEventAckMessage::CheckTypeAndMergeFrom( void StartEventAckMessage::MergeFrom(const StartEventAckMessage& from) { GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->append(from.unknown_fields()); } void StartEventAckMessage::CopyFrom(const StartEventAckMessage& from) { @@ -11818,6 +13324,7 @@ bool StartEventAckMessage::IsInitialized() const { void StartEventAckMessage::Swap(StartEventAckMessage* other) { if (other != this) { + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -11837,6 +13344,7 @@ const int GameStartInitialMessage::kPlayerSeatsFieldNumber; GameStartInitialMessage::GameStartInitialMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameStartInitialMessage) } void GameStartInitialMessage::InitAsDefaultInstance() { @@ -11846,6 +13354,7 @@ GameStartInitialMessage::GameStartInitialMessage(const GameStartInitialMessage& : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameStartInitialMessage) } void GameStartInitialMessage::SharedCtor() { @@ -11855,6 +13364,7 @@ void GameStartInitialMessage::SharedCtor() { } GameStartInitialMessage::~GameStartInitialMessage() { + // @@protoc_insertion_point(destructor:GameStartInitialMessage) SharedDtor(); } @@ -11888,29 +13398,35 @@ GameStartInitialMessage* GameStartInitialMessage::New() const { } void GameStartInitialMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - startdealerplayerid_ = 0u; - } + startdealerplayerid_ = 0u; playerseats_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameStartInitialMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameStartInitialMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 startDealerPlayerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &startdealerplayerid_))); set_has_startdealerplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_playerSeats; break; @@ -11918,42 +13434,47 @@ bool GameStartInitialMessage::MergePartialFromCodedStream( // repeated uint32 playerSeats = 2 [packed = true]; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_playerSeats: DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, this->mutable_playerseats()))); - } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) - == ::google::protobuf::internal::WireFormatLite:: - WIRETYPE_VARINT) { + } else if (tag == 16) { DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( 1, 18, input, this->mutable_playerseats()))); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameStartInitialMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameStartInitialMessage) + return false; #undef DO_ } void GameStartInitialMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameStartInitialMessage) // required uint32 startDealerPlayerId = 1; if (has_startdealerplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->startdealerplayerid(), output); @@ -11969,6 +13490,9 @@ void GameStartInitialMessage::SerializeWithCachedSizes( this->playerseats(i), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameStartInitialMessage) } int GameStartInitialMessage::ByteSize() const { @@ -12000,6 +13524,8 @@ int GameStartInitialMessage::ByteSize() const { total_size += data_size; } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -12019,6 +13545,7 @@ void GameStartInitialMessage::MergeFrom(const GameStartInitialMessage& from) { set_startdealerplayerid(from.startdealerplayerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameStartInitialMessage::CopyFrom(const GameStartInitialMessage& from) { @@ -12038,6 +13565,7 @@ void GameStartInitialMessage::Swap(GameStartInitialMessage* other) { std::swap(startdealerplayerid_, other->startdealerplayerid_); playerseats_.Swap(&other->playerseats_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -12057,6 +13585,7 @@ const int GameStartRejoinMessage_RejoinPlayerData::kPlayerMoneyFieldNumber; GameStartRejoinMessage_RejoinPlayerData::GameStartRejoinMessage_RejoinPlayerData() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameStartRejoinMessage.RejoinPlayerData) } void GameStartRejoinMessage_RejoinPlayerData::InitAsDefaultInstance() { @@ -12066,6 +13595,7 @@ GameStartRejoinMessage_RejoinPlayerData::GameStartRejoinMessage_RejoinPlayerData : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameStartRejoinMessage.RejoinPlayerData) } void GameStartRejoinMessage_RejoinPlayerData::SharedCtor() { @@ -12076,6 +13606,7 @@ void GameStartRejoinMessage_RejoinPlayerData::SharedCtor() { } GameStartRejoinMessage_RejoinPlayerData::~GameStartRejoinMessage_RejoinPlayerData() { + // @@protoc_insertion_point(destructor:GameStartRejoinMessage.RejoinPlayerData) SharedDtor(); } @@ -12109,29 +13640,48 @@ GameStartRejoinMessage_RejoinPlayerData* GameStartRejoinMessage_RejoinPlayerData } void GameStartRejoinMessage_RejoinPlayerData::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - playermoney_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(playerid_, playermoney_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameStartRejoinMessage_RejoinPlayerData::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameStartRejoinMessage.RejoinPlayerData) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_playerMoney; break; @@ -12139,37 +13689,44 @@ bool GameStartRejoinMessage_RejoinPlayerData::MergePartialFromCodedStream( // required uint32 playerMoney = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_playerMoney: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playermoney_))); set_has_playermoney(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameStartRejoinMessage.RejoinPlayerData) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameStartRejoinMessage.RejoinPlayerData) + return false; #undef DO_ } void GameStartRejoinMessage_RejoinPlayerData::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameStartRejoinMessage.RejoinPlayerData) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -12180,6 +13737,9 @@ void GameStartRejoinMessage_RejoinPlayerData::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playermoney(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameStartRejoinMessage.RejoinPlayerData) } int GameStartRejoinMessage_RejoinPlayerData::ByteSize() const { @@ -12201,6 +13761,8 @@ int GameStartRejoinMessage_RejoinPlayerData::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -12222,6 +13784,7 @@ void GameStartRejoinMessage_RejoinPlayerData::MergeFrom(const GameStartRejoinMes set_playermoney(from.playermoney()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameStartRejoinMessage_RejoinPlayerData::CopyFrom(const GameStartRejoinMessage_RejoinPlayerData& from) { @@ -12241,6 +13804,7 @@ void GameStartRejoinMessage_RejoinPlayerData::Swap(GameStartRejoinMessage_Rejoin std::swap(playerid_, other->playerid_); std::swap(playermoney_, other->playermoney_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -12261,6 +13825,7 @@ const int GameStartRejoinMessage::kRejoinPlayerDataFieldNumber; GameStartRejoinMessage::GameStartRejoinMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameStartRejoinMessage) } void GameStartRejoinMessage::InitAsDefaultInstance() { @@ -12270,6 +13835,7 @@ GameStartRejoinMessage::GameStartRejoinMessage(const GameStartRejoinMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameStartRejoinMessage) } void GameStartRejoinMessage::SharedCtor() { @@ -12280,6 +13846,7 @@ void GameStartRejoinMessage::SharedCtor() { } GameStartRejoinMessage::~GameStartRejoinMessage() { + // @@protoc_insertion_point(destructor:GameStartRejoinMessage) SharedDtor(); } @@ -12313,30 +13880,49 @@ GameStartRejoinMessage* GameStartRejoinMessage::New() const { } void GameStartRejoinMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - startdealerplayerid_ = 0u; - handnum_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(startdealerplayerid_, handnum_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + rejoinplayerdata_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameStartRejoinMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameStartRejoinMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 startDealerPlayerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &startdealerplayerid_))); set_has_startdealerplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_handNum; break; @@ -12344,15 +13930,14 @@ bool GameStartRejoinMessage::MergePartialFromCodedStream( // required uint32 handNum = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_handNum: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &handnum_))); set_has_handnum(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_rejoinPlayerData; break; @@ -12360,36 +13945,43 @@ bool GameStartRejoinMessage::MergePartialFromCodedStream( // repeated .GameStartRejoinMessage.RejoinPlayerData rejoinPlayerData = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_rejoinPlayerData: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, add_rejoinplayerdata())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_rejoinPlayerData; - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameStartRejoinMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameStartRejoinMessage) + return false; #undef DO_ } void GameStartRejoinMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameStartRejoinMessage) // required uint32 startDealerPlayerId = 1; if (has_startdealerplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->startdealerplayerid(), output); @@ -12406,6 +13998,9 @@ void GameStartRejoinMessage::SerializeWithCachedSizes( 3, this->rejoinplayerdata(i), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameStartRejoinMessage) } int GameStartRejoinMessage::ByteSize() const { @@ -12435,6 +14030,8 @@ int GameStartRejoinMessage::ByteSize() const { this->rejoinplayerdata(i)); } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -12457,6 +14054,7 @@ void GameStartRejoinMessage::MergeFrom(const GameStartRejoinMessage& from) { set_handnum(from.handnum()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameStartRejoinMessage::CopyFrom(const GameStartRejoinMessage& from) { @@ -12468,9 +14066,7 @@ void GameStartRejoinMessage::CopyFrom(const GameStartRejoinMessage& from) { bool GameStartRejoinMessage::IsInitialized() const { if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; - for (int i = 0; i < rejoinplayerdata_size(); i++) { - if (!this->rejoinplayerdata(i).IsInitialized()) return false; - } + if (!::google::protobuf::internal::AllAreInitialized(this->rejoinplayerdata())) return false; return true; } @@ -12480,6 +14076,7 @@ void GameStartRejoinMessage::Swap(GameStartRejoinMessage* other) { std::swap(handnum_, other->handnum_); rejoinplayerdata_.Swap(&other->rejoinplayerdata_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -12499,6 +14096,7 @@ const int HandStartMessage_PlainCards::kPlainCard2FieldNumber; HandStartMessage_PlainCards::HandStartMessage_PlainCards() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:HandStartMessage.PlainCards) } void HandStartMessage_PlainCards::InitAsDefaultInstance() { @@ -12508,6 +14106,7 @@ HandStartMessage_PlainCards::HandStartMessage_PlainCards(const HandStartMessage_ : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:HandStartMessage.PlainCards) } void HandStartMessage_PlainCards::SharedCtor() { @@ -12518,6 +14117,7 @@ void HandStartMessage_PlainCards::SharedCtor() { } HandStartMessage_PlainCards::~HandStartMessage_PlainCards() { + // @@protoc_insertion_point(destructor:HandStartMessage.PlainCards) SharedDtor(); } @@ -12551,29 +14151,48 @@ HandStartMessage_PlainCards* HandStartMessage_PlainCards::New() const { } void HandStartMessage_PlainCards::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - plaincard1_ = 0u; - plaincard2_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(plaincard1_, plaincard2_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool HandStartMessage_PlainCards::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:HandStartMessage.PlainCards) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 plainCard1 = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &plaincard1_))); set_has_plaincard1(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_plainCard2; break; @@ -12581,37 +14200,44 @@ bool HandStartMessage_PlainCards::MergePartialFromCodedStream( // required uint32 plainCard2 = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_plainCard2: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &plaincard2_))); set_has_plaincard2(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:HandStartMessage.PlainCards) return true; +failure: + // @@protoc_insertion_point(parse_failure:HandStartMessage.PlainCards) + return false; #undef DO_ } void HandStartMessage_PlainCards::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:HandStartMessage.PlainCards) // required uint32 plainCard1 = 1; if (has_plaincard1()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->plaincard1(), output); @@ -12622,6 +14248,9 @@ void HandStartMessage_PlainCards::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->plaincard2(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:HandStartMessage.PlainCards) } int HandStartMessage_PlainCards::ByteSize() const { @@ -12643,6 +14272,8 @@ int HandStartMessage_PlainCards::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -12664,6 +14295,7 @@ void HandStartMessage_PlainCards::MergeFrom(const HandStartMessage_PlainCards& f set_plaincard2(from.plaincard2()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void HandStartMessage_PlainCards::CopyFrom(const HandStartMessage_PlainCards& from) { @@ -12683,6 +14315,7 @@ void HandStartMessage_PlainCards::Swap(HandStartMessage_PlainCards* other) { std::swap(plaincard1_, other->plaincard1_); std::swap(plaincard2_, other->plaincard2_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -12705,6 +14338,7 @@ const int HandStartMessage::kDealerPlayerIdFieldNumber; HandStartMessage::HandStartMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:HandStartMessage) } void HandStartMessage::InitAsDefaultInstance() { @@ -12720,23 +14354,26 @@ HandStartMessage::HandStartMessage(const HandStartMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:HandStartMessage) } void HandStartMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; plaincards_ = NULL; - encryptedcards_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + encryptedcards_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); smallblind_ = 0u; dealerplayerid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } HandStartMessage::~HandStartMessage() { + // @@protoc_insertion_point(destructor:HandStartMessage) SharedDtor(); } void HandStartMessage::SharedDtor() { - if (encryptedcards_ != &::google::protobuf::internal::kEmptyString) { + if (encryptedcards_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete encryptedcards_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -12769,36 +14406,57 @@ HandStartMessage* HandStartMessage::New() const { } void HandStartMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 23) { + ZR_(smallblind_, dealerplayerid_); if (has_plaincards()) { if (plaincards_ != NULL) plaincards_->::HandStartMessage_PlainCards::Clear(); } if (has_encryptedcards()) { - if (encryptedcards_ != &::google::protobuf::internal::kEmptyString) { + if (encryptedcards_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { encryptedcards_->clear(); } } - smallblind_ = 0u; - dealerplayerid_ = 0u; } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + seatstates_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool HandStartMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:HandStartMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // optional .HandStartMessage.PlainCards plainCards = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_plaincards())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_encryptedCards; break; @@ -12806,13 +14464,12 @@ bool HandStartMessage::MergePartialFromCodedStream( // optional bytes encryptedCards = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_encryptedCards: DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_encryptedcards())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_smallBlind; break; @@ -12820,15 +14477,14 @@ bool HandStartMessage::MergePartialFromCodedStream( // required uint32 smallBlind = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_smallBlind: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &smallblind_))); set_has_smallblind(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_seatStates; break; @@ -12836,8 +14492,7 @@ bool HandStartMessage::MergePartialFromCodedStream( // repeated .NetPlayerState seatStates = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_seatStates: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -12845,16 +14500,17 @@ bool HandStartMessage::MergePartialFromCodedStream( input, &value))); if (::NetPlayerState_IsValid(value)) { add_seatstates(static_cast< ::NetPlayerState >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } - } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) - == ::google::protobuf::internal::WireFormatLite:: - WIRETYPE_LENGTH_DELIMITED) { + } else if (tag == 34) { DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( input, &::NetPlayerState_IsValid, this->mutable_seatstates()))); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_seatStates; if (input->ExpectTag(40)) goto parse_dealerPlayerId; @@ -12863,37 +14519,44 @@ bool HandStartMessage::MergePartialFromCodedStream( // optional uint32 dealerPlayerId = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 40) { parse_dealerPlayerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &dealerplayerid_))); set_has_dealerplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:HandStartMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:HandStartMessage) + return false; #undef DO_ } void HandStartMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:HandStartMessage) // optional .HandStartMessage.PlainCards plainCards = 1; if (has_plaincards()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( @@ -12902,7 +14565,7 @@ void HandStartMessage::SerializeWithCachedSizes( // optional bytes encryptedCards = 2; if (has_encryptedcards()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 2, this->encryptedcards(), output); } @@ -12922,6 +14585,9 @@ void HandStartMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->dealerplayerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:HandStartMessage) } int HandStartMessage::ByteSize() const { @@ -12967,6 +14633,8 @@ int HandStartMessage::ByteSize() const { total_size += 1 * this->seatstates_size() + data_size; } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -12995,6 +14663,7 @@ void HandStartMessage::MergeFrom(const HandStartMessage& from) { set_dealerplayerid(from.dealerplayerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void HandStartMessage::CopyFrom(const HandStartMessage& from) { @@ -13020,6 +14689,7 @@ void HandStartMessage::Swap(HandStartMessage* other) { seatstates_.Swap(&other->seatstates_); std::swap(dealerplayerid_, other->dealerplayerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -13039,6 +14709,7 @@ const int PlayersTurnMessage::kGameStateFieldNumber; PlayersTurnMessage::PlayersTurnMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PlayersTurnMessage) } void PlayersTurnMessage::InitAsDefaultInstance() { @@ -13048,6 +14719,7 @@ PlayersTurnMessage::PlayersTurnMessage(const PlayersTurnMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PlayersTurnMessage) } void PlayersTurnMessage::SharedCtor() { @@ -13058,6 +14730,7 @@ void PlayersTurnMessage::SharedCtor() { } PlayersTurnMessage::~PlayersTurnMessage() { + // @@protoc_insertion_point(destructor:PlayersTurnMessage) SharedDtor(); } @@ -13091,29 +14764,48 @@ PlayersTurnMessage* PlayersTurnMessage::New() const { } void PlayersTurnMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - gamestate_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(playerid_, gamestate_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PlayersTurnMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PlayersTurnMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_gameState; break; @@ -13121,8 +14813,7 @@ bool PlayersTurnMessage::MergePartialFromCodedStream( // required .NetGameState gameState = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_gameState: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -13130,31 +14821,42 @@ bool PlayersTurnMessage::MergePartialFromCodedStream( input, &value))); if (::NetGameState_IsValid(value)) { set_gamestate(static_cast< ::NetGameState >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PlayersTurnMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:PlayersTurnMessage) + return false; #undef DO_ } void PlayersTurnMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PlayersTurnMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -13166,6 +14868,9 @@ void PlayersTurnMessage::SerializeWithCachedSizes( 2, this->gamestate(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PlayersTurnMessage) } int PlayersTurnMessage::ByteSize() const { @@ -13186,6 +14891,8 @@ int PlayersTurnMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -13207,6 +14914,7 @@ void PlayersTurnMessage::MergeFrom(const PlayersTurnMessage& from) { set_gamestate(from.gamestate()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void PlayersTurnMessage::CopyFrom(const PlayersTurnMessage& from) { @@ -13226,6 +14934,7 @@ void PlayersTurnMessage::Swap(PlayersTurnMessage* other) { std::swap(playerid_, other->playerid_); std::swap(gamestate_, other->gamestate_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -13247,6 +14956,7 @@ const int MyActionRequestMessage::kMyRelativeBetFieldNumber; MyActionRequestMessage::MyActionRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:MyActionRequestMessage) } void MyActionRequestMessage::InitAsDefaultInstance() { @@ -13256,6 +14966,7 @@ MyActionRequestMessage::MyActionRequestMessage(const MyActionRequestMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:MyActionRequestMessage) } void MyActionRequestMessage::SharedCtor() { @@ -13268,6 +14979,7 @@ void MyActionRequestMessage::SharedCtor() { } MyActionRequestMessage::~MyActionRequestMessage() { + // @@protoc_insertion_point(destructor:MyActionRequestMessage) SharedDtor(); } @@ -13301,31 +15013,48 @@ MyActionRequestMessage* MyActionRequestMessage::New() const { } void MyActionRequestMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - handnum_ = 0u; - gamestate_ = 0; - myaction_ = 0; - myrelativebet_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(handnum_, myrelativebet_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool MyActionRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:MyActionRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 handNum = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &handnum_))); set_has_handnum(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_gameState; break; @@ -13333,8 +15062,7 @@ bool MyActionRequestMessage::MergePartialFromCodedStream( // required .NetGameState gameState = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_gameState: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -13342,9 +15070,12 @@ bool MyActionRequestMessage::MergePartialFromCodedStream( input, &value))); if (::NetGameState_IsValid(value)) { set_gamestate(static_cast< ::NetGameState >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_myAction; break; @@ -13352,8 +15083,7 @@ bool MyActionRequestMessage::MergePartialFromCodedStream( // required .NetPlayerAction myAction = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_myAction: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -13361,9 +15091,12 @@ bool MyActionRequestMessage::MergePartialFromCodedStream( input, &value))); if (::NetPlayerAction_IsValid(value)) { set_myaction(static_cast< ::NetPlayerAction >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_myRelativeBet; break; @@ -13371,37 +15104,44 @@ bool MyActionRequestMessage::MergePartialFromCodedStream( // required uint32 myRelativeBet = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_myRelativeBet: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &myrelativebet_))); set_has_myrelativebet(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:MyActionRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:MyActionRequestMessage) + return false; #undef DO_ } void MyActionRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:MyActionRequestMessage) // required uint32 handNum = 1; if (has_handnum()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->handnum(), output); @@ -13424,6 +15164,9 @@ void MyActionRequestMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->myrelativebet(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:MyActionRequestMessage) } int MyActionRequestMessage::ByteSize() const { @@ -13457,6 +15200,8 @@ int MyActionRequestMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -13484,6 +15229,7 @@ void MyActionRequestMessage::MergeFrom(const MyActionRequestMessage& from) { set_myrelativebet(from.myrelativebet()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void MyActionRequestMessage::CopyFrom(const MyActionRequestMessage& from) { @@ -13505,6 +15251,7 @@ void MyActionRequestMessage::Swap(MyActionRequestMessage* other) { std::swap(myaction_, other->myaction_); std::swap(myrelativebet_, other->myrelativebet_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -13545,6 +15292,7 @@ const int YourActionRejectedMessage::kRejectionReasonFieldNumber; YourActionRejectedMessage::YourActionRejectedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:YourActionRejectedMessage) } void YourActionRejectedMessage::InitAsDefaultInstance() { @@ -13554,6 +15302,7 @@ YourActionRejectedMessage::YourActionRejectedMessage(const YourActionRejectedMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:YourActionRejectedMessage) } void YourActionRejectedMessage::SharedCtor() { @@ -13566,6 +15315,7 @@ void YourActionRejectedMessage::SharedCtor() { } YourActionRejectedMessage::~YourActionRejectedMessage() { + // @@protoc_insertion_point(destructor:YourActionRejectedMessage) SharedDtor(); } @@ -13599,34 +15349,57 @@ YourActionRejectedMessage* YourActionRejectedMessage::New() const { } void YourActionRejectedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - gamestate_ = 0; - youraction_ = 0; - yourrelativebet_ = 0u; +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 15) { + ZR_(gamestate_, yourrelativebet_); rejectionreason_ = 1; } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool YourActionRejectedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:YourActionRejectedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .NetGameState gameState = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::NetGameState_IsValid(value)) { set_gamestate(static_cast< ::NetGameState >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_yourAction; break; @@ -13634,8 +15407,7 @@ bool YourActionRejectedMessage::MergePartialFromCodedStream( // required .NetPlayerAction yourAction = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_yourAction: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -13643,9 +15415,12 @@ bool YourActionRejectedMessage::MergePartialFromCodedStream( input, &value))); if (::NetPlayerAction_IsValid(value)) { set_youraction(static_cast< ::NetPlayerAction >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_yourRelativeBet; break; @@ -13653,15 +15428,14 @@ bool YourActionRejectedMessage::MergePartialFromCodedStream( // required uint32 yourRelativeBet = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_yourRelativeBet: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &yourrelativebet_))); set_has_yourrelativebet(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_rejectionReason; break; @@ -13669,8 +15443,7 @@ bool YourActionRejectedMessage::MergePartialFromCodedStream( // required .YourActionRejectedMessage.RejectionReason rejectionReason = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_rejectionReason: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -13678,31 +15451,42 @@ bool YourActionRejectedMessage::MergePartialFromCodedStream( input, &value))); if (::YourActionRejectedMessage_RejectionReason_IsValid(value)) { set_rejectionreason(static_cast< ::YourActionRejectedMessage_RejectionReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:YourActionRejectedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:YourActionRejectedMessage) + return false; #undef DO_ } void YourActionRejectedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:YourActionRejectedMessage) // required .NetGameState gameState = 1; if (has_gamestate()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -13726,6 +15510,9 @@ void YourActionRejectedMessage::SerializeWithCachedSizes( 4, this->rejectionreason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:YourActionRejectedMessage) } int YourActionRejectedMessage::ByteSize() const { @@ -13758,6 +15545,8 @@ int YourActionRejectedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -13785,6 +15574,7 @@ void YourActionRejectedMessage::MergeFrom(const YourActionRejectedMessage& from) set_rejectionreason(from.rejectionreason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void YourActionRejectedMessage::CopyFrom(const YourActionRejectedMessage& from) { @@ -13806,6 +15596,7 @@ void YourActionRejectedMessage::Swap(YourActionRejectedMessage* other) { std::swap(yourrelativebet_, other->yourrelativebet_); std::swap(rejectionreason_, other->rejectionreason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -13830,6 +15621,7 @@ const int PlayersActionDoneMessage::kMinimumRaiseFieldNumber; PlayersActionDoneMessage::PlayersActionDoneMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PlayersActionDoneMessage) } void PlayersActionDoneMessage::InitAsDefaultInstance() { @@ -13839,6 +15631,7 @@ PlayersActionDoneMessage::PlayersActionDoneMessage(const PlayersActionDoneMessag : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PlayersActionDoneMessage) } void PlayersActionDoneMessage::SharedCtor() { @@ -13854,6 +15647,7 @@ void PlayersActionDoneMessage::SharedCtor() { } PlayersActionDoneMessage::~PlayersActionDoneMessage() { + // @@protoc_insertion_point(destructor:PlayersActionDoneMessage) SharedDtor(); } @@ -13887,34 +15681,50 @@ PlayersActionDoneMessage* PlayersActionDoneMessage::New() const { } void PlayersActionDoneMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - gamestate_ = 0; - playeraction_ = 0; - totalplayerbet_ = 0u; - playermoney_ = 0u; - highestset_ = 0u; - minimumraise_ = 0u; +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 127) { + ZR_(playerid_, minimumraise_); } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PlayersActionDoneMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PlayersActionDoneMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_gameState; break; @@ -13922,8 +15732,7 @@ bool PlayersActionDoneMessage::MergePartialFromCodedStream( // required .NetGameState gameState = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_gameState: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -13931,9 +15740,12 @@ bool PlayersActionDoneMessage::MergePartialFromCodedStream( input, &value))); if (::NetGameState_IsValid(value)) { set_gamestate(static_cast< ::NetGameState >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_playerAction; break; @@ -13941,8 +15753,7 @@ bool PlayersActionDoneMessage::MergePartialFromCodedStream( // required .NetPlayerAction playerAction = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_playerAction: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -13950,9 +15761,12 @@ bool PlayersActionDoneMessage::MergePartialFromCodedStream( input, &value))); if (::NetPlayerAction_IsValid(value)) { set_playeraction(static_cast< ::NetPlayerAction >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_totalPlayerBet; break; @@ -13960,15 +15774,14 @@ bool PlayersActionDoneMessage::MergePartialFromCodedStream( // required uint32 totalPlayerBet = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_totalPlayerBet: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &totalplayerbet_))); set_has_totalplayerbet(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(40)) goto parse_playerMoney; break; @@ -13976,15 +15789,14 @@ bool PlayersActionDoneMessage::MergePartialFromCodedStream( // required uint32 playerMoney = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 40) { parse_playerMoney: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playermoney_))); set_has_playermoney(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(48)) goto parse_highestSet; break; @@ -13992,15 +15804,14 @@ bool PlayersActionDoneMessage::MergePartialFromCodedStream( // required uint32 highestSet = 6; case 6: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 48) { parse_highestSet: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &highestset_))); set_has_highestset(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(56)) goto parse_minimumRaise; break; @@ -14008,37 +15819,44 @@ bool PlayersActionDoneMessage::MergePartialFromCodedStream( // required uint32 minimumRaise = 7; case 7: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 56) { parse_minimumRaise: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &minimumraise_))); set_has_minimumraise(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PlayersActionDoneMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:PlayersActionDoneMessage) + return false; #undef DO_ } void PlayersActionDoneMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PlayersActionDoneMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -14076,6 +15894,9 @@ void PlayersActionDoneMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->minimumraise(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PlayersActionDoneMessage) } int PlayersActionDoneMessage::ByteSize() const { @@ -14130,6 +15951,8 @@ int PlayersActionDoneMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -14166,6 +15989,7 @@ void PlayersActionDoneMessage::MergeFrom(const PlayersActionDoneMessage& from) { set_minimumraise(from.minimumraise()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void PlayersActionDoneMessage::CopyFrom(const PlayersActionDoneMessage& from) { @@ -14190,6 +16014,7 @@ void PlayersActionDoneMessage::Swap(PlayersActionDoneMessage* other) { std::swap(highestset_, other->highestset_); std::swap(minimumraise_, other->minimumraise_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -14210,6 +16035,7 @@ const int DealFlopCardsMessage::kFlopCard3FieldNumber; DealFlopCardsMessage::DealFlopCardsMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:DealFlopCardsMessage) } void DealFlopCardsMessage::InitAsDefaultInstance() { @@ -14219,6 +16045,7 @@ DealFlopCardsMessage::DealFlopCardsMessage(const DealFlopCardsMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:DealFlopCardsMessage) } void DealFlopCardsMessage::SharedCtor() { @@ -14230,6 +16057,7 @@ void DealFlopCardsMessage::SharedCtor() { } DealFlopCardsMessage::~DealFlopCardsMessage() { + // @@protoc_insertion_point(destructor:DealFlopCardsMessage) SharedDtor(); } @@ -14263,30 +16091,48 @@ DealFlopCardsMessage* DealFlopCardsMessage::New() const { } void DealFlopCardsMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - flopcard1_ = 0u; - flopcard2_ = 0u; - flopcard3_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(flopcard1_, flopcard3_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool DealFlopCardsMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:DealFlopCardsMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 flopCard1 = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &flopcard1_))); set_has_flopcard1(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_flopCard2; break; @@ -14294,15 +16140,14 @@ bool DealFlopCardsMessage::MergePartialFromCodedStream( // required uint32 flopCard2 = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_flopCard2: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &flopcard2_))); set_has_flopcard2(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_flopCard3; break; @@ -14310,37 +16155,44 @@ bool DealFlopCardsMessage::MergePartialFromCodedStream( // required uint32 flopCard3 = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_flopCard3: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &flopcard3_))); set_has_flopcard3(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:DealFlopCardsMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:DealFlopCardsMessage) + return false; #undef DO_ } void DealFlopCardsMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:DealFlopCardsMessage) // required uint32 flopCard1 = 1; if (has_flopcard1()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->flopcard1(), output); @@ -14356,6 +16208,9 @@ void DealFlopCardsMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->flopcard3(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:DealFlopCardsMessage) } int DealFlopCardsMessage::ByteSize() const { @@ -14384,6 +16239,8 @@ int DealFlopCardsMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -14408,6 +16265,7 @@ void DealFlopCardsMessage::MergeFrom(const DealFlopCardsMessage& from) { set_flopcard3(from.flopcard3()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void DealFlopCardsMessage::CopyFrom(const DealFlopCardsMessage& from) { @@ -14428,6 +16286,7 @@ void DealFlopCardsMessage::Swap(DealFlopCardsMessage* other) { std::swap(flopcard2_, other->flopcard2_); std::swap(flopcard3_, other->flopcard3_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -14446,6 +16305,7 @@ const int DealTurnCardMessage::kTurnCardFieldNumber; DealTurnCardMessage::DealTurnCardMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:DealTurnCardMessage) } void DealTurnCardMessage::InitAsDefaultInstance() { @@ -14455,6 +16315,7 @@ DealTurnCardMessage::DealTurnCardMessage(const DealTurnCardMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:DealTurnCardMessage) } void DealTurnCardMessage::SharedCtor() { @@ -14464,6 +16325,7 @@ void DealTurnCardMessage::SharedCtor() { } DealTurnCardMessage::~DealTurnCardMessage() { + // @@protoc_insertion_point(destructor:DealTurnCardMessage) SharedDtor(); } @@ -14497,55 +16359,72 @@ DealTurnCardMessage* DealTurnCardMessage::New() const { } void DealTurnCardMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - turncard_ = 0u; - } + turncard_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool DealTurnCardMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:DealTurnCardMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 turnCard = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &turncard_))); set_has_turncard(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:DealTurnCardMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:DealTurnCardMessage) + return false; #undef DO_ } void DealTurnCardMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:DealTurnCardMessage) // required uint32 turnCard = 1; if (has_turncard()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->turncard(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:DealTurnCardMessage) } int DealTurnCardMessage::ByteSize() const { @@ -14560,6 +16439,8 @@ int DealTurnCardMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -14578,6 +16459,7 @@ void DealTurnCardMessage::MergeFrom(const DealTurnCardMessage& from) { set_turncard(from.turncard()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void DealTurnCardMessage::CopyFrom(const DealTurnCardMessage& from) { @@ -14596,6 +16478,7 @@ void DealTurnCardMessage::Swap(DealTurnCardMessage* other) { if (other != this) { std::swap(turncard_, other->turncard_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -14614,6 +16497,7 @@ const int DealRiverCardMessage::kRiverCardFieldNumber; DealRiverCardMessage::DealRiverCardMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:DealRiverCardMessage) } void DealRiverCardMessage::InitAsDefaultInstance() { @@ -14623,6 +16507,7 @@ DealRiverCardMessage::DealRiverCardMessage(const DealRiverCardMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:DealRiverCardMessage) } void DealRiverCardMessage::SharedCtor() { @@ -14632,6 +16517,7 @@ void DealRiverCardMessage::SharedCtor() { } DealRiverCardMessage::~DealRiverCardMessage() { + // @@protoc_insertion_point(destructor:DealRiverCardMessage) SharedDtor(); } @@ -14665,55 +16551,72 @@ DealRiverCardMessage* DealRiverCardMessage::New() const { } void DealRiverCardMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - rivercard_ = 0u; - } + rivercard_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool DealRiverCardMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:DealRiverCardMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 riverCard = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &rivercard_))); set_has_rivercard(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:DealRiverCardMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:DealRiverCardMessage) + return false; #undef DO_ } void DealRiverCardMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:DealRiverCardMessage) // required uint32 riverCard = 1; if (has_rivercard()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->rivercard(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:DealRiverCardMessage) } int DealRiverCardMessage::ByteSize() const { @@ -14728,6 +16631,8 @@ int DealRiverCardMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -14746,6 +16651,7 @@ void DealRiverCardMessage::MergeFrom(const DealRiverCardMessage& from) { set_rivercard(from.rivercard()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void DealRiverCardMessage::CopyFrom(const DealRiverCardMessage& from) { @@ -14764,6 +16670,7 @@ void DealRiverCardMessage::Swap(DealRiverCardMessage* other) { if (other != this) { std::swap(rivercard_, other->rivercard_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -14784,6 +16691,7 @@ const int AllInShowCardsMessage_PlayerAllIn::kAllInCard2FieldNumber; AllInShowCardsMessage_PlayerAllIn::AllInShowCardsMessage_PlayerAllIn() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AllInShowCardsMessage.PlayerAllIn) } void AllInShowCardsMessage_PlayerAllIn::InitAsDefaultInstance() { @@ -14793,6 +16701,7 @@ AllInShowCardsMessage_PlayerAllIn::AllInShowCardsMessage_PlayerAllIn(const AllIn : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AllInShowCardsMessage.PlayerAllIn) } void AllInShowCardsMessage_PlayerAllIn::SharedCtor() { @@ -14804,6 +16713,7 @@ void AllInShowCardsMessage_PlayerAllIn::SharedCtor() { } AllInShowCardsMessage_PlayerAllIn::~AllInShowCardsMessage_PlayerAllIn() { + // @@protoc_insertion_point(destructor:AllInShowCardsMessage.PlayerAllIn) SharedDtor(); } @@ -14837,30 +16747,48 @@ AllInShowCardsMessage_PlayerAllIn* AllInShowCardsMessage_PlayerAllIn::New() cons } void AllInShowCardsMessage_PlayerAllIn::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - allincard1_ = 0u; - allincard2_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(playerid_, allincard2_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AllInShowCardsMessage_PlayerAllIn::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AllInShowCardsMessage.PlayerAllIn) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_allInCard1; break; @@ -14868,15 +16796,14 @@ bool AllInShowCardsMessage_PlayerAllIn::MergePartialFromCodedStream( // required uint32 allInCard1 = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_allInCard1: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &allincard1_))); set_has_allincard1(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_allInCard2; break; @@ -14884,37 +16811,44 @@ bool AllInShowCardsMessage_PlayerAllIn::MergePartialFromCodedStream( // required uint32 allInCard2 = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_allInCard2: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &allincard2_))); set_has_allincard2(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AllInShowCardsMessage.PlayerAllIn) return true; +failure: + // @@protoc_insertion_point(parse_failure:AllInShowCardsMessage.PlayerAllIn) + return false; #undef DO_ } void AllInShowCardsMessage_PlayerAllIn::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AllInShowCardsMessage.PlayerAllIn) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -14930,6 +16864,9 @@ void AllInShowCardsMessage_PlayerAllIn::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->allincard2(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AllInShowCardsMessage.PlayerAllIn) } int AllInShowCardsMessage_PlayerAllIn::ByteSize() const { @@ -14958,6 +16895,8 @@ int AllInShowCardsMessage_PlayerAllIn::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -14982,6 +16921,7 @@ void AllInShowCardsMessage_PlayerAllIn::MergeFrom(const AllInShowCardsMessage_Pl set_allincard2(from.allincard2()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AllInShowCardsMessage_PlayerAllIn::CopyFrom(const AllInShowCardsMessage_PlayerAllIn& from) { @@ -15002,6 +16942,7 @@ void AllInShowCardsMessage_PlayerAllIn::Swap(AllInShowCardsMessage_PlayerAllIn* std::swap(allincard1_, other->allincard1_); std::swap(allincard2_, other->allincard2_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -15020,6 +16961,7 @@ const int AllInShowCardsMessage::kPlayersAllInFieldNumber; AllInShowCardsMessage::AllInShowCardsMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AllInShowCardsMessage) } void AllInShowCardsMessage::InitAsDefaultInstance() { @@ -15029,6 +16971,7 @@ AllInShowCardsMessage::AllInShowCardsMessage(const AllInShowCardsMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AllInShowCardsMessage) } void AllInShowCardsMessage::SharedCtor() { @@ -15037,6 +16980,7 @@ void AllInShowCardsMessage::SharedCtor() { } AllInShowCardsMessage::~AllInShowCardsMessage() { + // @@protoc_insertion_point(destructor:AllInShowCardsMessage) SharedDtor(); } @@ -15072,52 +17016,71 @@ AllInShowCardsMessage* AllInShowCardsMessage::New() const { void AllInShowCardsMessage::Clear() { playersallin_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AllInShowCardsMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AllInShowCardsMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // repeated .AllInShowCardsMessage.PlayerAllIn playersAllIn = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { parse_playersAllIn: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, add_playersallin())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(10)) goto parse_playersAllIn; - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AllInShowCardsMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AllInShowCardsMessage) + return false; #undef DO_ } void AllInShowCardsMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AllInShowCardsMessage) // repeated .AllInShowCardsMessage.PlayerAllIn playersAllIn = 1; for (int i = 0; i < this->playersallin_size(); i++) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 1, this->playersallin(i), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AllInShowCardsMessage) } int AllInShowCardsMessage::ByteSize() const { @@ -15131,6 +17094,8 @@ int AllInShowCardsMessage::ByteSize() const { this->playersallin(i)); } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -15145,6 +17110,7 @@ void AllInShowCardsMessage::CheckTypeAndMergeFrom( void AllInShowCardsMessage::MergeFrom(const AllInShowCardsMessage& from) { GOOGLE_CHECK_NE(&from, this); playersallin_.MergeFrom(from.playersallin_); + mutable_unknown_fields()->append(from.unknown_fields()); } void AllInShowCardsMessage::CopyFrom(const AllInShowCardsMessage& from) { @@ -15155,9 +17121,7 @@ void AllInShowCardsMessage::CopyFrom(const AllInShowCardsMessage& from) { bool AllInShowCardsMessage::IsInitialized() const { - for (int i = 0; i < playersallin_size(); i++) { - if (!this->playersallin(i).IsInitialized()) return false; - } + if (!::google::protobuf::internal::AllAreInitialized(this->playersallin())) return false; return true; } @@ -15165,6 +17129,7 @@ void AllInShowCardsMessage::Swap(AllInShowCardsMessage* other) { if (other != this) { playersallin_.Swap(&other->playersallin_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -15183,6 +17148,7 @@ const int EndOfHandShowCardsMessage::kPlayerResultsFieldNumber; EndOfHandShowCardsMessage::EndOfHandShowCardsMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:EndOfHandShowCardsMessage) } void EndOfHandShowCardsMessage::InitAsDefaultInstance() { @@ -15192,6 +17158,7 @@ EndOfHandShowCardsMessage::EndOfHandShowCardsMessage(const EndOfHandShowCardsMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:EndOfHandShowCardsMessage) } void EndOfHandShowCardsMessage::SharedCtor() { @@ -15200,6 +17167,7 @@ void EndOfHandShowCardsMessage::SharedCtor() { } EndOfHandShowCardsMessage::~EndOfHandShowCardsMessage() { + // @@protoc_insertion_point(destructor:EndOfHandShowCardsMessage) SharedDtor(); } @@ -15235,52 +17203,71 @@ EndOfHandShowCardsMessage* EndOfHandShowCardsMessage::New() const { void EndOfHandShowCardsMessage::Clear() { playerresults_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool EndOfHandShowCardsMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:EndOfHandShowCardsMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // repeated .PlayerResult playerResults = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { parse_playerResults: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, add_playerresults())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(10)) goto parse_playerResults; - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:EndOfHandShowCardsMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:EndOfHandShowCardsMessage) + return false; #undef DO_ } void EndOfHandShowCardsMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:EndOfHandShowCardsMessage) // repeated .PlayerResult playerResults = 1; for (int i = 0; i < this->playerresults_size(); i++) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 1, this->playerresults(i), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:EndOfHandShowCardsMessage) } int EndOfHandShowCardsMessage::ByteSize() const { @@ -15294,6 +17281,8 @@ int EndOfHandShowCardsMessage::ByteSize() const { this->playerresults(i)); } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -15308,6 +17297,7 @@ void EndOfHandShowCardsMessage::CheckTypeAndMergeFrom( void EndOfHandShowCardsMessage::MergeFrom(const EndOfHandShowCardsMessage& from) { GOOGLE_CHECK_NE(&from, this); playerresults_.MergeFrom(from.playerresults_); + mutable_unknown_fields()->append(from.unknown_fields()); } void EndOfHandShowCardsMessage::CopyFrom(const EndOfHandShowCardsMessage& from) { @@ -15318,9 +17308,7 @@ void EndOfHandShowCardsMessage::CopyFrom(const EndOfHandShowCardsMessage& from) bool EndOfHandShowCardsMessage::IsInitialized() const { - for (int i = 0; i < playerresults_size(); i++) { - if (!this->playerresults(i).IsInitialized()) return false; - } + if (!::google::protobuf::internal::AllAreInitialized(this->playerresults())) return false; return true; } @@ -15328,6 +17316,7 @@ void EndOfHandShowCardsMessage::Swap(EndOfHandShowCardsMessage* other) { if (other != this) { playerresults_.Swap(&other->playerresults_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -15348,6 +17337,7 @@ const int EndOfHandHideCardsMessage::kPlayerMoneyFieldNumber; EndOfHandHideCardsMessage::EndOfHandHideCardsMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:EndOfHandHideCardsMessage) } void EndOfHandHideCardsMessage::InitAsDefaultInstance() { @@ -15357,6 +17347,7 @@ EndOfHandHideCardsMessage::EndOfHandHideCardsMessage(const EndOfHandHideCardsMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:EndOfHandHideCardsMessage) } void EndOfHandHideCardsMessage::SharedCtor() { @@ -15368,6 +17359,7 @@ void EndOfHandHideCardsMessage::SharedCtor() { } EndOfHandHideCardsMessage::~EndOfHandHideCardsMessage() { + // @@protoc_insertion_point(destructor:EndOfHandHideCardsMessage) SharedDtor(); } @@ -15401,30 +17393,48 @@ EndOfHandHideCardsMessage* EndOfHandHideCardsMessage::New() const { } void EndOfHandHideCardsMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - moneywon_ = 0u; - playermoney_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(playerid_, playermoney_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool EndOfHandHideCardsMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:EndOfHandHideCardsMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_moneyWon; break; @@ -15432,15 +17442,14 @@ bool EndOfHandHideCardsMessage::MergePartialFromCodedStream( // required uint32 moneyWon = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_moneyWon: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &moneywon_))); set_has_moneywon(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_playerMoney; break; @@ -15448,37 +17457,44 @@ bool EndOfHandHideCardsMessage::MergePartialFromCodedStream( // required uint32 playerMoney = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_playerMoney: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playermoney_))); set_has_playermoney(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:EndOfHandHideCardsMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:EndOfHandHideCardsMessage) + return false; #undef DO_ } void EndOfHandHideCardsMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:EndOfHandHideCardsMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -15494,6 +17510,9 @@ void EndOfHandHideCardsMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->playermoney(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:EndOfHandHideCardsMessage) } int EndOfHandHideCardsMessage::ByteSize() const { @@ -15522,6 +17541,8 @@ int EndOfHandHideCardsMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -15546,6 +17567,7 @@ void EndOfHandHideCardsMessage::MergeFrom(const EndOfHandHideCardsMessage& from) set_playermoney(from.playermoney()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void EndOfHandHideCardsMessage::CopyFrom(const EndOfHandHideCardsMessage& from) { @@ -15566,6 +17588,7 @@ void EndOfHandHideCardsMessage::Swap(EndOfHandHideCardsMessage* other) { std::swap(moneywon_, other->moneywon_); std::swap(playermoney_, other->playermoney_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -15583,6 +17606,7 @@ void EndOfHandHideCardsMessage::Swap(EndOfHandHideCardsMessage* other) { ShowMyCardsRequestMessage::ShowMyCardsRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ShowMyCardsRequestMessage) } void ShowMyCardsRequestMessage::InitAsDefaultInstance() { @@ -15592,6 +17616,7 @@ ShowMyCardsRequestMessage::ShowMyCardsRequestMessage(const ShowMyCardsRequestMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ShowMyCardsRequestMessage) } void ShowMyCardsRequestMessage::SharedCtor() { @@ -15600,6 +17625,7 @@ void ShowMyCardsRequestMessage::SharedCtor() { } ShowMyCardsRequestMessage::~ShowMyCardsRequestMessage() { + // @@protoc_insertion_point(destructor:ShowMyCardsRequestMessage) SharedDtor(); } @@ -15634,30 +17660,53 @@ ShowMyCardsRequestMessage* ShowMyCardsRequestMessage::New() const { void ShowMyCardsRequestMessage::Clear() { ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ShowMyCardsRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ShowMyCardsRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); } +success: + // @@protoc_insertion_point(parse_success:ShowMyCardsRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ShowMyCardsRequestMessage) + return false; #undef DO_ } void ShowMyCardsRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ShowMyCardsRequestMessage) + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ShowMyCardsRequestMessage) } int ShowMyCardsRequestMessage::ByteSize() const { int total_size = 0; + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -15671,6 +17720,7 @@ void ShowMyCardsRequestMessage::CheckTypeAndMergeFrom( void ShowMyCardsRequestMessage::MergeFrom(const ShowMyCardsRequestMessage& from) { GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->append(from.unknown_fields()); } void ShowMyCardsRequestMessage::CopyFrom(const ShowMyCardsRequestMessage& from) { @@ -15686,6 +17736,7 @@ bool ShowMyCardsRequestMessage::IsInitialized() const { void ShowMyCardsRequestMessage::Swap(ShowMyCardsRequestMessage* other) { if (other != this) { + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -15704,6 +17755,7 @@ const int AfterHandShowCardsMessage::kPlayerResultFieldNumber; AfterHandShowCardsMessage::AfterHandShowCardsMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AfterHandShowCardsMessage) } void AfterHandShowCardsMessage::InitAsDefaultInstance() { @@ -15719,6 +17771,7 @@ AfterHandShowCardsMessage::AfterHandShowCardsMessage(const AfterHandShowCardsMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AfterHandShowCardsMessage) } void AfterHandShowCardsMessage::SharedCtor() { @@ -15728,6 +17781,7 @@ void AfterHandShowCardsMessage::SharedCtor() { } AfterHandShowCardsMessage::~AfterHandShowCardsMessage() { + // @@protoc_insertion_point(destructor:AfterHandShowCardsMessage) SharedDtor(); } @@ -15762,56 +17816,73 @@ AfterHandShowCardsMessage* AfterHandShowCardsMessage::New() const { } void AfterHandShowCardsMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - if (has_playerresult()) { - if (playerresult_ != NULL) playerresult_->::PlayerResult::Clear(); - } + if (has_playerresult()) { + if (playerresult_ != NULL) playerresult_->::PlayerResult::Clear(); } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AfterHandShowCardsMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AfterHandShowCardsMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .PlayerResult playerResult = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_playerresult())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AfterHandShowCardsMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AfterHandShowCardsMessage) + return false; #undef DO_ } void AfterHandShowCardsMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AfterHandShowCardsMessage) // required .PlayerResult playerResult = 1; if (has_playerresult()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 1, this->playerresult(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AfterHandShowCardsMessage) } int AfterHandShowCardsMessage::ByteSize() const { @@ -15826,6 +17897,8 @@ int AfterHandShowCardsMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -15844,6 +17917,7 @@ void AfterHandShowCardsMessage::MergeFrom(const AfterHandShowCardsMessage& from) mutable_playerresult()->::PlayerResult::MergeFrom(from.playerresult()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AfterHandShowCardsMessage::CopyFrom(const AfterHandShowCardsMessage& from) { @@ -15865,6 +17939,7 @@ void AfterHandShowCardsMessage::Swap(AfterHandShowCardsMessage* other) { if (other != this) { std::swap(playerresult_, other->playerresult_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -15883,6 +17958,7 @@ const int EndOfGameMessage::kWinnerPlayerIdFieldNumber; EndOfGameMessage::EndOfGameMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:EndOfGameMessage) } void EndOfGameMessage::InitAsDefaultInstance() { @@ -15892,6 +17968,7 @@ EndOfGameMessage::EndOfGameMessage(const EndOfGameMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:EndOfGameMessage) } void EndOfGameMessage::SharedCtor() { @@ -15901,6 +17978,7 @@ void EndOfGameMessage::SharedCtor() { } EndOfGameMessage::~EndOfGameMessage() { + // @@protoc_insertion_point(destructor:EndOfGameMessage) SharedDtor(); } @@ -15934,55 +18012,72 @@ EndOfGameMessage* EndOfGameMessage::New() const { } void EndOfGameMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - winnerplayerid_ = 0u; - } + winnerplayerid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool EndOfGameMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:EndOfGameMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 winnerPlayerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &winnerplayerid_))); set_has_winnerplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:EndOfGameMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:EndOfGameMessage) + return false; #undef DO_ } void EndOfGameMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:EndOfGameMessage) // required uint32 winnerPlayerId = 1; if (has_winnerplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->winnerplayerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:EndOfGameMessage) } int EndOfGameMessage::ByteSize() const { @@ -15997,6 +18092,8 @@ int EndOfGameMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -16015,6 +18112,7 @@ void EndOfGameMessage::MergeFrom(const EndOfGameMessage& from) { set_winnerplayerid(from.winnerplayerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void EndOfGameMessage::CopyFrom(const EndOfGameMessage& from) { @@ -16033,6 +18131,7 @@ void EndOfGameMessage::Swap(EndOfGameMessage* other) { if (other != this) { std::swap(winnerplayerid_, other->winnerplayerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -16052,6 +18151,7 @@ const int PlayerIdChangedMessage::kNewPlayerIdFieldNumber; PlayerIdChangedMessage::PlayerIdChangedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PlayerIdChangedMessage) } void PlayerIdChangedMessage::InitAsDefaultInstance() { @@ -16061,6 +18161,7 @@ PlayerIdChangedMessage::PlayerIdChangedMessage(const PlayerIdChangedMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PlayerIdChangedMessage) } void PlayerIdChangedMessage::SharedCtor() { @@ -16071,6 +18172,7 @@ void PlayerIdChangedMessage::SharedCtor() { } PlayerIdChangedMessage::~PlayerIdChangedMessage() { + // @@protoc_insertion_point(destructor:PlayerIdChangedMessage) SharedDtor(); } @@ -16104,29 +18206,48 @@ PlayerIdChangedMessage* PlayerIdChangedMessage::New() const { } void PlayerIdChangedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - oldplayerid_ = 0u; - newplayerid_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(oldplayerid_, newplayerid_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PlayerIdChangedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PlayerIdChangedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 oldPlayerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &oldplayerid_))); set_has_oldplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_newPlayerId; break; @@ -16134,37 +18255,44 @@ bool PlayerIdChangedMessage::MergePartialFromCodedStream( // required uint32 newPlayerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_newPlayerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &newplayerid_))); set_has_newplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PlayerIdChangedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:PlayerIdChangedMessage) + return false; #undef DO_ } void PlayerIdChangedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PlayerIdChangedMessage) // required uint32 oldPlayerId = 1; if (has_oldplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->oldplayerid(), output); @@ -16175,6 +18303,9 @@ void PlayerIdChangedMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->newplayerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PlayerIdChangedMessage) } int PlayerIdChangedMessage::ByteSize() const { @@ -16196,6 +18327,8 @@ int PlayerIdChangedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -16217,6 +18350,7 @@ void PlayerIdChangedMessage::MergeFrom(const PlayerIdChangedMessage& from) { set_newplayerid(from.newplayerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void PlayerIdChangedMessage::CopyFrom(const PlayerIdChangedMessage& from) { @@ -16236,6 +18370,7 @@ void PlayerIdChangedMessage::Swap(PlayerIdChangedMessage* other) { std::swap(oldplayerid_, other->oldplayerid_); std::swap(newplayerid_, other->newplayerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -16254,6 +18389,7 @@ const int AskKickPlayerMessage::kPlayerIdFieldNumber; AskKickPlayerMessage::AskKickPlayerMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AskKickPlayerMessage) } void AskKickPlayerMessage::InitAsDefaultInstance() { @@ -16263,6 +18399,7 @@ AskKickPlayerMessage::AskKickPlayerMessage(const AskKickPlayerMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AskKickPlayerMessage) } void AskKickPlayerMessage::SharedCtor() { @@ -16272,6 +18409,7 @@ void AskKickPlayerMessage::SharedCtor() { } AskKickPlayerMessage::~AskKickPlayerMessage() { + // @@protoc_insertion_point(destructor:AskKickPlayerMessage) SharedDtor(); } @@ -16305,55 +18443,72 @@ AskKickPlayerMessage* AskKickPlayerMessage::New() const { } void AskKickPlayerMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - } + playerid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AskKickPlayerMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AskKickPlayerMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AskKickPlayerMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AskKickPlayerMessage) + return false; #undef DO_ } void AskKickPlayerMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AskKickPlayerMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AskKickPlayerMessage) } int AskKickPlayerMessage::ByteSize() const { @@ -16368,6 +18523,8 @@ int AskKickPlayerMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -16386,6 +18543,7 @@ void AskKickPlayerMessage::MergeFrom(const AskKickPlayerMessage& from) { set_playerid(from.playerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AskKickPlayerMessage::CopyFrom(const AskKickPlayerMessage& from) { @@ -16404,6 +18562,7 @@ void AskKickPlayerMessage::Swap(AskKickPlayerMessage* other) { if (other != this) { std::swap(playerid_, other->playerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -16446,6 +18605,7 @@ const int AskKickDeniedMessage::kKickDeniedReasonFieldNumber; AskKickDeniedMessage::AskKickDeniedMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AskKickDeniedMessage) } void AskKickDeniedMessage::InitAsDefaultInstance() { @@ -16455,6 +18615,7 @@ AskKickDeniedMessage::AskKickDeniedMessage(const AskKickDeniedMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AskKickDeniedMessage) } void AskKickDeniedMessage::SharedCtor() { @@ -16465,6 +18626,7 @@ void AskKickDeniedMessage::SharedCtor() { } AskKickDeniedMessage::~AskKickDeniedMessage() { + // @@protoc_insertion_point(destructor:AskKickDeniedMessage) SharedDtor(); } @@ -16498,29 +18660,48 @@ AskKickDeniedMessage* AskKickDeniedMessage::New() const { } void AskKickDeniedMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - kickdeniedreason_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(playerid_, kickdeniedreason_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AskKickDeniedMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AskKickDeniedMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_kickDeniedReason; break; @@ -16528,8 +18709,7 @@ bool AskKickDeniedMessage::MergePartialFromCodedStream( // required .AskKickDeniedMessage.KickDeniedReason kickDeniedReason = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_kickDeniedReason: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -16537,31 +18717,42 @@ bool AskKickDeniedMessage::MergePartialFromCodedStream( input, &value))); if (::AskKickDeniedMessage_KickDeniedReason_IsValid(value)) { set_kickdeniedreason(static_cast< ::AskKickDeniedMessage_KickDeniedReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AskKickDeniedMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AskKickDeniedMessage) + return false; #undef DO_ } void AskKickDeniedMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AskKickDeniedMessage) // required uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -16573,6 +18764,9 @@ void AskKickDeniedMessage::SerializeWithCachedSizes( 2, this->kickdeniedreason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AskKickDeniedMessage) } int AskKickDeniedMessage::ByteSize() const { @@ -16593,6 +18787,8 @@ int AskKickDeniedMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -16614,6 +18810,7 @@ void AskKickDeniedMessage::MergeFrom(const AskKickDeniedMessage& from) { set_kickdeniedreason(from.kickdeniedreason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AskKickDeniedMessage::CopyFrom(const AskKickDeniedMessage& from) { @@ -16633,6 +18830,7 @@ void AskKickDeniedMessage::Swap(AskKickDeniedMessage* other) { std::swap(playerid_, other->playerid_); std::swap(kickdeniedreason_, other->kickdeniedreason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -16655,6 +18853,7 @@ const int StartKickPetitionMessage::kNumVotesNeededToKickFieldNumber; StartKickPetitionMessage::StartKickPetitionMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:StartKickPetitionMessage) } void StartKickPetitionMessage::InitAsDefaultInstance() { @@ -16664,6 +18863,7 @@ StartKickPetitionMessage::StartKickPetitionMessage(const StartKickPetitionMessag : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:StartKickPetitionMessage) } void StartKickPetitionMessage::SharedCtor() { @@ -16677,6 +18877,7 @@ void StartKickPetitionMessage::SharedCtor() { } StartKickPetitionMessage::~StartKickPetitionMessage() { + // @@protoc_insertion_point(destructor:StartKickPetitionMessage) SharedDtor(); } @@ -16710,32 +18911,50 @@ StartKickPetitionMessage* StartKickPetitionMessage::New() const { } void StartKickPetitionMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - petitionid_ = 0u; - proposingplayerid_ = 0u; - kickplayerid_ = 0u; - kicktimeoutsec_ = 0u; - numvotesneededtokick_ = 0u; +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 31) { + ZR_(petitionid_, numvotesneededtokick_); } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool StartKickPetitionMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:StartKickPetitionMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 petitionId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &petitionid_))); set_has_petitionid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_proposingPlayerId; break; @@ -16743,15 +18962,14 @@ bool StartKickPetitionMessage::MergePartialFromCodedStream( // required uint32 proposingPlayerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_proposingPlayerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &proposingplayerid_))); set_has_proposingplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_kickPlayerId; break; @@ -16759,15 +18977,14 @@ bool StartKickPetitionMessage::MergePartialFromCodedStream( // required uint32 kickPlayerId = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_kickPlayerId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &kickplayerid_))); set_has_kickplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_kickTimeoutSec; break; @@ -16775,15 +18992,14 @@ bool StartKickPetitionMessage::MergePartialFromCodedStream( // required uint32 kickTimeoutSec = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_kickTimeoutSec: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &kicktimeoutsec_))); set_has_kicktimeoutsec(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(40)) goto parse_numVotesNeededToKick; break; @@ -16791,37 +19007,44 @@ bool StartKickPetitionMessage::MergePartialFromCodedStream( // required uint32 numVotesNeededToKick = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 40) { parse_numVotesNeededToKick: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &numvotesneededtokick_))); set_has_numvotesneededtokick(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:StartKickPetitionMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:StartKickPetitionMessage) + return false; #undef DO_ } void StartKickPetitionMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:StartKickPetitionMessage) // required uint32 petitionId = 1; if (has_petitionid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->petitionid(), output); @@ -16847,6 +19070,9 @@ void StartKickPetitionMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->numvotesneededtokick(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:StartKickPetitionMessage) } int StartKickPetitionMessage::ByteSize() const { @@ -16889,6 +19115,8 @@ int StartKickPetitionMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -16919,6 +19147,7 @@ void StartKickPetitionMessage::MergeFrom(const StartKickPetitionMessage& from) { set_numvotesneededtokick(from.numvotesneededtokick()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void StartKickPetitionMessage::CopyFrom(const StartKickPetitionMessage& from) { @@ -16941,6 +19170,7 @@ void StartKickPetitionMessage::Swap(StartKickPetitionMessage* other) { std::swap(kicktimeoutsec_, other->kicktimeoutsec_); std::swap(numvotesneededtokick_, other->numvotesneededtokick_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -16960,6 +19190,7 @@ const int VoteKickRequestMessage::kVoteKickFieldNumber; VoteKickRequestMessage::VoteKickRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:VoteKickRequestMessage) } void VoteKickRequestMessage::InitAsDefaultInstance() { @@ -16969,6 +19200,7 @@ VoteKickRequestMessage::VoteKickRequestMessage(const VoteKickRequestMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:VoteKickRequestMessage) } void VoteKickRequestMessage::SharedCtor() { @@ -16979,6 +19211,7 @@ void VoteKickRequestMessage::SharedCtor() { } VoteKickRequestMessage::~VoteKickRequestMessage() { + // @@protoc_insertion_point(destructor:VoteKickRequestMessage) SharedDtor(); } @@ -17012,29 +19245,48 @@ VoteKickRequestMessage* VoteKickRequestMessage::New() const { } void VoteKickRequestMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - petitionid_ = 0u; - votekick_ = false; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(petitionid_, votekick_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool VoteKickRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:VoteKickRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 petitionId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &petitionid_))); set_has_petitionid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_voteKick; break; @@ -17042,37 +19294,44 @@ bool VoteKickRequestMessage::MergePartialFromCodedStream( // required bool voteKick = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_voteKick: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( input, &votekick_))); set_has_votekick(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:VoteKickRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:VoteKickRequestMessage) + return false; #undef DO_ } void VoteKickRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:VoteKickRequestMessage) // required uint32 petitionId = 1; if (has_petitionid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->petitionid(), output); @@ -17083,6 +19342,9 @@ void VoteKickRequestMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->votekick(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:VoteKickRequestMessage) } int VoteKickRequestMessage::ByteSize() const { @@ -17102,6 +19364,8 @@ int VoteKickRequestMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -17123,6 +19387,7 @@ void VoteKickRequestMessage::MergeFrom(const VoteKickRequestMessage& from) { set_votekick(from.votekick()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void VoteKickRequestMessage::CopyFrom(const VoteKickRequestMessage& from) { @@ -17142,6 +19407,7 @@ void VoteKickRequestMessage::Swap(VoteKickRequestMessage* other) { std::swap(petitionid_, other->petitionid_); std::swap(votekick_, other->votekick_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -17180,6 +19446,7 @@ const int VoteKickReplyMessage::kVoteKickReplyTypeFieldNumber; VoteKickReplyMessage::VoteKickReplyMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:VoteKickReplyMessage) } void VoteKickReplyMessage::InitAsDefaultInstance() { @@ -17189,6 +19456,7 @@ VoteKickReplyMessage::VoteKickReplyMessage(const VoteKickReplyMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:VoteKickReplyMessage) } void VoteKickReplyMessage::SharedCtor() { @@ -17199,6 +19467,7 @@ void VoteKickReplyMessage::SharedCtor() { } VoteKickReplyMessage::~VoteKickReplyMessage() { + // @@protoc_insertion_point(destructor:VoteKickReplyMessage) SharedDtor(); } @@ -17232,29 +19501,48 @@ VoteKickReplyMessage* VoteKickReplyMessage::New() const { } void VoteKickReplyMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - petitionid_ = 0u; - votekickreplytype_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(petitionid_, votekickreplytype_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool VoteKickReplyMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:VoteKickReplyMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 petitionId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &petitionid_))); set_has_petitionid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_voteKickReplyType; break; @@ -17262,8 +19550,7 @@ bool VoteKickReplyMessage::MergePartialFromCodedStream( // required .VoteKickReplyMessage.VoteKickReplyType voteKickReplyType = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_voteKickReplyType: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -17271,31 +19558,42 @@ bool VoteKickReplyMessage::MergePartialFromCodedStream( input, &value))); if (::VoteKickReplyMessage_VoteKickReplyType_IsValid(value)) { set_votekickreplytype(static_cast< ::VoteKickReplyMessage_VoteKickReplyType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:VoteKickReplyMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:VoteKickReplyMessage) + return false; #undef DO_ } void VoteKickReplyMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:VoteKickReplyMessage) // required uint32 petitionId = 1; if (has_petitionid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->petitionid(), output); @@ -17307,6 +19605,9 @@ void VoteKickReplyMessage::SerializeWithCachedSizes( 2, this->votekickreplytype(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:VoteKickReplyMessage) } int VoteKickReplyMessage::ByteSize() const { @@ -17327,6 +19628,8 @@ int VoteKickReplyMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -17348,6 +19651,7 @@ void VoteKickReplyMessage::MergeFrom(const VoteKickReplyMessage& from) { set_votekickreplytype(from.votekickreplytype()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void VoteKickReplyMessage::CopyFrom(const VoteKickReplyMessage& from) { @@ -17367,6 +19671,7 @@ void VoteKickReplyMessage::Swap(VoteKickReplyMessage* other) { std::swap(petitionid_, other->petitionid_); std::swap(votekickreplytype_, other->votekickreplytype_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -17388,6 +19693,7 @@ const int KickPetitionUpdateMessage::kNumVotesNeededToKickFieldNumber; KickPetitionUpdateMessage::KickPetitionUpdateMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:KickPetitionUpdateMessage) } void KickPetitionUpdateMessage::InitAsDefaultInstance() { @@ -17397,6 +19703,7 @@ KickPetitionUpdateMessage::KickPetitionUpdateMessage(const KickPetitionUpdateMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:KickPetitionUpdateMessage) } void KickPetitionUpdateMessage::SharedCtor() { @@ -17409,6 +19716,7 @@ void KickPetitionUpdateMessage::SharedCtor() { } KickPetitionUpdateMessage::~KickPetitionUpdateMessage() { + // @@protoc_insertion_point(destructor:KickPetitionUpdateMessage) SharedDtor(); } @@ -17442,31 +19750,48 @@ KickPetitionUpdateMessage* KickPetitionUpdateMessage::New() const { } void KickPetitionUpdateMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - petitionid_ = 0u; - numvotesagainstkicking_ = 0u; - numvotesinfavourofkicking_ = 0u; - numvotesneededtokick_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(petitionid_, numvotesneededtokick_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool KickPetitionUpdateMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:KickPetitionUpdateMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 petitionId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &petitionid_))); set_has_petitionid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_numVotesAgainstKicking; break; @@ -17474,15 +19799,14 @@ bool KickPetitionUpdateMessage::MergePartialFromCodedStream( // required uint32 numVotesAgainstKicking = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_numVotesAgainstKicking: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &numvotesagainstkicking_))); set_has_numvotesagainstkicking(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_numVotesInFavourOfKicking; break; @@ -17490,15 +19814,14 @@ bool KickPetitionUpdateMessage::MergePartialFromCodedStream( // required uint32 numVotesInFavourOfKicking = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_numVotesInFavourOfKicking: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &numvotesinfavourofkicking_))); set_has_numvotesinfavourofkicking(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_numVotesNeededToKick; break; @@ -17506,37 +19829,44 @@ bool KickPetitionUpdateMessage::MergePartialFromCodedStream( // required uint32 numVotesNeededToKick = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_numVotesNeededToKick: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &numvotesneededtokick_))); set_has_numvotesneededtokick(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:KickPetitionUpdateMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:KickPetitionUpdateMessage) + return false; #undef DO_ } void KickPetitionUpdateMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:KickPetitionUpdateMessage) // required uint32 petitionId = 1; if (has_petitionid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->petitionid(), output); @@ -17557,6 +19887,9 @@ void KickPetitionUpdateMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->numvotesneededtokick(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:KickPetitionUpdateMessage) } int KickPetitionUpdateMessage::ByteSize() const { @@ -17592,6 +19925,8 @@ int KickPetitionUpdateMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -17619,6 +19954,7 @@ void KickPetitionUpdateMessage::MergeFrom(const KickPetitionUpdateMessage& from) set_numvotesneededtokick(from.numvotesneededtokick()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void KickPetitionUpdateMessage::CopyFrom(const KickPetitionUpdateMessage& from) { @@ -17640,6 +19976,7 @@ void KickPetitionUpdateMessage::Swap(KickPetitionUpdateMessage* other) { std::swap(numvotesinfavourofkicking_, other->numvotesinfavourofkicking_); std::swap(numvotesneededtokick_, other->numvotesneededtokick_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -17683,6 +20020,7 @@ const int EndKickPetitionMessage::kPetitionEndReasonFieldNumber; EndKickPetitionMessage::EndKickPetitionMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:EndKickPetitionMessage) } void EndKickPetitionMessage::InitAsDefaultInstance() { @@ -17692,6 +20030,7 @@ EndKickPetitionMessage::EndKickPetitionMessage(const EndKickPetitionMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:EndKickPetitionMessage) } void EndKickPetitionMessage::SharedCtor() { @@ -17705,6 +20044,7 @@ void EndKickPetitionMessage::SharedCtor() { } EndKickPetitionMessage::~EndKickPetitionMessage() { + // @@protoc_insertion_point(destructor:EndKickPetitionMessage) SharedDtor(); } @@ -17738,32 +20078,50 @@ EndKickPetitionMessage* EndKickPetitionMessage::New() const { } void EndKickPetitionMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - petitionid_ = 0u; - numvotesagainstkicking_ = 0u; - numvotesinfavourofkicking_ = 0u; - resultplayerkicked_ = 0u; - petitionendreason_ = 0; +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 31) { + ZR_(petitionid_, petitionendreason_); } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool EndKickPetitionMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:EndKickPetitionMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 petitionId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &petitionid_))); set_has_petitionid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_numVotesAgainstKicking; break; @@ -17771,15 +20129,14 @@ bool EndKickPetitionMessage::MergePartialFromCodedStream( // required uint32 numVotesAgainstKicking = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_numVotesAgainstKicking: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &numvotesagainstkicking_))); set_has_numvotesagainstkicking(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(24)) goto parse_numVotesInFavourOfKicking; break; @@ -17787,15 +20144,14 @@ bool EndKickPetitionMessage::MergePartialFromCodedStream( // required uint32 numVotesInFavourOfKicking = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 24) { parse_numVotesInFavourOfKicking: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &numvotesinfavourofkicking_))); set_has_numvotesinfavourofkicking(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(32)) goto parse_resultPlayerKicked; break; @@ -17803,15 +20159,14 @@ bool EndKickPetitionMessage::MergePartialFromCodedStream( // required uint32 resultPlayerKicked = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 32) { parse_resultPlayerKicked: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &resultplayerkicked_))); set_has_resultplayerkicked(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(40)) goto parse_petitionEndReason; break; @@ -17819,8 +20174,7 @@ bool EndKickPetitionMessage::MergePartialFromCodedStream( // required .EndKickPetitionMessage.PetitionEndReason petitionEndReason = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 40) { parse_petitionEndReason: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -17828,31 +20182,42 @@ bool EndKickPetitionMessage::MergePartialFromCodedStream( input, &value))); if (::EndKickPetitionMessage_PetitionEndReason_IsValid(value)) { set_petitionendreason(static_cast< ::EndKickPetitionMessage_PetitionEndReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:EndKickPetitionMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:EndKickPetitionMessage) + return false; #undef DO_ } void EndKickPetitionMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:EndKickPetitionMessage) // required uint32 petitionId = 1; if (has_petitionid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->petitionid(), output); @@ -17879,6 +20244,9 @@ void EndKickPetitionMessage::SerializeWithCachedSizes( 5, this->petitionendreason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:EndKickPetitionMessage) } int EndKickPetitionMessage::ByteSize() const { @@ -17920,6 +20288,8 @@ int EndKickPetitionMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -17950,6 +20320,7 @@ void EndKickPetitionMessage::MergeFrom(const EndKickPetitionMessage& from) { set_petitionendreason(from.petitionendreason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void EndKickPetitionMessage::CopyFrom(const EndKickPetitionMessage& from) { @@ -17972,6 +20343,7 @@ void EndKickPetitionMessage::Swap(EndKickPetitionMessage* other) { std::swap(resultplayerkicked_, other->resultplayerkicked_); std::swap(petitionendreason_, other->petitionendreason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -18006,6 +20378,7 @@ const int StatisticsMessage_StatisticsData::kStatisticsValueFieldNumber; StatisticsMessage_StatisticsData::StatisticsMessage_StatisticsData() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:StatisticsMessage.StatisticsData) } void StatisticsMessage_StatisticsData::InitAsDefaultInstance() { @@ -18015,6 +20388,7 @@ StatisticsMessage_StatisticsData::StatisticsMessage_StatisticsData(const Statist : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:StatisticsMessage.StatisticsData) } void StatisticsMessage_StatisticsData::SharedCtor() { @@ -18025,6 +20399,7 @@ void StatisticsMessage_StatisticsData::SharedCtor() { } StatisticsMessage_StatisticsData::~StatisticsMessage_StatisticsData() { + // @@protoc_insertion_point(destructor:StatisticsMessage.StatisticsData) SharedDtor(); } @@ -18058,32 +20433,43 @@ StatisticsMessage_StatisticsData* StatisticsMessage_StatisticsData::New() const } void StatisticsMessage_StatisticsData::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { statisticstype_ = 1; statisticsvalue_ = 0u; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool StatisticsMessage_StatisticsData::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:StatisticsMessage.StatisticsData) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .StatisticsMessage.StatisticsData.StatisticsType statisticsType = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::StatisticsMessage_StatisticsData_StatisticsType_IsValid(value)) { set_statisticstype(static_cast< ::StatisticsMessage_StatisticsData_StatisticsType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_statisticsValue; break; @@ -18091,37 +20477,44 @@ bool StatisticsMessage_StatisticsData::MergePartialFromCodedStream( // required uint32 statisticsValue = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_statisticsValue: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &statisticsvalue_))); set_has_statisticsvalue(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:StatisticsMessage.StatisticsData) return true; +failure: + // @@protoc_insertion_point(parse_failure:StatisticsMessage.StatisticsData) + return false; #undef DO_ } void StatisticsMessage_StatisticsData::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:StatisticsMessage.StatisticsData) // required .StatisticsMessage.StatisticsData.StatisticsType statisticsType = 1; if (has_statisticstype()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -18133,6 +20526,9 @@ void StatisticsMessage_StatisticsData::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->statisticsvalue(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:StatisticsMessage.StatisticsData) } int StatisticsMessage_StatisticsData::ByteSize() const { @@ -18153,6 +20549,8 @@ int StatisticsMessage_StatisticsData::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -18174,6 +20572,7 @@ void StatisticsMessage_StatisticsData::MergeFrom(const StatisticsMessage_Statist set_statisticsvalue(from.statisticsvalue()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void StatisticsMessage_StatisticsData::CopyFrom(const StatisticsMessage_StatisticsData& from) { @@ -18193,6 +20592,7 @@ void StatisticsMessage_StatisticsData::Swap(StatisticsMessage_StatisticsData* ot std::swap(statisticstype_, other->statisticstype_); std::swap(statisticsvalue_, other->statisticsvalue_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -18211,6 +20611,7 @@ const int StatisticsMessage::kStatisticsDataFieldNumber; StatisticsMessage::StatisticsMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:StatisticsMessage) } void StatisticsMessage::InitAsDefaultInstance() { @@ -18220,6 +20621,7 @@ StatisticsMessage::StatisticsMessage(const StatisticsMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:StatisticsMessage) } void StatisticsMessage::SharedCtor() { @@ -18228,6 +20630,7 @@ void StatisticsMessage::SharedCtor() { } StatisticsMessage::~StatisticsMessage() { + // @@protoc_insertion_point(destructor:StatisticsMessage) SharedDtor(); } @@ -18263,52 +20666,71 @@ StatisticsMessage* StatisticsMessage::New() const { void StatisticsMessage::Clear() { statisticsdata_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool StatisticsMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:StatisticsMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // repeated .StatisticsMessage.StatisticsData statisticsData = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { parse_statisticsData: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, add_statisticsdata())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(10)) goto parse_statisticsData; - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:StatisticsMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:StatisticsMessage) + return false; #undef DO_ } void StatisticsMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:StatisticsMessage) // repeated .StatisticsMessage.StatisticsData statisticsData = 1; for (int i = 0; i < this->statisticsdata_size(); i++) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 1, this->statisticsdata(i), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:StatisticsMessage) } int StatisticsMessage::ByteSize() const { @@ -18322,6 +20744,8 @@ int StatisticsMessage::ByteSize() const { this->statisticsdata(i)); } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -18336,6 +20760,7 @@ void StatisticsMessage::CheckTypeAndMergeFrom( void StatisticsMessage::MergeFrom(const StatisticsMessage& from) { GOOGLE_CHECK_NE(&from, this); statisticsdata_.MergeFrom(from.statisticsdata_); + mutable_unknown_fields()->append(from.unknown_fields()); } void StatisticsMessage::CopyFrom(const StatisticsMessage& from) { @@ -18346,9 +20771,7 @@ void StatisticsMessage::CopyFrom(const StatisticsMessage& from) { bool StatisticsMessage::IsInitialized() const { - for (int i = 0; i < statisticsdata_size(); i++) { - if (!this->statisticsdata(i).IsInitialized()) return false; - } + if (!::google::protobuf::internal::AllAreInitialized(this->statisticsdata())) return false; return true; } @@ -18356,6 +20779,7 @@ void StatisticsMessage::Swap(StatisticsMessage* other) { if (other != this) { statisticsdata_.Swap(&other->statisticsdata_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -18375,6 +20799,7 @@ const int ChatRequestMessage::kChatTextFieldNumber; ChatRequestMessage::ChatRequestMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ChatRequestMessage) } void ChatRequestMessage::InitAsDefaultInstance() { @@ -18384,21 +20809,24 @@ ChatRequestMessage::ChatRequestMessage(const ChatRequestMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ChatRequestMessage) } void ChatRequestMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; targetplayerid_ = 0u; - chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } ChatRequestMessage::~ChatRequestMessage() { + // @@protoc_insertion_point(destructor:ChatRequestMessage) SharedDtor(); } void ChatRequestMessage::SharedDtor() { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete chattext_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -18430,33 +20858,41 @@ ChatRequestMessage* ChatRequestMessage::New() const { } void ChatRequestMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { targetplayerid_ = 0u; if (has_chattext()) { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_->clear(); } } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ChatRequestMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ChatRequestMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // optional uint32 targetPlayerId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &targetplayerid_))); set_has_targetplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_chatText; break; @@ -18464,35 +20900,42 @@ bool ChatRequestMessage::MergePartialFromCodedStream( // required string chatText = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_chatText: DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_chattext())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:ChatRequestMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ChatRequestMessage) + return false; #undef DO_ } void ChatRequestMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ChatRequestMessage) // optional uint32 targetPlayerId = 2; if (has_targetplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->targetplayerid(), output); @@ -18500,10 +20943,13 @@ void ChatRequestMessage::SerializeWithCachedSizes( // required string chatText = 3; if (has_chattext()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 3, this->chattext(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ChatRequestMessage) } int ChatRequestMessage::ByteSize() const { @@ -18525,6 +20971,8 @@ int ChatRequestMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -18546,6 +20994,7 @@ void ChatRequestMessage::MergeFrom(const ChatRequestMessage& from) { set_chattext(from.chattext()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void ChatRequestMessage::CopyFrom(const ChatRequestMessage& from) { @@ -18565,6 +21014,7 @@ void ChatRequestMessage::Swap(ChatRequestMessage* other) { std::swap(targetplayerid_, other->targetplayerid_); std::swap(chattext_, other->chattext_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -18606,6 +21056,7 @@ const int ChatMessage::kChatTextFieldNumber; ChatMessage::ChatMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ChatMessage) } void ChatMessage::InitAsDefaultInstance() { @@ -18615,22 +21066,25 @@ ChatMessage::ChatMessage(const ChatMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ChatMessage) } void ChatMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; playerid_ = 0u; chattype_ = 0; - chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } ChatMessage::~ChatMessage() { + // @@protoc_insertion_point(destructor:ChatMessage) SharedDtor(); } void ChatMessage::SharedDtor() { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete chattext_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -18662,34 +21116,55 @@ ChatMessage* ChatMessage::New() const { } void ChatMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - playerid_ = 0u; - chattype_ = 0; +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 7) { + ZR_(playerid_, chattype_); if (has_chattext()) { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_->clear(); } } } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ChatMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ChatMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // optional uint32 playerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &playerid_))); set_has_playerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_chatType; break; @@ -18697,8 +21172,7 @@ bool ChatMessage::MergePartialFromCodedStream( // required .ChatMessage.ChatType chatType = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_chatType: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -18706,9 +21180,12 @@ bool ChatMessage::MergePartialFromCodedStream( input, &value))); if (::ChatMessage_ChatType_IsValid(value)) { set_chattype(static_cast< ::ChatMessage_ChatType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_chatText; break; @@ -18716,35 +21193,42 @@ bool ChatMessage::MergePartialFromCodedStream( // required string chatText = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_chatText: DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_chattext())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:ChatMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ChatMessage) + return false; #undef DO_ } void ChatMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ChatMessage) // optional uint32 playerId = 1; if (has_playerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); @@ -18758,10 +21242,13 @@ void ChatMessage::SerializeWithCachedSizes( // required string chatText = 3; if (has_chattext()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 3, this->chattext(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ChatMessage) } int ChatMessage::ByteSize() const { @@ -18789,6 +21276,8 @@ int ChatMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -18813,6 +21302,7 @@ void ChatMessage::MergeFrom(const ChatMessage& from) { set_chattext(from.chattext()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void ChatMessage::CopyFrom(const ChatMessage& from) { @@ -18833,6 +21323,7 @@ void ChatMessage::Swap(ChatMessage* other) { std::swap(chattype_, other->chattype_); std::swap(chattext_, other->chattext_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -18851,6 +21342,7 @@ const int ChatRejectMessage::kChatTextFieldNumber; ChatRejectMessage::ChatRejectMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ChatRejectMessage) } void ChatRejectMessage::InitAsDefaultInstance() { @@ -18860,20 +21352,23 @@ ChatRejectMessage::ChatRejectMessage(const ChatRejectMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ChatRejectMessage) } void ChatRejectMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; - chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } ChatRejectMessage::~ChatRejectMessage() { + // @@protoc_insertion_point(destructor:ChatRejectMessage) SharedDtor(); } void ChatRejectMessage::SharedDtor() { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete chattext_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -18905,58 +21400,75 @@ ChatRejectMessage* ChatRejectMessage::New() const { } void ChatRejectMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - if (has_chattext()) { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { - chattext_->clear(); - } + if (has_chattext()) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + chattext_->clear(); } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ChatRejectMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ChatRejectMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required string chatText = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_chattext())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:ChatRejectMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ChatRejectMessage) + return false; #undef DO_ } void ChatRejectMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ChatRejectMessage) // required string chatText = 1; if (has_chattext()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 1, this->chattext(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ChatRejectMessage) } int ChatRejectMessage::ByteSize() const { @@ -18971,6 +21483,8 @@ int ChatRejectMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -18989,6 +21503,7 @@ void ChatRejectMessage::MergeFrom(const ChatRejectMessage& from) { set_chattext(from.chattext()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void ChatRejectMessage::CopyFrom(const ChatRejectMessage& from) { @@ -19007,6 +21522,7 @@ void ChatRejectMessage::Swap(ChatRejectMessage* other) { if (other != this) { std::swap(chattext_, other->chattext_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -19025,6 +21541,7 @@ const int DialogMessage::kNotificationTextFieldNumber; DialogMessage::DialogMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:DialogMessage) } void DialogMessage::InitAsDefaultInstance() { @@ -19034,20 +21551,23 @@ DialogMessage::DialogMessage(const DialogMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:DialogMessage) } void DialogMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; - notificationtext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + notificationtext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } DialogMessage::~DialogMessage() { + // @@protoc_insertion_point(destructor:DialogMessage) SharedDtor(); } void DialogMessage::SharedDtor() { - if (notificationtext_ != &::google::protobuf::internal::kEmptyString) { + if (notificationtext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete notificationtext_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -19079,58 +21599,75 @@ DialogMessage* DialogMessage::New() const { } void DialogMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - if (has_notificationtext()) { - if (notificationtext_ != &::google::protobuf::internal::kEmptyString) { - notificationtext_->clear(); - } + if (has_notificationtext()) { + if (notificationtext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + notificationtext_->clear(); } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool DialogMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:DialogMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required string notificationText = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 10) { DO_(::google::protobuf::internal::WireFormatLite::ReadString( input, this->mutable_notificationtext())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:DialogMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:DialogMessage) + return false; #undef DO_ } void DialogMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:DialogMessage) // required string notificationText = 1; if (has_notificationtext()) { - ::google::protobuf::internal::WireFormatLite::WriteString( + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( 1, this->notificationtext(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:DialogMessage) } int DialogMessage::ByteSize() const { @@ -19145,6 +21682,8 @@ int DialogMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -19163,6 +21702,7 @@ void DialogMessage::MergeFrom(const DialogMessage& from) { set_notificationtext(from.notificationtext()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void DialogMessage::CopyFrom(const DialogMessage& from) { @@ -19181,6 +21721,7 @@ void DialogMessage::Swap(DialogMessage* other) { if (other != this) { std::swap(notificationtext_, other->notificationtext_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -19219,6 +21760,7 @@ const int TimeoutWarningMessage::kRemainingSecondsFieldNumber; TimeoutWarningMessage::TimeoutWarningMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:TimeoutWarningMessage) } void TimeoutWarningMessage::InitAsDefaultInstance() { @@ -19228,6 +21770,7 @@ TimeoutWarningMessage::TimeoutWarningMessage(const TimeoutWarningMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:TimeoutWarningMessage) } void TimeoutWarningMessage::SharedCtor() { @@ -19238,6 +21781,7 @@ void TimeoutWarningMessage::SharedCtor() { } TimeoutWarningMessage::~TimeoutWarningMessage() { + // @@protoc_insertion_point(destructor:TimeoutWarningMessage) SharedDtor(); } @@ -19271,32 +21815,54 @@ TimeoutWarningMessage* TimeoutWarningMessage::New() const { } void TimeoutWarningMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - timeoutreason_ = 0; - remainingseconds_ = 0u; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(timeoutreason_, remainingseconds_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool TimeoutWarningMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:TimeoutWarningMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .TimeoutWarningMessage.TimeoutReason timeoutReason = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::TimeoutWarningMessage_TimeoutReason_IsValid(value)) { set_timeoutreason(static_cast< ::TimeoutWarningMessage_TimeoutReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_remainingSeconds; break; @@ -19304,37 +21870,44 @@ bool TimeoutWarningMessage::MergePartialFromCodedStream( // required uint32 remainingSeconds = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_remainingSeconds: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &remainingseconds_))); set_has_remainingseconds(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:TimeoutWarningMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:TimeoutWarningMessage) + return false; #undef DO_ } void TimeoutWarningMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:TimeoutWarningMessage) // required .TimeoutWarningMessage.TimeoutReason timeoutReason = 1; if (has_timeoutreason()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -19346,6 +21919,9 @@ void TimeoutWarningMessage::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->remainingseconds(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:TimeoutWarningMessage) } int TimeoutWarningMessage::ByteSize() const { @@ -19366,6 +21942,8 @@ int TimeoutWarningMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -19387,6 +21965,7 @@ void TimeoutWarningMessage::MergeFrom(const TimeoutWarningMessage& from) { set_remainingseconds(from.remainingseconds()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void TimeoutWarningMessage::CopyFrom(const TimeoutWarningMessage& from) { @@ -19406,6 +21985,7 @@ void TimeoutWarningMessage::Swap(TimeoutWarningMessage* other) { std::swap(timeoutreason_, other->timeoutreason_); std::swap(remainingseconds_, other->remainingseconds_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -19423,6 +22003,7 @@ void TimeoutWarningMessage::Swap(TimeoutWarningMessage* other) { ResetTimeoutMessage::ResetTimeoutMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ResetTimeoutMessage) } void ResetTimeoutMessage::InitAsDefaultInstance() { @@ -19432,6 +22013,7 @@ ResetTimeoutMessage::ResetTimeoutMessage(const ResetTimeoutMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ResetTimeoutMessage) } void ResetTimeoutMessage::SharedCtor() { @@ -19440,6 +22022,7 @@ void ResetTimeoutMessage::SharedCtor() { } ResetTimeoutMessage::~ResetTimeoutMessage() { + // @@protoc_insertion_point(destructor:ResetTimeoutMessage) SharedDtor(); } @@ -19474,30 +22057,53 @@ ResetTimeoutMessage* ResetTimeoutMessage::New() const { void ResetTimeoutMessage::Clear() { ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ResetTimeoutMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ResetTimeoutMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); } +success: + // @@protoc_insertion_point(parse_success:ResetTimeoutMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ResetTimeoutMessage) + return false; #undef DO_ } void ResetTimeoutMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ResetTimeoutMessage) + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ResetTimeoutMessage) } int ResetTimeoutMessage::ByteSize() const { int total_size = 0; + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -19511,6 +22117,7 @@ void ResetTimeoutMessage::CheckTypeAndMergeFrom( void ResetTimeoutMessage::MergeFrom(const ResetTimeoutMessage& from) { GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->append(from.unknown_fields()); } void ResetTimeoutMessage::CopyFrom(const ResetTimeoutMessage& from) { @@ -19526,6 +22133,7 @@ bool ResetTimeoutMessage::IsInitialized() const { void ResetTimeoutMessage::Swap(ResetTimeoutMessage* other) { if (other != this) { + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -19545,6 +22153,7 @@ const int ReportAvatarMessage::kReportedAvatarHashFieldNumber; ReportAvatarMessage::ReportAvatarMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ReportAvatarMessage) } void ReportAvatarMessage::InitAsDefaultInstance() { @@ -19554,21 +22163,24 @@ ReportAvatarMessage::ReportAvatarMessage(const ReportAvatarMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ReportAvatarMessage) } void ReportAvatarMessage::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); _cached_size_ = 0; reportedplayerid_ = 0u; - reportedavatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + reportedavatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); ::memset(_has_bits_, 0, sizeof(_has_bits_)); } ReportAvatarMessage::~ReportAvatarMessage() { + // @@protoc_insertion_point(destructor:ReportAvatarMessage) SharedDtor(); } void ReportAvatarMessage::SharedDtor() { - if (reportedavatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (reportedavatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete reportedavatarhash_; } #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -19600,33 +22212,41 @@ ReportAvatarMessage* ReportAvatarMessage::New() const { } void ReportAvatarMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 3) { reportedplayerid_ = 0u; if (has_reportedavatarhash()) { - if (reportedavatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (reportedavatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { reportedavatarhash_->clear(); } } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ReportAvatarMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ReportAvatarMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 reportedPlayerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &reportedplayerid_))); set_has_reportedplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_reportedAvatarHash; break; @@ -19634,35 +22254,42 @@ bool ReportAvatarMessage::MergePartialFromCodedStream( // required bytes reportedAvatarHash = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_reportedAvatarHash: DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( input, this->mutable_reportedavatarhash())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:ReportAvatarMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ReportAvatarMessage) + return false; #undef DO_ } void ReportAvatarMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ReportAvatarMessage) // required uint32 reportedPlayerId = 1; if (has_reportedplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->reportedplayerid(), output); @@ -19670,10 +22297,13 @@ void ReportAvatarMessage::SerializeWithCachedSizes( // required bytes reportedAvatarHash = 2; if (has_reportedavatarhash()) { - ::google::protobuf::internal::WireFormatLite::WriteBytes( + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( 2, this->reportedavatarhash(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ReportAvatarMessage) } int ReportAvatarMessage::ByteSize() const { @@ -19695,6 +22325,8 @@ int ReportAvatarMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -19716,6 +22348,7 @@ void ReportAvatarMessage::MergeFrom(const ReportAvatarMessage& from) { set_reportedavatarhash(from.reportedavatarhash()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void ReportAvatarMessage::CopyFrom(const ReportAvatarMessage& from) { @@ -19735,6 +22368,7 @@ void ReportAvatarMessage::Swap(ReportAvatarMessage* other) { std::swap(reportedplayerid_, other->reportedplayerid_); std::swap(reportedavatarhash_, other->reportedavatarhash_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -19773,6 +22407,7 @@ const int ReportAvatarAckMessage::kReportAvatarResultFieldNumber; ReportAvatarAckMessage::ReportAvatarAckMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ReportAvatarAckMessage) } void ReportAvatarAckMessage::InitAsDefaultInstance() { @@ -19782,6 +22417,7 @@ ReportAvatarAckMessage::ReportAvatarAckMessage(const ReportAvatarAckMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ReportAvatarAckMessage) } void ReportAvatarAckMessage::SharedCtor() { @@ -19792,6 +22428,7 @@ void ReportAvatarAckMessage::SharedCtor() { } ReportAvatarAckMessage::~ReportAvatarAckMessage() { + // @@protoc_insertion_point(destructor:ReportAvatarAckMessage) SharedDtor(); } @@ -19825,29 +22462,48 @@ ReportAvatarAckMessage* ReportAvatarAckMessage::New() const { } void ReportAvatarAckMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - reportedplayerid_ = 0u; - reportavatarresult_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(reportedplayerid_, reportavatarresult_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ReportAvatarAckMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ReportAvatarAckMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 reportedPlayerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &reportedplayerid_))); set_has_reportedplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_reportAvatarResult; break; @@ -19855,8 +22511,7 @@ bool ReportAvatarAckMessage::MergePartialFromCodedStream( // required .ReportAvatarAckMessage.ReportAvatarResult reportAvatarResult = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_reportAvatarResult: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -19864,31 +22519,42 @@ bool ReportAvatarAckMessage::MergePartialFromCodedStream( input, &value))); if (::ReportAvatarAckMessage_ReportAvatarResult_IsValid(value)) { set_reportavatarresult(static_cast< ::ReportAvatarAckMessage_ReportAvatarResult >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:ReportAvatarAckMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ReportAvatarAckMessage) + return false; #undef DO_ } void ReportAvatarAckMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ReportAvatarAckMessage) // required uint32 reportedPlayerId = 1; if (has_reportedplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->reportedplayerid(), output); @@ -19900,6 +22566,9 @@ void ReportAvatarAckMessage::SerializeWithCachedSizes( 2, this->reportavatarresult(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ReportAvatarAckMessage) } int ReportAvatarAckMessage::ByteSize() const { @@ -19920,6 +22589,8 @@ int ReportAvatarAckMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -19941,6 +22612,7 @@ void ReportAvatarAckMessage::MergeFrom(const ReportAvatarAckMessage& from) { set_reportavatarresult(from.reportavatarresult()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void ReportAvatarAckMessage::CopyFrom(const ReportAvatarAckMessage& from) { @@ -19960,6 +22632,7 @@ void ReportAvatarAckMessage::Swap(ReportAvatarAckMessage* other) { std::swap(reportedplayerid_, other->reportedplayerid_); std::swap(reportavatarresult_, other->reportavatarresult_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -19978,6 +22651,7 @@ const int ReportGameMessage::kReportedGameIdFieldNumber; ReportGameMessage::ReportGameMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ReportGameMessage) } void ReportGameMessage::InitAsDefaultInstance() { @@ -19987,6 +22661,7 @@ ReportGameMessage::ReportGameMessage(const ReportGameMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ReportGameMessage) } void ReportGameMessage::SharedCtor() { @@ -19996,6 +22671,7 @@ void ReportGameMessage::SharedCtor() { } ReportGameMessage::~ReportGameMessage() { + // @@protoc_insertion_point(destructor:ReportGameMessage) SharedDtor(); } @@ -20029,55 +22705,72 @@ ReportGameMessage* ReportGameMessage::New() const { } void ReportGameMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - reportedgameid_ = 0u; - } + reportedgameid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ReportGameMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ReportGameMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 reportedGameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &reportedgameid_))); set_has_reportedgameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:ReportGameMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ReportGameMessage) + return false; #undef DO_ } void ReportGameMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ReportGameMessage) // required uint32 reportedGameId = 1; if (has_reportedgameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->reportedgameid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ReportGameMessage) } int ReportGameMessage::ByteSize() const { @@ -20092,6 +22785,8 @@ int ReportGameMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -20110,6 +22805,7 @@ void ReportGameMessage::MergeFrom(const ReportGameMessage& from) { set_reportedgameid(from.reportedgameid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void ReportGameMessage::CopyFrom(const ReportGameMessage& from) { @@ -20128,6 +22824,7 @@ void ReportGameMessage::Swap(ReportGameMessage* other) { if (other != this) { std::swap(reportedgameid_, other->reportedgameid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -20166,6 +22863,7 @@ const int ReportGameAckMessage::kReportGameResultFieldNumber; ReportGameAckMessage::ReportGameAckMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ReportGameAckMessage) } void ReportGameAckMessage::InitAsDefaultInstance() { @@ -20175,6 +22873,7 @@ ReportGameAckMessage::ReportGameAckMessage(const ReportGameAckMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ReportGameAckMessage) } void ReportGameAckMessage::SharedCtor() { @@ -20185,6 +22884,7 @@ void ReportGameAckMessage::SharedCtor() { } ReportGameAckMessage::~ReportGameAckMessage() { + // @@protoc_insertion_point(destructor:ReportGameAckMessage) SharedDtor(); } @@ -20218,29 +22918,48 @@ ReportGameAckMessage* ReportGameAckMessage::New() const { } void ReportGameAckMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - reportedgameid_ = 0u; - reportgameresult_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(reportedgameid_, reportgameresult_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ReportGameAckMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ReportGameAckMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 reportedGameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &reportedgameid_))); set_has_reportedgameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_reportGameResult; break; @@ -20248,8 +22967,7 @@ bool ReportGameAckMessage::MergePartialFromCodedStream( // required .ReportGameAckMessage.ReportGameResult reportGameResult = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_reportGameResult: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -20257,31 +22975,42 @@ bool ReportGameAckMessage::MergePartialFromCodedStream( input, &value))); if (::ReportGameAckMessage_ReportGameResult_IsValid(value)) { set_reportgameresult(static_cast< ::ReportGameAckMessage_ReportGameResult >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:ReportGameAckMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ReportGameAckMessage) + return false; #undef DO_ } void ReportGameAckMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ReportGameAckMessage) // required uint32 reportedGameId = 1; if (has_reportedgameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->reportedgameid(), output); @@ -20293,6 +23022,9 @@ void ReportGameAckMessage::SerializeWithCachedSizes( 2, this->reportgameresult(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ReportGameAckMessage) } int ReportGameAckMessage::ByteSize() const { @@ -20313,6 +23045,8 @@ int ReportGameAckMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -20334,6 +23068,7 @@ void ReportGameAckMessage::MergeFrom(const ReportGameAckMessage& from) { set_reportgameresult(from.reportgameresult()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void ReportGameAckMessage::CopyFrom(const ReportGameAckMessage& from) { @@ -20353,6 +23088,7 @@ void ReportGameAckMessage::Swap(ReportGameAckMessage* other) { std::swap(reportedgameid_, other->reportedgameid_); std::swap(reportgameresult_, other->reportgameresult_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -20414,6 +23150,7 @@ const int ErrorMessage::kErrorReasonFieldNumber; ErrorMessage::ErrorMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:ErrorMessage) } void ErrorMessage::InitAsDefaultInstance() { @@ -20423,6 +23160,7 @@ ErrorMessage::ErrorMessage(const ErrorMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ErrorMessage) } void ErrorMessage::SharedCtor() { @@ -20432,6 +23170,7 @@ void ErrorMessage::SharedCtor() { } ErrorMessage::~ErrorMessage() { + // @@protoc_insertion_point(destructor:ErrorMessage) SharedDtor(); } @@ -20465,59 +23204,79 @@ ErrorMessage* ErrorMessage::New() const { } void ErrorMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - errorreason_ = 0; - } + errorreason_ = 0; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool ErrorMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ErrorMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .ErrorMessage.ErrorReason errorReason = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::ErrorMessage_ErrorReason_IsValid(value)) { set_errorreason(static_cast< ::ErrorMessage_ErrorReason >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:ErrorMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:ErrorMessage) + return false; #undef DO_ } void ErrorMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ErrorMessage) // required .ErrorMessage.ErrorReason errorReason = 1; if (has_errorreason()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( 1, this->errorreason(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ErrorMessage) } int ErrorMessage::ByteSize() const { @@ -20531,6 +23290,8 @@ int ErrorMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -20549,6 +23310,7 @@ void ErrorMessage::MergeFrom(const ErrorMessage& from) { set_errorreason(from.errorreason()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void ErrorMessage::CopyFrom(const ErrorMessage& from) { @@ -20567,6 +23329,7 @@ void ErrorMessage::Swap(ErrorMessage* other) { if (other != this) { std::swap(errorreason_, other->errorreason_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -20585,6 +23348,7 @@ const int AdminRemoveGameMessage::kRemoveGameIdFieldNumber; AdminRemoveGameMessage::AdminRemoveGameMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AdminRemoveGameMessage) } void AdminRemoveGameMessage::InitAsDefaultInstance() { @@ -20594,6 +23358,7 @@ AdminRemoveGameMessage::AdminRemoveGameMessage(const AdminRemoveGameMessage& fro : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AdminRemoveGameMessage) } void AdminRemoveGameMessage::SharedCtor() { @@ -20603,6 +23368,7 @@ void AdminRemoveGameMessage::SharedCtor() { } AdminRemoveGameMessage::~AdminRemoveGameMessage() { + // @@protoc_insertion_point(destructor:AdminRemoveGameMessage) SharedDtor(); } @@ -20636,55 +23402,72 @@ AdminRemoveGameMessage* AdminRemoveGameMessage::New() const { } void AdminRemoveGameMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - removegameid_ = 0u; - } + removegameid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AdminRemoveGameMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AdminRemoveGameMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 removeGameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &removegameid_))); set_has_removegameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AdminRemoveGameMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AdminRemoveGameMessage) + return false; #undef DO_ } void AdminRemoveGameMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AdminRemoveGameMessage) // required uint32 removeGameId = 1; if (has_removegameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->removegameid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AdminRemoveGameMessage) } int AdminRemoveGameMessage::ByteSize() const { @@ -20699,6 +23482,8 @@ int AdminRemoveGameMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -20717,6 +23502,7 @@ void AdminRemoveGameMessage::MergeFrom(const AdminRemoveGameMessage& from) { set_removegameid(from.removegameid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AdminRemoveGameMessage::CopyFrom(const AdminRemoveGameMessage& from) { @@ -20735,6 +23521,7 @@ void AdminRemoveGameMessage::Swap(AdminRemoveGameMessage* other) { if (other != this) { std::swap(removegameid_, other->removegameid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -20771,6 +23558,7 @@ const int AdminRemoveGameAckMessage::kRemoveGameResultFieldNumber; AdminRemoveGameAckMessage::AdminRemoveGameAckMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AdminRemoveGameAckMessage) } void AdminRemoveGameAckMessage::InitAsDefaultInstance() { @@ -20780,6 +23568,7 @@ AdminRemoveGameAckMessage::AdminRemoveGameAckMessage(const AdminRemoveGameAckMes : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AdminRemoveGameAckMessage) } void AdminRemoveGameAckMessage::SharedCtor() { @@ -20790,6 +23579,7 @@ void AdminRemoveGameAckMessage::SharedCtor() { } AdminRemoveGameAckMessage::~AdminRemoveGameAckMessage() { + // @@protoc_insertion_point(destructor:AdminRemoveGameAckMessage) SharedDtor(); } @@ -20823,29 +23613,48 @@ AdminRemoveGameAckMessage* AdminRemoveGameAckMessage::New() const { } void AdminRemoveGameAckMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - removegameid_ = 0u; - removegameresult_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(removegameid_, removegameresult_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AdminRemoveGameAckMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AdminRemoveGameAckMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 removeGameId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &removegameid_))); set_has_removegameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_removeGameResult; break; @@ -20853,8 +23662,7 @@ bool AdminRemoveGameAckMessage::MergePartialFromCodedStream( // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_removeGameResult: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -20862,31 +23670,42 @@ bool AdminRemoveGameAckMessage::MergePartialFromCodedStream( input, &value))); if (::AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(value)) { set_removegameresult(static_cast< ::AdminRemoveGameAckMessage_AdminRemoveGameResult >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AdminRemoveGameAckMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AdminRemoveGameAckMessage) + return false; #undef DO_ } void AdminRemoveGameAckMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AdminRemoveGameAckMessage) // required uint32 removeGameId = 1; if (has_removegameid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->removegameid(), output); @@ -20898,6 +23717,9 @@ void AdminRemoveGameAckMessage::SerializeWithCachedSizes( 2, this->removegameresult(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AdminRemoveGameAckMessage) } int AdminRemoveGameAckMessage::ByteSize() const { @@ -20918,6 +23740,8 @@ int AdminRemoveGameAckMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -20939,6 +23763,7 @@ void AdminRemoveGameAckMessage::MergeFrom(const AdminRemoveGameAckMessage& from) set_removegameresult(from.removegameresult()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AdminRemoveGameAckMessage::CopyFrom(const AdminRemoveGameAckMessage& from) { @@ -20958,6 +23783,7 @@ void AdminRemoveGameAckMessage::Swap(AdminRemoveGameAckMessage* other) { std::swap(removegameid_, other->removegameid_); std::swap(removegameresult_, other->removegameresult_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -20976,6 +23802,7 @@ const int AdminBanPlayerMessage::kBanPlayerIdFieldNumber; AdminBanPlayerMessage::AdminBanPlayerMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AdminBanPlayerMessage) } void AdminBanPlayerMessage::InitAsDefaultInstance() { @@ -20985,6 +23812,7 @@ AdminBanPlayerMessage::AdminBanPlayerMessage(const AdminBanPlayerMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AdminBanPlayerMessage) } void AdminBanPlayerMessage::SharedCtor() { @@ -20994,6 +23822,7 @@ void AdminBanPlayerMessage::SharedCtor() { } AdminBanPlayerMessage::~AdminBanPlayerMessage() { + // @@protoc_insertion_point(destructor:AdminBanPlayerMessage) SharedDtor(); } @@ -21027,55 +23856,72 @@ AdminBanPlayerMessage* AdminBanPlayerMessage::New() const { } void AdminBanPlayerMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - banplayerid_ = 0u; - } + banplayerid_ = 0u; ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AdminBanPlayerMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AdminBanPlayerMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 banPlayerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &banplayerid_))); set_has_banplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AdminBanPlayerMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AdminBanPlayerMessage) + return false; #undef DO_ } void AdminBanPlayerMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AdminBanPlayerMessage) // required uint32 banPlayerId = 1; if (has_banplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->banplayerid(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AdminBanPlayerMessage) } int AdminBanPlayerMessage::ByteSize() const { @@ -21090,6 +23936,8 @@ int AdminBanPlayerMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -21108,6 +23956,7 @@ void AdminBanPlayerMessage::MergeFrom(const AdminBanPlayerMessage& from) { set_banplayerid(from.banplayerid()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AdminBanPlayerMessage::CopyFrom(const AdminBanPlayerMessage& from) { @@ -21126,6 +23975,7 @@ void AdminBanPlayerMessage::Swap(AdminBanPlayerMessage* other) { if (other != this) { std::swap(banplayerid_, other->banplayerid_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -21168,6 +24018,7 @@ const int AdminBanPlayerAckMessage::kBanPlayerResultFieldNumber; AdminBanPlayerAckMessage::AdminBanPlayerAckMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AdminBanPlayerAckMessage) } void AdminBanPlayerAckMessage::InitAsDefaultInstance() { @@ -21177,6 +24028,7 @@ AdminBanPlayerAckMessage::AdminBanPlayerAckMessage(const AdminBanPlayerAckMessag : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AdminBanPlayerAckMessage) } void AdminBanPlayerAckMessage::SharedCtor() { @@ -21187,6 +24039,7 @@ void AdminBanPlayerAckMessage::SharedCtor() { } AdminBanPlayerAckMessage::~AdminBanPlayerAckMessage() { + // @@protoc_insertion_point(destructor:AdminBanPlayerAckMessage) SharedDtor(); } @@ -21220,29 +24073,48 @@ AdminBanPlayerAckMessage* AdminBanPlayerAckMessage::New() const { } void AdminBanPlayerAckMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { - banplayerid_ = 0u; - banplayerresult_ = 0; - } +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(banplayerid_, banplayerresult_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AdminBanPlayerAckMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AdminBanPlayerAckMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required uint32 banPlayerId = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &banplayerid_))); set_has_banplayerid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_banPlayerResult; break; @@ -21250,8 +24122,7 @@ bool AdminBanPlayerAckMessage::MergePartialFromCodedStream( // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_banPlayerResult: int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< @@ -21259,31 +24130,42 @@ bool AdminBanPlayerAckMessage::MergePartialFromCodedStream( input, &value))); if (::AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(value)) { set_banplayerresult(static_cast< ::AdminBanPlayerAckMessage_AdminBanPlayerResult >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AdminBanPlayerAckMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AdminBanPlayerAckMessage) + return false; #undef DO_ } void AdminBanPlayerAckMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AdminBanPlayerAckMessage) // required uint32 banPlayerId = 1; if (has_banplayerid()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->banplayerid(), output); @@ -21295,6 +24177,9 @@ void AdminBanPlayerAckMessage::SerializeWithCachedSizes( 2, this->banplayerresult(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AdminBanPlayerAckMessage) } int AdminBanPlayerAckMessage::ByteSize() const { @@ -21315,6 +24200,8 @@ int AdminBanPlayerAckMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -21336,6 +24223,7 @@ void AdminBanPlayerAckMessage::MergeFrom(const AdminBanPlayerAckMessage& from) { set_banplayerresult(from.banplayerresult()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AdminBanPlayerAckMessage::CopyFrom(const AdminBanPlayerAckMessage& from) { @@ -21355,6 +24243,7 @@ void AdminBanPlayerAckMessage::Swap(AdminBanPlayerAckMessage* other) { std::swap(banplayerid_, other->banplayerid_); std::swap(banplayerresult_, other->banplayerresult_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -21401,6 +24290,7 @@ const int AuthMessage::kErrorMessageFieldNumber; AuthMessage::AuthMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:AuthMessage) } void AuthMessage::InitAsDefaultInstance() { @@ -21440,6 +24330,7 @@ AuthMessage::AuthMessage(const AuthMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:AuthMessage) } void AuthMessage::SharedCtor() { @@ -21454,6 +24345,7 @@ void AuthMessage::SharedCtor() { } AuthMessage::~AuthMessage() { + // @@protoc_insertion_point(destructor:AuthMessage) SharedDtor(); } @@ -21492,7 +24384,7 @@ AuthMessage* AuthMessage::New() const { } void AuthMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 63) { messagetype_ = 1; if (has_authclientrequestmessage()) { if (authclientrequestmessage_ != NULL) authclientrequestmessage_->::AuthClientRequestMessage::Clear(); @@ -21511,27 +24403,38 @@ void AuthMessage::Clear() { } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool AuthMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:AuthMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .AuthMessage.AuthMessageType messageType = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::AuthMessage_AuthMessageType_IsValid(value)) { set_messagetype(static_cast< ::AuthMessage_AuthMessageType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_authClientRequestMessage; break; @@ -21539,13 +24442,12 @@ bool AuthMessage::MergePartialFromCodedStream( // optional .AuthClientRequestMessage authClientRequestMessage = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_authClientRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_authclientrequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_authServerChallengeMessage; break; @@ -21553,13 +24455,12 @@ bool AuthMessage::MergePartialFromCodedStream( // optional .AuthServerChallengeMessage authServerChallengeMessage = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_authServerChallengeMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_authserverchallengemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_authClientResponseMessage; break; @@ -21567,13 +24468,12 @@ bool AuthMessage::MergePartialFromCodedStream( // optional .AuthClientResponseMessage authClientResponseMessage = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_authClientResponseMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_authclientresponsemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(42)) goto parse_authServerVerificationMessage; break; @@ -21581,13 +24481,12 @@ bool AuthMessage::MergePartialFromCodedStream( // optional .AuthServerVerificationMessage authServerVerificationMessage = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 42) { parse_authServerVerificationMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_authserververificationmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(8202)) goto parse_errorMessage; break; @@ -21595,35 +24494,42 @@ bool AuthMessage::MergePartialFromCodedStream( // optional .ErrorMessage errorMessage = 1025; case 1025: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 8202) { parse_errorMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_errormessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:AuthMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:AuthMessage) + return false; #undef DO_ } void AuthMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:AuthMessage) // required .AuthMessage.AuthMessageType messageType = 1; if (has_messagetype()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -21660,6 +24566,9 @@ void AuthMessage::SerializeWithCachedSizes( 1025, this->errormessage(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:AuthMessage) } int AuthMessage::ByteSize() const { @@ -21708,6 +24617,8 @@ int AuthMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -21741,6 +24652,7 @@ void AuthMessage::MergeFrom(const AuthMessage& from) { mutable_errormessage()->::ErrorMessage::MergeFrom(from.errormessage()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void AuthMessage::CopyFrom(const AuthMessage& from) { @@ -21779,6 +24691,7 @@ void AuthMessage::Swap(AuthMessage* other) { std::swap(authserververificationmessage_, other->authserververificationmessage_); std::swap(errormessage_, other->errormessage_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -21939,6 +24852,7 @@ const int LobbyMessage::kErrorMessageFieldNumber; LobbyMessage::LobbyMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:LobbyMessage) } void LobbyMessage::InitAsDefaultInstance() { @@ -22206,6 +25120,7 @@ LobbyMessage::LobbyMessage(const LobbyMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:LobbyMessage) } void LobbyMessage::SharedCtor() { @@ -22258,6 +25173,7 @@ void LobbyMessage::SharedCtor() { } LobbyMessage::~LobbyMessage() { + // @@protoc_insertion_point(destructor:LobbyMessage) SharedDtor(); } @@ -22334,7 +25250,7 @@ LobbyMessage* LobbyMessage::New() const { } void LobbyMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 255) { messagetype_ = 1; if (has_initdonemessage()) { if (initdonemessage_ != NULL) initdonemessage_->::InitDoneMessage::Clear(); @@ -22358,7 +25274,7 @@ void LobbyMessage::Clear() { if (playerlistmessage_ != NULL) playerlistmessage_->::PlayerListMessage::Clear(); } } - if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (_has_bits_[8 / 32] & 65280) { if (has_gamelistnewmessage()) { if (gamelistnewmessage_ != NULL) gamelistnewmessage_->::GameListNewMessage::Clear(); } @@ -22384,7 +25300,7 @@ void LobbyMessage::Clear() { if (playerinforequestmessage_ != NULL) playerinforequestmessage_->::PlayerInfoRequestMessage::Clear(); } } - if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (_has_bits_[16 / 32] & 16711680) { if (has_playerinforeplymessage()) { if (playerinforeplymessage_ != NULL) playerinforeplymessage_->::PlayerInfoReplyMessage::Clear(); } @@ -22410,7 +25326,7 @@ void LobbyMessage::Clear() { if (joingameackmessage_ != NULL) joingameackmessage_->::JoinGameAckMessage::Clear(); } } - if (_has_bits_[24 / 32] & (0xffu << (24 % 32))) { + if (_has_bits_[24 / 32] & 4278190080) { if (has_joingamefailedmessage()) { if (joingamefailedmessage_ != NULL) joingamefailedmessage_->::JoinGameFailedMessage::Clear(); } @@ -22436,7 +25352,7 @@ void LobbyMessage::Clear() { if (chatrejectmessage_ != NULL) chatrejectmessage_->::ChatRejectMessage::Clear(); } } - if (_has_bits_[32 / 32] & (0xffu << (32 % 32))) { + if (_has_bits_[32 / 32] & 255) { if (has_dialogmessage()) { if (dialogmessage_ != NULL) dialogmessage_->::DialogMessage::Clear(); } @@ -22462,7 +25378,7 @@ void LobbyMessage::Clear() { if (adminremovegamemessage_ != NULL) adminremovegamemessage_->::AdminRemoveGameMessage::Clear(); } } - if (_has_bits_[40 / 32] & (0xffu << (40 % 32))) { + if (_has_bits_[40 / 32] & 3840) { if (has_adminremovegameackmessage()) { if (adminremovegameackmessage_ != NULL) adminremovegameackmessage_->::AdminRemoveGameAckMessage::Clear(); } @@ -22477,27 +25393,38 @@ void LobbyMessage::Clear() { } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool LobbyMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:LobbyMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .LobbyMessage.LobbyMessageType messageType = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::LobbyMessage_LobbyMessageType_IsValid(value)) { set_messagetype(static_cast< ::LobbyMessage_LobbyMessageType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_initDoneMessage; break; @@ -22505,13 +25432,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .InitDoneMessage initDoneMessage = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_initDoneMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_initdonemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_avatarRequestMessage; break; @@ -22519,13 +25445,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .AvatarRequestMessage avatarRequestMessage = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_avatarRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_avatarrequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_avatarHeaderMessage; break; @@ -22533,13 +25458,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .AvatarHeaderMessage avatarHeaderMessage = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_avatarHeaderMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_avatarheadermessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(42)) goto parse_avatarDataMessage; break; @@ -22547,13 +25471,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .AvatarDataMessage avatarDataMessage = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 42) { parse_avatarDataMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_avatardatamessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(50)) goto parse_avatarEndMessage; break; @@ -22561,13 +25484,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .AvatarEndMessage avatarEndMessage = 6; case 6: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 50) { parse_avatarEndMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_avatarendmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(58)) goto parse_unknownAvatarMessage; break; @@ -22575,13 +25497,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .UnknownAvatarMessage unknownAvatarMessage = 7; case 7: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 58) { parse_unknownAvatarMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_unknownavatarmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(66)) goto parse_playerListMessage; break; @@ -22589,13 +25510,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .PlayerListMessage playerListMessage = 8; case 8: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 66) { parse_playerListMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_playerlistmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(74)) goto parse_gameListNewMessage; break; @@ -22603,13 +25523,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .GameListNewMessage gameListNewMessage = 9; case 9: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 74) { parse_gameListNewMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamelistnewmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(82)) goto parse_gameListUpdateMessage; break; @@ -22617,13 +25536,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .GameListUpdateMessage gameListUpdateMessage = 10; case 10: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 82) { parse_gameListUpdateMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamelistupdatemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(90)) goto parse_gameListPlayerJoinedMessage; break; @@ -22631,13 +25549,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .GameListPlayerJoinedMessage gameListPlayerJoinedMessage = 11; case 11: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 90) { parse_gameListPlayerJoinedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamelistplayerjoinedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(98)) goto parse_gameListPlayerLeftMessage; break; @@ -22645,13 +25562,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .GameListPlayerLeftMessage gameListPlayerLeftMessage = 12; case 12: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 98) { parse_gameListPlayerLeftMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamelistplayerleftmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(106)) goto parse_gameListSpectatorJoinedMessage; break; @@ -22659,13 +25575,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .GameListSpectatorJoinedMessage gameListSpectatorJoinedMessage = 13; case 13: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 106) { parse_gameListSpectatorJoinedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamelistspectatorjoinedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(114)) goto parse_gameListSpectatorLeftMessage; break; @@ -22673,13 +25588,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .GameListSpectatorLeftMessage gameListSpectatorLeftMessage = 14; case 14: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 114) { parse_gameListSpectatorLeftMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamelistspectatorleftmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(122)) goto parse_gameListAdminChangedMessage; break; @@ -22687,13 +25601,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .GameListAdminChangedMessage gameListAdminChangedMessage = 15; case 15: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 122) { parse_gameListAdminChangedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamelistadminchangedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(130)) goto parse_playerInfoRequestMessage; break; @@ -22701,13 +25614,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .PlayerInfoRequestMessage playerInfoRequestMessage = 16; case 16: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 130) { parse_playerInfoRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_playerinforequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(138)) goto parse_playerInfoReplyMessage; break; @@ -22715,13 +25627,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .PlayerInfoReplyMessage playerInfoReplyMessage = 17; case 17: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 138) { parse_playerInfoReplyMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_playerinforeplymessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(146)) goto parse_subscriptionRequestMessage; break; @@ -22729,13 +25640,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .SubscriptionRequestMessage subscriptionRequestMessage = 18; case 18: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 146) { parse_subscriptionRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_subscriptionrequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(154)) goto parse_subscriptionReplyMessage; break; @@ -22743,13 +25653,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .SubscriptionReplyMessage subscriptionReplyMessage = 19; case 19: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 154) { parse_subscriptionReplyMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_subscriptionreplymessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(162)) goto parse_createGameMessage; break; @@ -22757,13 +25666,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .CreateGameMessage createGameMessage = 20; case 20: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 162) { parse_createGameMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_creategamemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(170)) goto parse_createGameFailedMessage; break; @@ -22771,13 +25679,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .CreateGameFailedMessage createGameFailedMessage = 21; case 21: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 170) { parse_createGameFailedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_creategamefailedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(178)) goto parse_joinGameMessage; break; @@ -22785,13 +25692,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .JoinGameMessage joinGameMessage = 22; case 22: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 178) { parse_joinGameMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_joingamemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(186)) goto parse_rejoinGameMessage; break; @@ -22799,13 +25705,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .RejoinGameMessage rejoinGameMessage = 23; case 23: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 186) { parse_rejoinGameMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_rejoingamemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(194)) goto parse_joinGameAckMessage; break; @@ -22813,13 +25718,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .JoinGameAckMessage joinGameAckMessage = 24; case 24: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 194) { parse_joinGameAckMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_joingameackmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(202)) goto parse_joinGameFailedMessage; break; @@ -22827,13 +25731,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .JoinGameFailedMessage joinGameFailedMessage = 25; case 25: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 202) { parse_joinGameFailedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_joingamefailedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(210)) goto parse_inviteNotifyMessage; break; @@ -22841,13 +25744,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .InviteNotifyMessage inviteNotifyMessage = 26; case 26: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 210) { parse_inviteNotifyMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_invitenotifymessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(218)) goto parse_rejectGameInvitationMessage; break; @@ -22855,13 +25757,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .RejectGameInvitationMessage rejectGameInvitationMessage = 27; case 27: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 218) { parse_rejectGameInvitationMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_rejectgameinvitationmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(226)) goto parse_rejectInvNotifyMessage; break; @@ -22869,13 +25770,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .RejectInvNotifyMessage rejectInvNotifyMessage = 28; case 28: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 226) { parse_rejectInvNotifyMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_rejectinvnotifymessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(234)) goto parse_statisticsMessage; break; @@ -22883,13 +25783,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .StatisticsMessage statisticsMessage = 29; case 29: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 234) { parse_statisticsMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_statisticsmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(242)) goto parse_chatRequestMessage; break; @@ -22897,13 +25796,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .ChatRequestMessage chatRequestMessage = 30; case 30: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 242) { parse_chatRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_chatrequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(250)) goto parse_chatMessage; break; @@ -22911,13 +25809,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .ChatMessage chatMessage = 31; case 31: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 250) { parse_chatMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_chatmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(258)) goto parse_chatRejectMessage; break; @@ -22925,13 +25822,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .ChatRejectMessage chatRejectMessage = 32; case 32: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 258) { parse_chatRejectMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_chatrejectmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(266)) goto parse_dialogMessage; break; @@ -22939,13 +25835,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .DialogMessage dialogMessage = 33; case 33: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 266) { parse_dialogMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_dialogmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(274)) goto parse_timeoutWarningMessage; break; @@ -22953,13 +25848,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .TimeoutWarningMessage timeoutWarningMessage = 34; case 34: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 274) { parse_timeoutWarningMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_timeoutwarningmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(282)) goto parse_resetTimeoutMessage; break; @@ -22967,13 +25861,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .ResetTimeoutMessage resetTimeoutMessage = 35; case 35: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 282) { parse_resetTimeoutMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_resettimeoutmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(290)) goto parse_reportAvatarMessage; break; @@ -22981,13 +25874,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .ReportAvatarMessage reportAvatarMessage = 36; case 36: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 290) { parse_reportAvatarMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_reportavatarmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(298)) goto parse_reportAvatarAckMessage; break; @@ -22995,13 +25887,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .ReportAvatarAckMessage reportAvatarAckMessage = 37; case 37: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 298) { parse_reportAvatarAckMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_reportavatarackmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(306)) goto parse_reportGameMessage; break; @@ -23009,13 +25900,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .ReportGameMessage reportGameMessage = 38; case 38: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 306) { parse_reportGameMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_reportgamemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(314)) goto parse_reportGameAckMessage; break; @@ -23023,13 +25913,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .ReportGameAckMessage reportGameAckMessage = 39; case 39: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 314) { parse_reportGameAckMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_reportgameackmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(322)) goto parse_adminRemoveGameMessage; break; @@ -23037,13 +25926,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .AdminRemoveGameMessage adminRemoveGameMessage = 40; case 40: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 322) { parse_adminRemoveGameMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_adminremovegamemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(330)) goto parse_adminRemoveGameAckMessage; break; @@ -23051,13 +25939,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 41; case 41: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 330) { parse_adminRemoveGameAckMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_adminremovegameackmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(338)) goto parse_adminBanPlayerMessage; break; @@ -23065,13 +25952,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .AdminBanPlayerMessage adminBanPlayerMessage = 42; case 42: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 338) { parse_adminBanPlayerMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_adminbanplayermessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(346)) goto parse_adminBanPlayerAckMessage; break; @@ -23079,13 +25965,12 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 43; case 43: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 346) { parse_adminBanPlayerAckMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_adminbanplayerackmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(8202)) goto parse_errorMessage; break; @@ -23093,35 +25978,42 @@ bool LobbyMessage::MergePartialFromCodedStream( // optional .ErrorMessage errorMessage = 1025; case 1025: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 8202) { parse_errorMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_errormessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:LobbyMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:LobbyMessage) + return false; #undef DO_ } void LobbyMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:LobbyMessage) // required .LobbyMessage.LobbyMessageType messageType = 1; if (has_messagetype()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -23386,6 +26278,9 @@ void LobbyMessage::SerializeWithCachedSizes( 1025, this->errormessage(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:LobbyMessage) } int LobbyMessage::ByteSize() const { @@ -23710,6 +26605,8 @@ int LobbyMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -23867,6 +26764,7 @@ void LobbyMessage::MergeFrom(const LobbyMessage& from) { mutable_errormessage()->::ErrorMessage::MergeFrom(from.errormessage()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void LobbyMessage::CopyFrom(const LobbyMessage& from) { @@ -24052,6 +26950,7 @@ void LobbyMessage::Swap(LobbyMessage* other) { std::swap(errormessage_, other->errormessage_); std::swap(_has_bits_[0], other->_has_bits_[0]); std::swap(_has_bits_[1], other->_has_bits_[1]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -24167,6 +27066,7 @@ const int GameManagementMessage::kErrorMessageFieldNumber; GameManagementMessage::GameManagementMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameManagementMessage) } void GameManagementMessage::InitAsDefaultInstance() { @@ -24344,6 +27244,7 @@ GameManagementMessage::GameManagementMessage(const GameManagementMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameManagementMessage) } void GameManagementMessage::SharedCtor() { @@ -24381,6 +27282,7 @@ void GameManagementMessage::SharedCtor() { } GameManagementMessage::~GameManagementMessage() { + // @@protoc_insertion_point(destructor:GameManagementMessage) SharedDtor(); } @@ -24442,7 +27344,7 @@ GameManagementMessage* GameManagementMessage::New() const { } void GameManagementMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 255) { messagetype_ = 1; if (has_gameplayerjoinedmessage()) { if (gameplayerjoinedmessage_ != NULL) gameplayerjoinedmessage_->::GamePlayerJoinedMessage::Clear(); @@ -24466,7 +27368,7 @@ void GameManagementMessage::Clear() { if (kickplayerrequestmessage_ != NULL) kickplayerrequestmessage_->::KickPlayerRequestMessage::Clear(); } } - if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (_has_bits_[8 / 32] & 65280) { if (has_leavegamerequestmessage()) { if (leavegamerequestmessage_ != NULL) leavegamerequestmessage_->::LeaveGameRequestMessage::Clear(); } @@ -24492,7 +27394,7 @@ void GameManagementMessage::Clear() { if (playeridchangedmessage_ != NULL) playeridchangedmessage_->::PlayerIdChangedMessage::Clear(); } } - if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (_has_bits_[16 / 32] & 16711680) { if (has_askkickplayermessage()) { if (askkickplayermessage_ != NULL) askkickplayermessage_->::AskKickPlayerMessage::Clear(); } @@ -24518,7 +27420,7 @@ void GameManagementMessage::Clear() { if (chatrequestmessage_ != NULL) chatrequestmessage_->::ChatRequestMessage::Clear(); } } - if (_has_bits_[24 / 32] & (0xffu << (24 % 32))) { + if (_has_bits_[24 / 32] & 520093696) { if (has_chatmessage()) { if (chatmessage_ != NULL) chatmessage_->::ChatMessage::Clear(); } @@ -24536,27 +27438,38 @@ void GameManagementMessage::Clear() { } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameManagementMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameManagementMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .GameManagementMessage.GameManagementMessageType messageType = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::GameManagementMessage_GameManagementMessageType_IsValid(value)) { set_messagetype(static_cast< ::GameManagementMessage_GameManagementMessageType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_gamePlayerJoinedMessage; break; @@ -24564,13 +27477,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .GamePlayerJoinedMessage gamePlayerJoinedMessage = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_gamePlayerJoinedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gameplayerjoinedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_gamePlayerLeftMessage; break; @@ -24578,13 +27490,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .GamePlayerLeftMessage gamePlayerLeftMessage = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_gamePlayerLeftMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gameplayerleftmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_gameSpectatorJoinedMessage; break; @@ -24592,13 +27503,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .GameSpectatorJoinedMessage gameSpectatorJoinedMessage = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_gameSpectatorJoinedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamespectatorjoinedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(42)) goto parse_gameSpectatorLeftMessage; break; @@ -24606,13 +27516,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .GameSpectatorLeftMessage gameSpectatorLeftMessage = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 42) { parse_gameSpectatorLeftMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamespectatorleftmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(50)) goto parse_gameAdminChangedMessage; break; @@ -24620,13 +27529,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .GameAdminChangedMessage gameAdminChangedMessage = 6; case 6: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 50) { parse_gameAdminChangedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gameadminchangedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(58)) goto parse_removedFromGameMessage; break; @@ -24634,13 +27542,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .RemovedFromGameMessage removedFromGameMessage = 7; case 7: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 58) { parse_removedFromGameMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_removedfromgamemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(66)) goto parse_kickPlayerRequestMessage; break; @@ -24648,13 +27555,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .KickPlayerRequestMessage kickPlayerRequestMessage = 8; case 8: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 66) { parse_kickPlayerRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_kickplayerrequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(74)) goto parse_leaveGameRequestMessage; break; @@ -24662,13 +27568,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .LeaveGameRequestMessage leaveGameRequestMessage = 9; case 9: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 74) { parse_leaveGameRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_leavegamerequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(82)) goto parse_invitePlayerToGameMessage; break; @@ -24676,13 +27581,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .InvitePlayerToGameMessage invitePlayerToGameMessage = 10; case 10: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 82) { parse_invitePlayerToGameMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_inviteplayertogamemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(90)) goto parse_startEventMessage; break; @@ -24690,13 +27594,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .StartEventMessage startEventMessage = 11; case 11: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 90) { parse_startEventMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_starteventmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(98)) goto parse_startEventAckMessage; break; @@ -24704,13 +27607,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .StartEventAckMessage startEventAckMessage = 12; case 12: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 98) { parse_startEventAckMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_starteventackmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(106)) goto parse_gameStartInitialMessage; break; @@ -24718,13 +27620,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .GameStartInitialMessage gameStartInitialMessage = 13; case 13: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 106) { parse_gameStartInitialMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamestartinitialmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(114)) goto parse_gameStartRejoinMessage; break; @@ -24732,13 +27633,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .GameStartRejoinMessage gameStartRejoinMessage = 14; case 14: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 114) { parse_gameStartRejoinMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamestartrejoinmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(122)) goto parse_endOfGameMessage; break; @@ -24746,13 +27646,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .EndOfGameMessage endOfGameMessage = 15; case 15: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 122) { parse_endOfGameMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_endofgamemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(130)) goto parse_playerIdChangedMessage; break; @@ -24760,13 +27659,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .PlayerIdChangedMessage playerIdChangedMessage = 16; case 16: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 130) { parse_playerIdChangedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_playeridchangedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(138)) goto parse_askKickPlayerMessage; break; @@ -24774,13 +27672,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .AskKickPlayerMessage askKickPlayerMessage = 17; case 17: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 138) { parse_askKickPlayerMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_askkickplayermessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(146)) goto parse_askKickDeniedMessage; break; @@ -24788,13 +27685,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .AskKickDeniedMessage askKickDeniedMessage = 18; case 18: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 146) { parse_askKickDeniedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_askkickdeniedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(154)) goto parse_startKickPetitionMessage; break; @@ -24802,13 +27698,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .StartKickPetitionMessage startKickPetitionMessage = 19; case 19: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 154) { parse_startKickPetitionMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_startkickpetitionmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(162)) goto parse_voteKickRequestMessage; break; @@ -24816,13 +27711,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .VoteKickRequestMessage voteKickRequestMessage = 20; case 20: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 162) { parse_voteKickRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_votekickrequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(170)) goto parse_voteKickReplyMessage; break; @@ -24830,13 +27724,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .VoteKickReplyMessage voteKickReplyMessage = 21; case 21: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 170) { parse_voteKickReplyMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_votekickreplymessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(178)) goto parse_kickPetitionUpdateMessage; break; @@ -24844,13 +27737,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .KickPetitionUpdateMessage kickPetitionUpdateMessage = 22; case 22: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 178) { parse_kickPetitionUpdateMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_kickpetitionupdatemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(186)) goto parse_endKickPetitionMessage; break; @@ -24858,13 +27750,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .EndKickPetitionMessage endKickPetitionMessage = 23; case 23: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 186) { parse_endKickPetitionMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_endkickpetitionmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(194)) goto parse_chatRequestMessage; break; @@ -24872,13 +27763,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .ChatRequestMessage chatRequestMessage = 24; case 24: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 194) { parse_chatRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_chatrequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(202)) goto parse_chatMessage; break; @@ -24886,13 +27776,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .ChatMessage chatMessage = 25; case 25: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 202) { parse_chatMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_chatmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(210)) goto parse_chatRejectMessage; break; @@ -24900,13 +27789,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .ChatRejectMessage chatRejectMessage = 26; case 26: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 210) { parse_chatRejectMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_chatrejectmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(218)) goto parse_timeoutWarningMessage; break; @@ -24914,13 +27802,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .TimeoutWarningMessage timeoutWarningMessage = 27; case 27: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 218) { parse_timeoutWarningMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_timeoutwarningmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(226)) goto parse_resetTimeoutMessage; break; @@ -24928,13 +27815,12 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .ResetTimeoutMessage resetTimeoutMessage = 28; case 28: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 226) { parse_resetTimeoutMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_resettimeoutmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(8202)) goto parse_errorMessage; break; @@ -24942,35 +27828,42 @@ bool GameManagementMessage::MergePartialFromCodedStream( // optional .ErrorMessage errorMessage = 1025; case 1025: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 8202) { parse_errorMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_errormessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameManagementMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameManagementMessage) + return false; #undef DO_ } void GameManagementMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameManagementMessage) // required .GameManagementMessage.GameManagementMessageType messageType = 1; if (has_messagetype()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -25145,6 +28038,9 @@ void GameManagementMessage::SerializeWithCachedSizes( 1025, this->errormessage(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameManagementMessage) } int GameManagementMessage::ByteSize() const { @@ -25360,6 +28256,8 @@ int GameManagementMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -25468,6 +28366,7 @@ void GameManagementMessage::MergeFrom(const GameManagementMessage& from) { mutable_errormessage()->::ErrorMessage::MergeFrom(from.errormessage()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameManagementMessage::CopyFrom(const GameManagementMessage& from) { @@ -25589,6 +28488,7 @@ void GameManagementMessage::Swap(GameManagementMessage* other) { std::swap(resettimeoutmessage_, other->resettimeoutmessage_); std::swap(errormessage_, other->errormessage_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -25659,6 +28559,7 @@ const int GameEngineMessage::kAfterHandShowCardsMessageFieldNumber; GameEngineMessage::GameEngineMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameEngineMessage) } void GameEngineMessage::InitAsDefaultInstance() { @@ -25746,6 +28647,7 @@ GameEngineMessage::GameEngineMessage(const GameEngineMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameEngineMessage) } void GameEngineMessage::SharedCtor() { @@ -25768,6 +28670,7 @@ void GameEngineMessage::SharedCtor() { } GameEngineMessage::~GameEngineMessage() { + // @@protoc_insertion_point(destructor:GameEngineMessage) SharedDtor(); } @@ -25814,7 +28717,7 @@ GameEngineMessage* GameEngineMessage::New() const { } void GameEngineMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 255) { messagetype_ = 1; if (has_handstartmessage()) { if (handstartmessage_ != NULL) handstartmessage_->::HandStartMessage::Clear(); @@ -25838,7 +28741,7 @@ void GameEngineMessage::Clear() { if (dealturncardmessage_ != NULL) dealturncardmessage_->::DealTurnCardMessage::Clear(); } } - if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (_has_bits_[8 / 32] & 16128) { if (has_dealrivercardmessage()) { if (dealrivercardmessage_ != NULL) dealrivercardmessage_->::DealRiverCardMessage::Clear(); } @@ -25859,27 +28762,38 @@ void GameEngineMessage::Clear() { } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameEngineMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameEngineMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .GameEngineMessage.GameEngineMessageType messageType = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::GameEngineMessage_GameEngineMessageType_IsValid(value)) { set_messagetype(static_cast< ::GameEngineMessage_GameEngineMessageType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_handStartMessage; break; @@ -25887,13 +28801,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .HandStartMessage handStartMessage = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_handStartMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_handstartmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_playersTurnMessage; break; @@ -25901,13 +28814,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .PlayersTurnMessage playersTurnMessage = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_playersTurnMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_playersturnmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_myActionRequestMessage; break; @@ -25915,13 +28827,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .MyActionRequestMessage myActionRequestMessage = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_myActionRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_myactionrequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(42)) goto parse_yourActionRejectedMessage; break; @@ -25929,13 +28840,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .YourActionRejectedMessage yourActionRejectedMessage = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 42) { parse_yourActionRejectedMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_youractionrejectedmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(50)) goto parse_playersActionDoneMessage; break; @@ -25943,13 +28853,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .PlayersActionDoneMessage playersActionDoneMessage = 6; case 6: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 50) { parse_playersActionDoneMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_playersactiondonemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(58)) goto parse_dealFlopCardsMessage; break; @@ -25957,13 +28866,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .DealFlopCardsMessage dealFlopCardsMessage = 7; case 7: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 58) { parse_dealFlopCardsMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_dealflopcardsmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(66)) goto parse_dealTurnCardMessage; break; @@ -25971,13 +28879,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .DealTurnCardMessage dealTurnCardMessage = 8; case 8: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 66) { parse_dealTurnCardMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_dealturncardmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(74)) goto parse_dealRiverCardMessage; break; @@ -25985,13 +28892,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .DealRiverCardMessage dealRiverCardMessage = 9; case 9: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 74) { parse_dealRiverCardMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_dealrivercardmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(82)) goto parse_allInShowCardsMessage; break; @@ -25999,13 +28905,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .AllInShowCardsMessage allInShowCardsMessage = 10; case 10: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 82) { parse_allInShowCardsMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_allinshowcardsmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(90)) goto parse_endOfHandShowCardsMessage; break; @@ -26013,13 +28918,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .EndOfHandShowCardsMessage endOfHandShowCardsMessage = 11; case 11: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 90) { parse_endOfHandShowCardsMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_endofhandshowcardsmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(98)) goto parse_endOfHandHideCardsMessage; break; @@ -26027,13 +28931,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .EndOfHandHideCardsMessage endOfHandHideCardsMessage = 12; case 12: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 98) { parse_endOfHandHideCardsMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_endofhandhidecardsmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(106)) goto parse_showMyCardsRequestMessage; break; @@ -26041,13 +28944,12 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .ShowMyCardsRequestMessage showMyCardsRequestMessage = 13; case 13: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 106) { parse_showMyCardsRequestMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_showmycardsrequestmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(114)) goto parse_afterHandShowCardsMessage; break; @@ -26055,35 +28957,42 @@ bool GameEngineMessage::MergePartialFromCodedStream( // optional .AfterHandShowCardsMessage afterHandShowCardsMessage = 14; case 14: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 114) { parse_afterHandShowCardsMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_afterhandshowcardsmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameEngineMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameEngineMessage) + return false; #undef DO_ } void GameEngineMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameEngineMessage) // required .GameEngineMessage.GameEngineMessageType messageType = 1; if (has_messagetype()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -26168,6 +29077,9 @@ void GameEngineMessage::SerializeWithCachedSizes( 14, this->afterhandshowcardsmessage(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameEngineMessage) } int GameEngineMessage::ByteSize() const { @@ -26274,6 +29186,8 @@ int GameEngineMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -26333,6 +29247,7 @@ void GameEngineMessage::MergeFrom(const GameEngineMessage& from) { mutable_afterhandshowcardsmessage()->::AfterHandShowCardsMessage::MergeFrom(from.afterhandshowcardsmessage()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameEngineMessage::CopyFrom(const GameEngineMessage& from) { @@ -26400,6 +29315,7 @@ void GameEngineMessage::Swap(GameEngineMessage* other) { std::swap(showmycardsrequestmessage_, other->showmycardsrequestmessage_); std::swap(afterhandshowcardsmessage_, other->afterhandshowcardsmessage_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -26438,6 +29354,7 @@ const int GameMessage::kGameEngineMessageFieldNumber; GameMessage::GameMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:GameMessage) } void GameMessage::InitAsDefaultInstance() { @@ -26459,6 +29376,7 @@ GameMessage::GameMessage(const GameMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:GameMessage) } void GameMessage::SharedCtor() { @@ -26471,6 +29389,7 @@ void GameMessage::SharedCtor() { } GameMessage::~GameMessage() { + // @@protoc_insertion_point(destructor:GameMessage) SharedDtor(); } @@ -26506,7 +29425,7 @@ GameMessage* GameMessage::New() const { } void GameMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 15) { messagetype_ = 1; gameid_ = 0u; if (has_gamemanagementmessage()) { @@ -26517,27 +29436,38 @@ void GameMessage::Clear() { } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool GameMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:GameMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .GameMessage.GameMessageType messageType = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::GameMessage_GameMessageType_IsValid(value)) { set_messagetype(static_cast< ::GameMessage_GameMessageType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(16)) goto parse_gameId; break; @@ -26545,15 +29475,14 @@ bool GameMessage::MergePartialFromCodedStream( // required uint32 gameId = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 16) { parse_gameId: DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( input, &gameid_))); set_has_gameid(); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_gameManagementMessage; break; @@ -26561,13 +29490,12 @@ bool GameMessage::MergePartialFromCodedStream( // optional .GameManagementMessage gameManagementMessage = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_gameManagementMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamemanagementmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_gameEngineMessage; break; @@ -26575,35 +29503,42 @@ bool GameMessage::MergePartialFromCodedStream( // optional .GameEngineMessage gameEngineMessage = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_gameEngineMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gameenginemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:GameMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:GameMessage) + return false; #undef DO_ } void GameMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:GameMessage) // required .GameMessage.GameMessageType messageType = 1; if (has_messagetype()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -26627,6 +29562,9 @@ void GameMessage::SerializeWithCachedSizes( 4, this->gameenginemessage(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:GameMessage) } int GameMessage::ByteSize() const { @@ -26661,6 +29599,8 @@ int GameMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -26688,6 +29628,7 @@ void GameMessage::MergeFrom(const GameMessage& from) { mutable_gameenginemessage()->::GameEngineMessage::MergeFrom(from.gameenginemessage()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void GameMessage::CopyFrom(const GameMessage& from) { @@ -26715,6 +29656,7 @@ void GameMessage::Swap(GameMessage* other) { std::swap(gamemanagementmessage_, other->gamemanagementmessage_); std::swap(gameenginemessage_, other->gameenginemessage_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } @@ -26758,6 +29700,7 @@ const int PokerTHMessage::kGameMessageFieldNumber; PokerTHMessage::PokerTHMessage() : ::google::protobuf::MessageLite() { SharedCtor(); + // @@protoc_insertion_point(constructor:PokerTHMessage) } void PokerTHMessage::InitAsDefaultInstance() { @@ -26791,6 +29734,7 @@ PokerTHMessage::PokerTHMessage(const PokerTHMessage& from) : ::google::protobuf::MessageLite() { SharedCtor(); MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:PokerTHMessage) } void PokerTHMessage::SharedCtor() { @@ -26804,6 +29748,7 @@ void PokerTHMessage::SharedCtor() { } PokerTHMessage::~PokerTHMessage() { + // @@protoc_insertion_point(destructor:PokerTHMessage) SharedDtor(); } @@ -26841,7 +29786,7 @@ PokerTHMessage* PokerTHMessage::New() const { } void PokerTHMessage::Clear() { - if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (_has_bits_[0 / 32] & 31) { messagetype_ = 1; if (has_announcemessage()) { if (announcemessage_ != NULL) announcemessage_->::AnnounceMessage::Clear(); @@ -26857,27 +29802,38 @@ void PokerTHMessage::Clear() { } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); } bool PokerTHMessage::MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!(EXPRESSION)) return false +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure ::google::protobuf::uint32 tag; - while ((tag = input->ReadTag()) != 0) { + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:PokerTHMessage) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { // required .PokerTHMessage.PokerTHMessageType messageType = 1; case 1: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + if (tag == 8) { int value; DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( input, &value))); if (::PokerTHMessage_PokerTHMessageType_IsValid(value)) { set_messagetype(static_cast< ::PokerTHMessage_PokerTHMessageType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); } } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(18)) goto parse_announceMessage; break; @@ -26885,13 +29841,12 @@ bool PokerTHMessage::MergePartialFromCodedStream( // optional .AnnounceMessage announceMessage = 2; case 2: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 18) { parse_announceMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_announcemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(26)) goto parse_authMessage; break; @@ -26899,13 +29854,12 @@ bool PokerTHMessage::MergePartialFromCodedStream( // optional .AuthMessage authMessage = 3; case 3: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 26) { parse_authMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_authmessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(34)) goto parse_lobbyMessage; break; @@ -26913,13 +29867,12 @@ bool PokerTHMessage::MergePartialFromCodedStream( // optional .LobbyMessage lobbyMessage = 4; case 4: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 34) { parse_lobbyMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_lobbymessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } if (input->ExpectTag(42)) goto parse_gameMessage; break; @@ -26927,35 +29880,42 @@ bool PokerTHMessage::MergePartialFromCodedStream( // optional .GameMessage gameMessage = 5; case 5: { - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == - ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + if (tag == 42) { parse_gameMessage: DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( input, mutable_gamemessage())); } else { - goto handle_uninterpreted; + goto handle_unusual; } - if (input->ExpectAtEnd()) return true; + if (input->ExpectAtEnd()) goto success; break; } default: { - handle_uninterpreted: - if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { - return true; + goto success; } - DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); break; } } } +success: + // @@protoc_insertion_point(parse_success:PokerTHMessage) return true; +failure: + // @@protoc_insertion_point(parse_failure:PokerTHMessage) + return false; #undef DO_ } void PokerTHMessage::SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:PokerTHMessage) // required .PokerTHMessage.PokerTHMessageType messageType = 1; if (has_messagetype()) { ::google::protobuf::internal::WireFormatLite::WriteEnum( @@ -26986,6 +29946,9 @@ void PokerTHMessage::SerializeWithCachedSizes( 5, this->gamemessage(), output); } + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:PokerTHMessage) } int PokerTHMessage::ByteSize() const { @@ -27027,6 +29990,8 @@ int PokerTHMessage::ByteSize() const { } } + total_size += unknown_fields().size(); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -27057,6 +30022,7 @@ void PokerTHMessage::MergeFrom(const PokerTHMessage& from) { mutable_gamemessage()->::GameMessage::MergeFrom(from.gamemessage()); } } + mutable_unknown_fields()->append(from.unknown_fields()); } void PokerTHMessage::CopyFrom(const PokerTHMessage& from) { @@ -27091,6 +30057,7 @@ void PokerTHMessage::Swap(PokerTHMessage* other) { std::swap(lobbymessage_, other->lobbymessage_); std::swap(gamemessage_, other->gamemessage_); std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); } } diff --git a/src/third_party/protobuf/pokerth.pb.h b/src/third_party/protobuf/pokerth.pb.h index 0a0184a9..dd63209d 100644 --- a/src/third_party/protobuf/pokerth.pb.h +++ b/src/third_party/protobuf/pokerth.pb.h @@ -8,12 +8,12 @@ #include -#if GOOGLE_PROTOBUF_VERSION < 2005000 +#if GOOGLE_PROTOBUF_VERSION < 2006000 #error This file was generated by a newer version of protoc which is #error incompatible with your Protocol Buffer headers. Please update #error your headers. #endif -#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION #error This file was generated by an older version of protoc which is #error incompatible with your Protocol Buffer headers. Please #error regenerate this file with a newer version of protoc. @@ -619,6 +619,14 @@ class NetGameInfo : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const NetGameInfo& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -647,13 +655,13 @@ class NetGameInfo : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -848,6 +856,10 @@ class NetGameInfo : public ::google::protobuf::MessageLite { inline void set_has_allowspectators(); inline void clear_has_allowspectators(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::std::string* gamename_; int netgametype_; ::google::protobuf::uint32 maxnumplayers_; @@ -864,10 +876,6 @@ class NetGameInfo : public ::google::protobuf::MessageLite { ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > manualblinds_; mutable int _manualblinds_cached_byte_size_; bool allowspectators_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(15 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -893,6 +901,14 @@ class PlayerResult : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PlayerResult& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -921,13 +937,13 @@ class PlayerResult : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -1003,6 +1019,10 @@ class PlayerResult : public ::google::protobuf::MessageLite { inline void set_has_cardsvalue(); inline void clear_has_cardsvalue(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; ::google::protobuf::uint32 resultcard1_; ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > besthandposition_; @@ -1011,10 +1031,6 @@ class PlayerResult : public ::google::protobuf::MessageLite { ::google::protobuf::uint32 moneywon_; ::google::protobuf::uint32 playermoney_; ::google::protobuf::uint32 cardsvalue_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -1040,6 +1056,14 @@ class AnnounceMessage_Version : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AnnounceMessage_Version& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -1068,13 +1092,13 @@ class AnnounceMessage_Version : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -1102,12 +1126,12 @@ class AnnounceMessage_Version : public ::google::protobuf::MessageLite { inline void set_has_minorversion(); inline void clear_has_minorversion(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 majorversion_; ::google::protobuf::uint32 minorversion_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -1133,6 +1157,14 @@ class AnnounceMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AnnounceMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -1161,13 +1193,13 @@ class AnnounceMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -1242,15 +1274,15 @@ class AnnounceMessage : public ::google::protobuf::MessageLite { inline void set_has_numplayersonserver(); inline void clear_has_numplayersonserver(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::AnnounceMessage_Version* protocolversion_; ::AnnounceMessage_Version* latestgameversion_; ::google::protobuf::uint32 latestbetarevision_; int servertype_; ::google::protobuf::uint32 numplayersonserver_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -1276,6 +1308,14 @@ class AuthClientRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AuthClientRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -1304,13 +1344,13 @@ class AuthClientRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -1433,6 +1473,10 @@ class AuthClientRequestMessage : public ::google::protobuf::MessageLite { inline void set_has_avatarhash(); inline void clear_has_avatarhash(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::AnnounceMessage_Version* requestedversion_; ::google::protobuf::uint32 buildid_; int login_; @@ -1441,10 +1485,6 @@ class AuthClientRequestMessage : public ::google::protobuf::MessageLite { ::std::string* clientuserdata_; ::std::string* mylastsessionid_; ::std::string* avatarhash_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -1470,6 +1510,14 @@ class AuthServerChallengeMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AuthServerChallengeMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -1498,13 +1546,13 @@ class AuthServerChallengeMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -1528,11 +1576,11 @@ class AuthServerChallengeMessage : public ::google::protobuf::MessageLite { inline void set_has_serverchallenge(); inline void clear_has_serverchallenge(); - ::std::string* serverchallenge_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::std::string* serverchallenge_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -1558,6 +1606,14 @@ class AuthClientResponseMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AuthClientResponseMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -1586,13 +1642,13 @@ class AuthClientResponseMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -1616,11 +1672,11 @@ class AuthClientResponseMessage : public ::google::protobuf::MessageLite { inline void set_has_clientresponse(); inline void clear_has_clientresponse(); - ::std::string* clientresponse_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::std::string* clientresponse_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -1646,6 +1702,14 @@ class AuthServerVerificationMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AuthServerVerificationMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -1674,13 +1738,13 @@ class AuthServerVerificationMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -1704,11 +1768,11 @@ class AuthServerVerificationMessage : public ::google::protobuf::MessageLite { inline void set_has_serververification(); inline void clear_has_serververification(); - ::std::string* serververification_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::std::string* serververification_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -1734,6 +1798,14 @@ class InitDoneMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const InitDoneMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -1762,13 +1834,13 @@ class InitDoneMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -1824,14 +1896,14 @@ class InitDoneMessage : public ::google::protobuf::MessageLite { inline void set_has_rejoingameid(); inline void clear_has_rejoingameid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::std::string* yoursessionid_; ::std::string* youravatarhash_; ::google::protobuf::uint32 yourplayerid_; ::google::protobuf::uint32 rejoingameid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -1857,6 +1929,14 @@ class AvatarRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AvatarRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -1885,13 +1965,13 @@ class AvatarRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -1924,12 +2004,12 @@ class AvatarRequestMessage : public ::google::protobuf::MessageLite { inline void set_has_avatarhash(); inline void clear_has_avatarhash(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::std::string* avatarhash_; ::google::protobuf::uint32 requestid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -1955,6 +2035,14 @@ class AvatarHeaderMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AvatarHeaderMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -1983,13 +2071,13 @@ class AvatarHeaderMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2026,13 +2114,13 @@ class AvatarHeaderMessage : public ::google::protobuf::MessageLite { inline void set_has_avatarsize(); inline void clear_has_avatarsize(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 requestid_; int avatartype_; ::google::protobuf::uint32 avatarsize_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2058,6 +2146,14 @@ class AvatarDataMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AvatarDataMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2086,13 +2182,13 @@ class AvatarDataMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2125,12 +2221,12 @@ class AvatarDataMessage : public ::google::protobuf::MessageLite { inline void set_has_avatarblock(); inline void clear_has_avatarblock(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::std::string* avatarblock_; ::google::protobuf::uint32 requestid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2156,6 +2252,14 @@ class AvatarEndMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AvatarEndMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2184,13 +2288,13 @@ class AvatarEndMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2209,11 +2313,11 @@ class AvatarEndMessage : public ::google::protobuf::MessageLite { inline void set_has_requestid(); inline void clear_has_requestid(); - ::google::protobuf::uint32 requestid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 requestid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2239,6 +2343,14 @@ class UnknownAvatarMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const UnknownAvatarMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2267,13 +2379,13 @@ class UnknownAvatarMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2292,11 +2404,11 @@ class UnknownAvatarMessage : public ::google::protobuf::MessageLite { inline void set_has_requestid(); inline void clear_has_requestid(); - ::google::protobuf::uint32 requestid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 requestid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2322,6 +2434,14 @@ class PlayerListMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PlayerListMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2350,13 +2470,13 @@ class PlayerListMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2397,12 +2517,12 @@ class PlayerListMessage : public ::google::protobuf::MessageLite { inline void set_has_playerlistnotification(); inline void clear_has_playerlistnotification(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; int playerlistnotification_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2428,6 +2548,14 @@ class GameListNewMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameListNewMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2456,13 +2584,13 @@ class GameListNewMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2543,6 +2671,10 @@ class GameListNewMessage : public ::google::protobuf::MessageLite { inline void set_has_gameinfo(); inline void clear_has_gameinfo(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; int gamemode_; ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > playerids_; @@ -2552,10 +2684,6 @@ class GameListNewMessage : public ::google::protobuf::MessageLite { ::NetGameInfo* gameinfo_; ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > spectatorids_; mutable int _spectatorids_cached_byte_size_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2581,6 +2709,14 @@ class GameListUpdateMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameListUpdateMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2609,13 +2745,13 @@ class GameListUpdateMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2643,12 +2779,12 @@ class GameListUpdateMessage : public ::google::protobuf::MessageLite { inline void set_has_gamemode(); inline void clear_has_gamemode(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; int gamemode_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2674,6 +2810,14 @@ class GameListPlayerJoinedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameListPlayerJoinedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2702,13 +2846,13 @@ class GameListPlayerJoinedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2736,12 +2880,12 @@ class GameListPlayerJoinedMessage : public ::google::protobuf::MessageLite { inline void set_has_playerid(); inline void clear_has_playerid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; ::google::protobuf::uint32 playerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2767,6 +2911,14 @@ class GameListPlayerLeftMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameListPlayerLeftMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2795,13 +2947,13 @@ class GameListPlayerLeftMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2829,12 +2981,12 @@ class GameListPlayerLeftMessage : public ::google::protobuf::MessageLite { inline void set_has_playerid(); inline void clear_has_playerid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; ::google::protobuf::uint32 playerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2860,6 +3012,14 @@ class GameListSpectatorJoinedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameListSpectatorJoinedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2888,13 +3048,13 @@ class GameListSpectatorJoinedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -2922,12 +3082,12 @@ class GameListSpectatorJoinedMessage : public ::google::protobuf::MessageLite { inline void set_has_playerid(); inline void clear_has_playerid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; ::google::protobuf::uint32 playerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -2953,6 +3113,14 @@ class GameListSpectatorLeftMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameListSpectatorLeftMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -2981,13 +3149,13 @@ class GameListSpectatorLeftMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3015,12 +3183,12 @@ class GameListSpectatorLeftMessage : public ::google::protobuf::MessageLite { inline void set_has_playerid(); inline void clear_has_playerid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; ::google::protobuf::uint32 playerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3046,6 +3214,14 @@ class GameListAdminChangedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameListAdminChangedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3074,13 +3250,13 @@ class GameListAdminChangedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3108,12 +3284,12 @@ class GameListAdminChangedMessage : public ::google::protobuf::MessageLite { inline void set_has_newadminplayerid(); inline void clear_has_newadminplayerid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; ::google::protobuf::uint32 newadminplayerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3139,6 +3315,14 @@ class PlayerInfoRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PlayerInfoRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3167,13 +3351,13 @@ class PlayerInfoRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3195,12 +3379,12 @@ class PlayerInfoRequestMessage : public ::google::protobuf::MessageLite { // @@protoc_insertion_point(class_scope:PlayerInfoRequestMessage) private: + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > playerid_; mutable int _playerid_cached_byte_size_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3226,6 +3410,14 @@ class PlayerInfoReplyMessage_PlayerInfoData_AvatarData : public ::google::protob return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PlayerInfoReplyMessage_PlayerInfoData_AvatarData& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3254,13 +3446,13 @@ class PlayerInfoReplyMessage_PlayerInfoData_AvatarData : public ::google::protob ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3293,12 +3485,12 @@ class PlayerInfoReplyMessage_PlayerInfoData_AvatarData : public ::google::protob inline void set_has_avatarhash(); inline void clear_has_avatarhash(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::std::string* avatarhash_; int avatartype_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3324,6 +3516,14 @@ class PlayerInfoReplyMessage_PlayerInfoData : public ::google::protobuf::Message return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PlayerInfoReplyMessage_PlayerInfoData& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3352,13 +3552,13 @@ class PlayerInfoReplyMessage_PlayerInfoData : public ::google::protobuf::Message ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3427,15 +3627,15 @@ class PlayerInfoReplyMessage_PlayerInfoData : public ::google::protobuf::Message inline void set_has_avatardata(); inline void clear_has_avatardata(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::std::string* playername_; bool ishuman_; int playerrights_; ::std::string* countrycode_; ::PlayerInfoReplyMessage_PlayerInfoData_AvatarData* avatardata_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3461,6 +3661,14 @@ class PlayerInfoReplyMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PlayerInfoReplyMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3489,13 +3697,13 @@ class PlayerInfoReplyMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3527,12 +3735,12 @@ class PlayerInfoReplyMessage : public ::google::protobuf::MessageLite { inline void set_has_playerinfodata(); inline void clear_has_playerinfodata(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::PlayerInfoReplyMessage_PlayerInfoData* playerinfodata_; ::google::protobuf::uint32 playerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3558,6 +3766,14 @@ class SubscriptionRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const SubscriptionRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3586,13 +3802,13 @@ class SubscriptionRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3633,12 +3849,12 @@ class SubscriptionRequestMessage : public ::google::protobuf::MessageLite { inline void set_has_subscriptionaction(); inline void clear_has_subscriptionaction(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 requestid_; int subscriptionaction_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3664,6 +3880,14 @@ class SubscriptionReplyMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const SubscriptionReplyMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3692,13 +3916,13 @@ class SubscriptionReplyMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3726,12 +3950,12 @@ class SubscriptionReplyMessage : public ::google::protobuf::MessageLite { inline void set_has_ack(); inline void clear_has_ack(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 requestid_; bool ack_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3757,6 +3981,14 @@ class CreateGameMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const CreateGameMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3785,13 +4017,13 @@ class CreateGameMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3844,14 +4076,14 @@ class CreateGameMessage : public ::google::protobuf::MessageLite { inline void set_has_autoleave(); inline void clear_has_autoleave(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::NetGameInfo* gameinfo_; ::google::protobuf::uint32 requestid_; bool autoleave_; ::std::string* password_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3877,6 +4109,14 @@ class CreateGameFailedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const CreateGameFailedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -3905,13 +4145,13 @@ class CreateGameFailedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -3954,12 +4194,12 @@ class CreateGameFailedMessage : public ::google::protobuf::MessageLite { inline void set_has_creategamefailurereason(); inline void clear_has_creategamefailurereason(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 requestid_; int creategamefailurereason_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -3985,6 +4225,14 @@ class JoinGameMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const JoinGameMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4013,13 +4261,13 @@ class JoinGameMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4070,14 +4318,14 @@ class JoinGameMessage : public ::google::protobuf::MessageLite { inline void set_has_spectateonly(); inline void clear_has_spectateonly(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::std::string* password_; ::google::protobuf::uint32 gameid_; bool autoleave_; bool spectateonly_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4103,6 +4351,14 @@ class RejoinGameMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const RejoinGameMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4131,13 +4387,13 @@ class RejoinGameMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4165,12 +4421,12 @@ class RejoinGameMessage : public ::google::protobuf::MessageLite { inline void set_has_autoleave(); inline void clear_has_autoleave(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; bool autoleave_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4196,6 +4452,14 @@ class JoinGameAckMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const JoinGameAckMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4224,13 +4488,13 @@ class JoinGameAckMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4278,14 +4542,14 @@ class JoinGameAckMessage : public ::google::protobuf::MessageLite { inline void set_has_spectateonly(); inline void clear_has_spectateonly(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; bool areyougameadmin_; bool spectateonly_; ::NetGameInfo* gameinfo_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4311,6 +4575,14 @@ class JoinGameFailedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const JoinGameFailedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4339,13 +4611,13 @@ class JoinGameFailedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4393,12 +4665,12 @@ class JoinGameFailedMessage : public ::google::protobuf::MessageLite { inline void set_has_joingamefailurereason(); inline void clear_has_joingamefailurereason(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; int joingamefailurereason_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4424,6 +4696,14 @@ class GamePlayerJoinedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GamePlayerJoinedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4452,13 +4732,13 @@ class GamePlayerJoinedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4486,12 +4766,12 @@ class GamePlayerJoinedMessage : public ::google::protobuf::MessageLite { inline void set_has_isgameadmin(); inline void clear_has_isgameadmin(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; bool isgameadmin_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4517,6 +4797,14 @@ class GamePlayerLeftMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GamePlayerLeftMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4545,13 +4833,13 @@ class GamePlayerLeftMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4593,12 +4881,12 @@ class GamePlayerLeftMessage : public ::google::protobuf::MessageLite { inline void set_has_gameplayerleftreason(); inline void clear_has_gameplayerleftreason(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; int gameplayerleftreason_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4624,6 +4912,14 @@ class GameSpectatorJoinedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameSpectatorJoinedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4652,13 +4948,13 @@ class GameSpectatorJoinedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4677,11 +4973,11 @@ class GameSpectatorJoinedMessage : public ::google::protobuf::MessageLite { inline void set_has_playerid(); inline void clear_has_playerid(); - ::google::protobuf::uint32 playerid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 playerid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4707,6 +5003,14 @@ class GameSpectatorLeftMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameSpectatorLeftMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4735,13 +5039,13 @@ class GameSpectatorLeftMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4769,12 +5073,12 @@ class GameSpectatorLeftMessage : public ::google::protobuf::MessageLite { inline void set_has_gamespectatorleftreason(); inline void clear_has_gamespectatorleftreason(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; int gamespectatorleftreason_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4800,6 +5104,14 @@ class GameAdminChangedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameAdminChangedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4828,13 +5140,13 @@ class GameAdminChangedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4853,11 +5165,11 @@ class GameAdminChangedMessage : public ::google::protobuf::MessageLite { inline void set_has_newadminplayerid(); inline void clear_has_newadminplayerid(); - ::google::protobuf::uint32 newadminplayerid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 newadminplayerid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4883,6 +5195,14 @@ class RemovedFromGameMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const RemovedFromGameMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -4911,13 +5231,13 @@ class RemovedFromGameMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -4954,11 +5274,11 @@ class RemovedFromGameMessage : public ::google::protobuf::MessageLite { inline void set_has_removedfromgamereason(); inline void clear_has_removedfromgamereason(); - int removedfromgamereason_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + int removedfromgamereason_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -4984,6 +5304,14 @@ class KickPlayerRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const KickPlayerRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5012,13 +5340,13 @@ class KickPlayerRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5037,11 +5365,11 @@ class KickPlayerRequestMessage : public ::google::protobuf::MessageLite { inline void set_has_playerid(); inline void clear_has_playerid(); - ::google::protobuf::uint32 playerid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 playerid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5067,6 +5395,14 @@ class LeaveGameRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const LeaveGameRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5095,13 +5431,13 @@ class LeaveGameRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5111,10 +5447,10 @@ class LeaveGameRequestMessage : public ::google::protobuf::MessageLite { // @@protoc_insertion_point(class_scope:LeaveGameRequestMessage) private: + ::std::string _unknown_fields_; - mutable int _cached_size_; ::google::protobuf::uint32 _has_bits_[1]; - + mutable int _cached_size_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5140,6 +5476,14 @@ class InvitePlayerToGameMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const InvitePlayerToGameMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5168,13 +5512,13 @@ class InvitePlayerToGameMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5202,12 +5546,12 @@ class InvitePlayerToGameMessage : public ::google::protobuf::MessageLite { inline void set_has_playerid(); inline void clear_has_playerid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; ::google::protobuf::uint32 playerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5233,6 +5577,14 @@ class InviteNotifyMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const InviteNotifyMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5261,13 +5613,13 @@ class InviteNotifyMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5304,13 +5656,13 @@ class InviteNotifyMessage : public ::google::protobuf::MessageLite { inline void set_has_playeridbywhom(); inline void clear_has_playeridbywhom(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; ::google::protobuf::uint32 playeridwho_; ::google::protobuf::uint32 playeridbywhom_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5336,6 +5688,14 @@ class RejectGameInvitationMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const RejectGameInvitationMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5364,13 +5724,13 @@ class RejectGameInvitationMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5411,12 +5771,12 @@ class RejectGameInvitationMessage : public ::google::protobuf::MessageLite { inline void set_has_myrejectreason(); inline void clear_has_myrejectreason(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; int myrejectreason_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5442,6 +5802,14 @@ class RejectInvNotifyMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const RejectInvNotifyMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5470,13 +5838,13 @@ class RejectInvNotifyMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5513,13 +5881,13 @@ class RejectInvNotifyMessage : public ::google::protobuf::MessageLite { inline void set_has_playerrejectreason(); inline void clear_has_playerrejectreason(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 gameid_; ::google::protobuf::uint32 playerid_; int playerrejectreason_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5545,6 +5913,14 @@ class StartEventMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const StartEventMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5573,13 +5949,13 @@ class StartEventMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5620,12 +5996,12 @@ class StartEventMessage : public ::google::protobuf::MessageLite { inline void set_has_fillwithcomputerplayers(); inline void clear_has_fillwithcomputerplayers(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; int starteventtype_; bool fillwithcomputerplayers_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5651,6 +6027,14 @@ class StartEventAckMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const StartEventAckMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5679,13 +6063,13 @@ class StartEventAckMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5695,10 +6079,10 @@ class StartEventAckMessage : public ::google::protobuf::MessageLite { // @@protoc_insertion_point(class_scope:StartEventAckMessage) private: + ::std::string _unknown_fields_; - mutable int _cached_size_; ::google::protobuf::uint32 _has_bits_[1]; - + mutable int _cached_size_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5724,6 +6108,14 @@ class GameStartInitialMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameStartInitialMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5752,13 +6144,13 @@ class GameStartInitialMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5789,13 +6181,13 @@ class GameStartInitialMessage : public ::google::protobuf::MessageLite { inline void set_has_startdealerplayerid(); inline void clear_has_startdealerplayerid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > playerseats_; mutable int _playerseats_cached_byte_size_; ::google::protobuf::uint32 startdealerplayerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5821,6 +6213,14 @@ class GameStartRejoinMessage_RejoinPlayerData : public ::google::protobuf::Messa return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameStartRejoinMessage_RejoinPlayerData& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5849,13 +6249,13 @@ class GameStartRejoinMessage_RejoinPlayerData : public ::google::protobuf::Messa ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5883,12 +6283,12 @@ class GameStartRejoinMessage_RejoinPlayerData : public ::google::protobuf::Messa inline void set_has_playermoney(); inline void clear_has_playermoney(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; ::google::protobuf::uint32 playermoney_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -5914,6 +6314,14 @@ class GameStartRejoinMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameStartRejoinMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -5942,13 +6350,13 @@ class GameStartRejoinMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -5990,13 +6398,13 @@ class GameStartRejoinMessage : public ::google::protobuf::MessageLite { inline void set_has_handnum(); inline void clear_has_handnum(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 startdealerplayerid_; ::google::protobuf::uint32 handnum_; ::google::protobuf::RepeatedPtrField< ::GameStartRejoinMessage_RejoinPlayerData > rejoinplayerdata_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6022,6 +6430,14 @@ class HandStartMessage_PlainCards : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const HandStartMessage_PlainCards& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6050,13 +6466,13 @@ class HandStartMessage_PlainCards : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -6084,12 +6500,12 @@ class HandStartMessage_PlainCards : public ::google::protobuf::MessageLite { inline void set_has_plaincard2(); inline void clear_has_plaincard2(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 plaincard1_; ::google::protobuf::uint32 plaincard2_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6115,6 +6531,14 @@ class HandStartMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const HandStartMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6143,13 +6567,13 @@ class HandStartMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -6214,15 +6638,15 @@ class HandStartMessage : public ::google::protobuf::MessageLite { inline void set_has_dealerplayerid(); inline void clear_has_dealerplayerid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::HandStartMessage_PlainCards* plaincards_; ::std::string* encryptedcards_; ::google::protobuf::RepeatedField seatstates_; ::google::protobuf::uint32 smallblind_; ::google::protobuf::uint32 dealerplayerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6248,6 +6672,14 @@ class PlayersTurnMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PlayersTurnMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6276,13 +6708,13 @@ class PlayersTurnMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -6310,12 +6742,12 @@ class PlayersTurnMessage : public ::google::protobuf::MessageLite { inline void set_has_gamestate(); inline void clear_has_gamestate(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; int gamestate_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6341,6 +6773,14 @@ class MyActionRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const MyActionRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6369,13 +6809,13 @@ class MyActionRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -6421,14 +6861,14 @@ class MyActionRequestMessage : public ::google::protobuf::MessageLite { inline void set_has_myrelativebet(); inline void clear_has_myrelativebet(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 handnum_; int gamestate_; int myaction_; ::google::protobuf::uint32 myrelativebet_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6454,6 +6894,14 @@ class YourActionRejectedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const YourActionRejectedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6482,13 +6930,13 @@ class YourActionRejectedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -6548,14 +6996,14 @@ class YourActionRejectedMessage : public ::google::protobuf::MessageLite { inline void set_has_rejectionreason(); inline void clear_has_rejectionreason(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; int gamestate_; int youraction_; ::google::protobuf::uint32 yourrelativebet_; int rejectionreason_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6581,6 +7029,14 @@ class PlayersActionDoneMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PlayersActionDoneMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6609,13 +7065,13 @@ class PlayersActionDoneMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -6688,6 +7144,10 @@ class PlayersActionDoneMessage : public ::google::protobuf::MessageLite { inline void set_has_minimumraise(); inline void clear_has_minimumraise(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; int gamestate_; int playeraction_; @@ -6695,10 +7155,6 @@ class PlayersActionDoneMessage : public ::google::protobuf::MessageLite { ::google::protobuf::uint32 playermoney_; ::google::protobuf::uint32 highestset_; ::google::protobuf::uint32 minimumraise_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6724,6 +7180,14 @@ class DealFlopCardsMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const DealFlopCardsMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6752,13 +7216,13 @@ class DealFlopCardsMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -6795,13 +7259,13 @@ class DealFlopCardsMessage : public ::google::protobuf::MessageLite { inline void set_has_flopcard3(); inline void clear_has_flopcard3(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 flopcard1_; ::google::protobuf::uint32 flopcard2_; ::google::protobuf::uint32 flopcard3_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6827,6 +7291,14 @@ class DealTurnCardMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const DealTurnCardMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6855,13 +7327,13 @@ class DealTurnCardMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -6880,11 +7352,11 @@ class DealTurnCardMessage : public ::google::protobuf::MessageLite { inline void set_has_turncard(); inline void clear_has_turncard(); - ::google::protobuf::uint32 turncard_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 turncard_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6910,6 +7382,14 @@ class DealRiverCardMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const DealRiverCardMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -6938,13 +7418,13 @@ class DealRiverCardMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -6963,11 +7443,11 @@ class DealRiverCardMessage : public ::google::protobuf::MessageLite { inline void set_has_rivercard(); inline void clear_has_rivercard(); - ::google::protobuf::uint32 rivercard_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 rivercard_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -6993,6 +7473,14 @@ class AllInShowCardsMessage_PlayerAllIn : public ::google::protobuf::MessageLite return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AllInShowCardsMessage_PlayerAllIn& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7021,13 +7509,13 @@ class AllInShowCardsMessage_PlayerAllIn : public ::google::protobuf::MessageLite ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7064,13 +7552,13 @@ class AllInShowCardsMessage_PlayerAllIn : public ::google::protobuf::MessageLite inline void set_has_allincard2(); inline void clear_has_allincard2(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; ::google::protobuf::uint32 allincard1_; ::google::protobuf::uint32 allincard2_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7096,6 +7584,14 @@ class AllInShowCardsMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AllInShowCardsMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7124,13 +7620,13 @@ class AllInShowCardsMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7154,11 +7650,11 @@ class AllInShowCardsMessage : public ::google::protobuf::MessageLite { // @@protoc_insertion_point(class_scope:AllInShowCardsMessage) private: - ::google::protobuf::RepeatedPtrField< ::AllInShowCardsMessage_PlayerAllIn > playersallin_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::RepeatedPtrField< ::AllInShowCardsMessage_PlayerAllIn > playersallin_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7184,6 +7680,14 @@ class EndOfHandShowCardsMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const EndOfHandShowCardsMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7212,13 +7716,13 @@ class EndOfHandShowCardsMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7240,11 +7744,11 @@ class EndOfHandShowCardsMessage : public ::google::protobuf::MessageLite { // @@protoc_insertion_point(class_scope:EndOfHandShowCardsMessage) private: - ::google::protobuf::RepeatedPtrField< ::PlayerResult > playerresults_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::RepeatedPtrField< ::PlayerResult > playerresults_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7270,6 +7774,14 @@ class EndOfHandHideCardsMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const EndOfHandHideCardsMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7298,13 +7810,13 @@ class EndOfHandHideCardsMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7341,13 +7853,13 @@ class EndOfHandHideCardsMessage : public ::google::protobuf::MessageLite { inline void set_has_playermoney(); inline void clear_has_playermoney(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; ::google::protobuf::uint32 moneywon_; ::google::protobuf::uint32 playermoney_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7373,6 +7885,14 @@ class ShowMyCardsRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ShowMyCardsRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7401,13 +7921,13 @@ class ShowMyCardsRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7417,10 +7937,10 @@ class ShowMyCardsRequestMessage : public ::google::protobuf::MessageLite { // @@protoc_insertion_point(class_scope:ShowMyCardsRequestMessage) private: + ::std::string _unknown_fields_; - mutable int _cached_size_; ::google::protobuf::uint32 _has_bits_[1]; - + mutable int _cached_size_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7446,6 +7966,14 @@ class AfterHandShowCardsMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AfterHandShowCardsMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7474,13 +8002,13 @@ class AfterHandShowCardsMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7501,11 +8029,11 @@ class AfterHandShowCardsMessage : public ::google::protobuf::MessageLite { inline void set_has_playerresult(); inline void clear_has_playerresult(); - ::PlayerResult* playerresult_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::PlayerResult* playerresult_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7531,6 +8059,14 @@ class EndOfGameMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const EndOfGameMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7559,13 +8095,13 @@ class EndOfGameMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7584,11 +8120,11 @@ class EndOfGameMessage : public ::google::protobuf::MessageLite { inline void set_has_winnerplayerid(); inline void clear_has_winnerplayerid(); - ::google::protobuf::uint32 winnerplayerid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 winnerplayerid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7614,6 +8150,14 @@ class PlayerIdChangedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PlayerIdChangedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7642,13 +8186,13 @@ class PlayerIdChangedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7676,12 +8220,12 @@ class PlayerIdChangedMessage : public ::google::protobuf::MessageLite { inline void set_has_newplayerid(); inline void clear_has_newplayerid(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 oldplayerid_; ::google::protobuf::uint32 newplayerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7707,6 +8251,14 @@ class AskKickPlayerMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AskKickPlayerMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7735,13 +8287,13 @@ class AskKickPlayerMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7760,11 +8312,11 @@ class AskKickPlayerMessage : public ::google::protobuf::MessageLite { inline void set_has_playerid(); inline void clear_has_playerid(); - ::google::protobuf::uint32 playerid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 playerid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7790,6 +8342,14 @@ class AskKickDeniedMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AskKickDeniedMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7818,13 +8378,13 @@ class AskKickDeniedMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7868,12 +8428,12 @@ class AskKickDeniedMessage : public ::google::protobuf::MessageLite { inline void set_has_kickdeniedreason(); inline void clear_has_kickdeniedreason(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; int kickdeniedreason_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -7899,6 +8459,14 @@ class StartKickPetitionMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const StartKickPetitionMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -7927,13 +8495,13 @@ class StartKickPetitionMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -7988,15 +8556,15 @@ class StartKickPetitionMessage : public ::google::protobuf::MessageLite { inline void set_has_numvotesneededtokick(); inline void clear_has_numvotesneededtokick(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 petitionid_; ::google::protobuf::uint32 proposingplayerid_; ::google::protobuf::uint32 kickplayerid_; ::google::protobuf::uint32 kicktimeoutsec_; ::google::protobuf::uint32 numvotesneededtokick_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8022,6 +8590,14 @@ class VoteKickRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const VoteKickRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8050,13 +8626,13 @@ class VoteKickRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -8084,12 +8660,12 @@ class VoteKickRequestMessage : public ::google::protobuf::MessageLite { inline void set_has_votekick(); inline void clear_has_votekick(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 petitionid_; bool votekick_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8115,6 +8691,14 @@ class VoteKickReplyMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const VoteKickReplyMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8143,13 +8727,13 @@ class VoteKickReplyMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -8191,12 +8775,12 @@ class VoteKickReplyMessage : public ::google::protobuf::MessageLite { inline void set_has_votekickreplytype(); inline void clear_has_votekickreplytype(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 petitionid_; int votekickreplytype_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8222,6 +8806,14 @@ class KickPetitionUpdateMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const KickPetitionUpdateMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8250,13 +8842,13 @@ class KickPetitionUpdateMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -8302,14 +8894,14 @@ class KickPetitionUpdateMessage : public ::google::protobuf::MessageLite { inline void set_has_numvotesneededtokick(); inline void clear_has_numvotesneededtokick(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 petitionid_; ::google::protobuf::uint32 numvotesagainstkicking_; ::google::protobuf::uint32 numvotesinfavourofkicking_; ::google::protobuf::uint32 numvotesneededtokick_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8335,6 +8927,14 @@ class EndKickPetitionMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const EndKickPetitionMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8363,13 +8963,13 @@ class EndKickPetitionMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -8439,15 +9039,15 @@ class EndKickPetitionMessage : public ::google::protobuf::MessageLite { inline void set_has_petitionendreason(); inline void clear_has_petitionendreason(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 petitionid_; ::google::protobuf::uint32 numvotesagainstkicking_; ::google::protobuf::uint32 numvotesinfavourofkicking_; ::google::protobuf::uint32 resultplayerkicked_; int petitionendreason_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8473,6 +9073,14 @@ class StatisticsMessage_StatisticsData : public ::google::protobuf::MessageLite return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const StatisticsMessage_StatisticsData& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8501,13 +9109,13 @@ class StatisticsMessage_StatisticsData : public ::google::protobuf::MessageLite ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -8547,12 +9155,12 @@ class StatisticsMessage_StatisticsData : public ::google::protobuf::MessageLite inline void set_has_statisticsvalue(); inline void clear_has_statisticsvalue(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; int statisticstype_; ::google::protobuf::uint32 statisticsvalue_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8578,6 +9186,14 @@ class StatisticsMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const StatisticsMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8606,13 +9222,13 @@ class StatisticsMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -8636,11 +9252,11 @@ class StatisticsMessage : public ::google::protobuf::MessageLite { // @@protoc_insertion_point(class_scope:StatisticsMessage) private: - ::google::protobuf::RepeatedPtrField< ::StatisticsMessage_StatisticsData > statisticsdata_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::RepeatedPtrField< ::StatisticsMessage_StatisticsData > statisticsdata_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8666,6 +9282,14 @@ class ChatRequestMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ChatRequestMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8694,13 +9318,13 @@ class ChatRequestMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -8733,12 +9357,12 @@ class ChatRequestMessage : public ::google::protobuf::MessageLite { inline void set_has_chattext(); inline void clear_has_chattext(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::std::string* chattext_; ::google::protobuf::uint32 targetplayerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8764,6 +9388,14 @@ class ChatMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ChatMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8792,13 +9424,13 @@ class ChatMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -8855,13 +9487,13 @@ class ChatMessage : public ::google::protobuf::MessageLite { inline void set_has_chattext(); inline void clear_has_chattext(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 playerid_; int chattype_; ::std::string* chattext_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8887,6 +9519,14 @@ class ChatRejectMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ChatRejectMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -8915,13 +9555,13 @@ class ChatRejectMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -8945,11 +9585,11 @@ class ChatRejectMessage : public ::google::protobuf::MessageLite { inline void set_has_chattext(); inline void clear_has_chattext(); - ::std::string* chattext_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::std::string* chattext_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -8975,6 +9615,14 @@ class DialogMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const DialogMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9003,13 +9651,13 @@ class DialogMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9033,11 +9681,11 @@ class DialogMessage : public ::google::protobuf::MessageLite { inline void set_has_notificationtext(); inline void clear_has_notificationtext(); - ::std::string* notificationtext_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::std::string* notificationtext_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9063,6 +9711,14 @@ class TimeoutWarningMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const TimeoutWarningMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9091,13 +9747,13 @@ class TimeoutWarningMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9139,12 +9795,12 @@ class TimeoutWarningMessage : public ::google::protobuf::MessageLite { inline void set_has_remainingseconds(); inline void clear_has_remainingseconds(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; int timeoutreason_; ::google::protobuf::uint32 remainingseconds_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9170,6 +9826,14 @@ class ResetTimeoutMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ResetTimeoutMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9198,13 +9862,13 @@ class ResetTimeoutMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9214,10 +9878,10 @@ class ResetTimeoutMessage : public ::google::protobuf::MessageLite { // @@protoc_insertion_point(class_scope:ResetTimeoutMessage) private: + ::std::string _unknown_fields_; - mutable int _cached_size_; ::google::protobuf::uint32 _has_bits_[1]; - + mutable int _cached_size_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9243,6 +9907,14 @@ class ReportAvatarMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ReportAvatarMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9271,13 +9943,13 @@ class ReportAvatarMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9310,12 +9982,12 @@ class ReportAvatarMessage : public ::google::protobuf::MessageLite { inline void set_has_reportedavatarhash(); inline void clear_has_reportedavatarhash(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::std::string* reportedavatarhash_; ::google::protobuf::uint32 reportedplayerid_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9341,6 +10013,14 @@ class ReportAvatarAckMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ReportAvatarAckMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9369,13 +10049,13 @@ class ReportAvatarAckMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9417,12 +10097,12 @@ class ReportAvatarAckMessage : public ::google::protobuf::MessageLite { inline void set_has_reportavatarresult(); inline void clear_has_reportavatarresult(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 reportedplayerid_; int reportavatarresult_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9448,6 +10128,14 @@ class ReportGameMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ReportGameMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9476,13 +10164,13 @@ class ReportGameMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9501,11 +10189,11 @@ class ReportGameMessage : public ::google::protobuf::MessageLite { inline void set_has_reportedgameid(); inline void clear_has_reportedgameid(); - ::google::protobuf::uint32 reportedgameid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 reportedgameid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9531,6 +10219,14 @@ class ReportGameAckMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ReportGameAckMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9559,13 +10255,13 @@ class ReportGameAckMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9607,12 +10303,12 @@ class ReportGameAckMessage : public ::google::protobuf::MessageLite { inline void set_has_reportgameresult(); inline void clear_has_reportgameresult(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 reportedgameid_; int reportgameresult_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9638,6 +10334,14 @@ class ErrorMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const ErrorMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9666,13 +10370,13 @@ class ErrorMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9717,11 +10421,11 @@ class ErrorMessage : public ::google::protobuf::MessageLite { inline void set_has_errorreason(); inline void clear_has_errorreason(); - int errorreason_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + int errorreason_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9747,6 +10451,14 @@ class AdminRemoveGameMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AdminRemoveGameMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9775,13 +10487,13 @@ class AdminRemoveGameMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9800,11 +10512,11 @@ class AdminRemoveGameMessage : public ::google::protobuf::MessageLite { inline void set_has_removegameid(); inline void clear_has_removegameid(); - ::google::protobuf::uint32 removegameid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 removegameid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9830,6 +10542,14 @@ class AdminRemoveGameAckMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AdminRemoveGameAckMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9858,13 +10578,13 @@ class AdminRemoveGameAckMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9905,12 +10625,12 @@ class AdminRemoveGameAckMessage : public ::google::protobuf::MessageLite { inline void set_has_removegameresult(); inline void clear_has_removegameresult(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 removegameid_; int removegameresult_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -9936,6 +10656,14 @@ class AdminBanPlayerMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AdminBanPlayerMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -9964,13 +10692,13 @@ class AdminBanPlayerMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -9989,11 +10717,11 @@ class AdminBanPlayerMessage : public ::google::protobuf::MessageLite { inline void set_has_banplayerid(); inline void clear_has_banplayerid(); - ::google::protobuf::uint32 banplayerid_; + ::std::string _unknown_fields_; + ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; - + ::google::protobuf::uint32 banplayerid_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -10019,6 +10747,14 @@ class AdminBanPlayerAckMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AdminBanPlayerAckMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -10047,13 +10783,13 @@ class AdminBanPlayerAckMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -10097,12 +10833,12 @@ class AdminBanPlayerAckMessage : public ::google::protobuf::MessageLite { inline void set_has_banplayerresult(); inline void clear_has_banplayerresult(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::google::protobuf::uint32 banplayerid_; int banplayerresult_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -10128,6 +10864,14 @@ class AuthMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const AuthMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -10156,13 +10900,13 @@ class AuthMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -10252,16 +10996,16 @@ class AuthMessage : public ::google::protobuf::MessageLite { inline void set_has_errormessage(); inline void clear_has_errormessage(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::AuthClientRequestMessage* authclientrequestmessage_; ::AuthServerChallengeMessage* authserverchallengemessage_; ::AuthClientResponseMessage* authclientresponsemessage_; ::AuthServerVerificationMessage* authserververificationmessage_; ::ErrorMessage* errormessage_; int messagetype_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -10287,6 +11031,14 @@ class LobbyMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const LobbyMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -10315,13 +11067,13 @@ class LobbyMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -10867,6 +11619,9 @@ class LobbyMessage : public ::google::protobuf::MessageLite { inline void set_has_errormessage(); inline void clear_has_errormessage(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[2]; ::InitDoneMessage* initdonemessage_; ::AvatarRequestMessage* avatarrequestmessage_; ::AvatarHeaderMessage* avatarheadermessage_; @@ -10911,10 +11666,7 @@ class LobbyMessage : public ::google::protobuf::MessageLite { ::AdminBanPlayerAckMessage* adminbanplayerackmessage_; ::ErrorMessage* errormessage_; int messagetype_; - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(44 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -10940,6 +11692,14 @@ class GameManagementMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameManagementMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -10968,13 +11728,13 @@ class GameManagementMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -11340,6 +12100,10 @@ class GameManagementMessage : public ::google::protobuf::MessageLite { inline void set_has_errormessage(); inline void clear_has_errormessage(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::GamePlayerJoinedMessage* gameplayerjoinedmessage_; ::GamePlayerLeftMessage* gameplayerleftmessage_; ::GameSpectatorJoinedMessage* gamespectatorjoinedmessage_; @@ -11369,10 +12133,6 @@ class GameManagementMessage : public ::google::protobuf::MessageLite { ::ResetTimeoutMessage* resettimeoutmessage_; ::ErrorMessage* errormessage_; int messagetype_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(29 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -11398,6 +12158,14 @@ class GameEngineMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameEngineMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -11426,13 +12194,13 @@ class GameEngineMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -11618,6 +12386,10 @@ class GameEngineMessage : public ::google::protobuf::MessageLite { inline void set_has_afterhandshowcardsmessage(); inline void clear_has_afterhandshowcardsmessage(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::HandStartMessage* handstartmessage_; ::PlayersTurnMessage* playersturnmessage_; ::MyActionRequestMessage* myactionrequestmessage_; @@ -11632,10 +12404,6 @@ class GameEngineMessage : public ::google::protobuf::MessageLite { ::ShowMyCardsRequestMessage* showmycardsrequestmessage_; ::AfterHandShowCardsMessage* afterhandshowcardsmessage_; int messagetype_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(14 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -11661,6 +12429,14 @@ class GameMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const GameMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -11689,13 +12465,13 @@ class GameMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -11758,14 +12534,14 @@ class GameMessage : public ::google::protobuf::MessageLite { inline void set_has_gameenginemessage(); inline void clear_has_gameenginemessage(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; int messagetype_; ::google::protobuf::uint32 gameid_; ::GameManagementMessage* gamemanagementmessage_; ::GameEngineMessage* gameenginemessage_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -11791,6 +12567,14 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { return *this; } + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + static const PokerTHMessage& default_instance(); #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER @@ -11819,13 +12603,13 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { ::google::protobuf::io::CodedInputStream* input); void SerializeWithCachedSizes( ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); int GetCachedSize() const { return _cached_size_; } private: void SharedCtor(); void SharedDtor(); void SetCachedSize(int size) const; public: - ::std::string GetTypeName() const; // nested types ---------------------------------------------------- @@ -11903,15 +12687,15 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { inline void set_has_gamemessage(); inline void clear_has_gamemessage(); + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; ::AnnounceMessage* announcemessage_; ::AuthMessage* authmessage_; ::LobbyMessage* lobbymessage_; ::GameMessage* gamemessage_; int messagetype_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; - #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); #else @@ -11941,54 +12725,59 @@ inline void NetGameInfo::clear_has_gamename() { _has_bits_[0] &= ~0x00000001u; } inline void NetGameInfo::clear_gamename() { - if (gamename_ != &::google::protobuf::internal::kEmptyString) { + if (gamename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { gamename_->clear(); } clear_has_gamename(); } inline const ::std::string& NetGameInfo::gamename() const { + // @@protoc_insertion_point(field_get:NetGameInfo.gameName) return *gamename_; } inline void NetGameInfo::set_gamename(const ::std::string& value) { set_has_gamename(); - if (gamename_ == &::google::protobuf::internal::kEmptyString) { + if (gamename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { gamename_ = new ::std::string; } gamename_->assign(value); + // @@protoc_insertion_point(field_set:NetGameInfo.gameName) } inline void NetGameInfo::set_gamename(const char* value) { set_has_gamename(); - if (gamename_ == &::google::protobuf::internal::kEmptyString) { + if (gamename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { gamename_ = new ::std::string; } gamename_->assign(value); + // @@protoc_insertion_point(field_set_char:NetGameInfo.gameName) } inline void NetGameInfo::set_gamename(const char* value, size_t size) { set_has_gamename(); - if (gamename_ == &::google::protobuf::internal::kEmptyString) { + if (gamename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { gamename_ = new ::std::string; } gamename_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:NetGameInfo.gameName) } inline ::std::string* NetGameInfo::mutable_gamename() { set_has_gamename(); - if (gamename_ == &::google::protobuf::internal::kEmptyString) { + if (gamename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { gamename_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:NetGameInfo.gameName) return gamename_; } inline ::std::string* NetGameInfo::release_gamename() { clear_has_gamename(); - if (gamename_ == &::google::protobuf::internal::kEmptyString) { + if (gamename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = gamename_; - gamename_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + gamename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void NetGameInfo::set_allocated_gamename(::std::string* gamename) { - if (gamename_ != &::google::protobuf::internal::kEmptyString) { + if (gamename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete gamename_; } if (gamename) { @@ -11996,8 +12785,9 @@ inline void NetGameInfo::set_allocated_gamename(::std::string* gamename) { gamename_ = gamename; } else { clear_has_gamename(); - gamename_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + gamename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:NetGameInfo.gameName) } // required .NetGameInfo.NetGameType netGameType = 2; @@ -12015,12 +12805,14 @@ inline void NetGameInfo::clear_netgametype() { clear_has_netgametype(); } inline ::NetGameInfo_NetGameType NetGameInfo::netgametype() const { + // @@protoc_insertion_point(field_get:NetGameInfo.netGameType) return static_cast< ::NetGameInfo_NetGameType >(netgametype_); } inline void NetGameInfo::set_netgametype(::NetGameInfo_NetGameType value) { assert(::NetGameInfo_NetGameType_IsValid(value)); set_has_netgametype(); netgametype_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.netGameType) } // required uint32 maxNumPlayers = 3; @@ -12038,11 +12830,13 @@ inline void NetGameInfo::clear_maxnumplayers() { clear_has_maxnumplayers(); } inline ::google::protobuf::uint32 NetGameInfo::maxnumplayers() const { + // @@protoc_insertion_point(field_get:NetGameInfo.maxNumPlayers) return maxnumplayers_; } inline void NetGameInfo::set_maxnumplayers(::google::protobuf::uint32 value) { set_has_maxnumplayers(); maxnumplayers_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.maxNumPlayers) } // required .NetGameInfo.RaiseIntervalMode raiseIntervalMode = 4; @@ -12060,12 +12854,14 @@ inline void NetGameInfo::clear_raiseintervalmode() { clear_has_raiseintervalmode(); } inline ::NetGameInfo_RaiseIntervalMode NetGameInfo::raiseintervalmode() const { + // @@protoc_insertion_point(field_get:NetGameInfo.raiseIntervalMode) return static_cast< ::NetGameInfo_RaiseIntervalMode >(raiseintervalmode_); } inline void NetGameInfo::set_raiseintervalmode(::NetGameInfo_RaiseIntervalMode value) { assert(::NetGameInfo_RaiseIntervalMode_IsValid(value)); set_has_raiseintervalmode(); raiseintervalmode_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.raiseIntervalMode) } // optional uint32 raiseEveryHands = 5; @@ -12083,11 +12879,13 @@ inline void NetGameInfo::clear_raiseeveryhands() { clear_has_raiseeveryhands(); } inline ::google::protobuf::uint32 NetGameInfo::raiseeveryhands() const { + // @@protoc_insertion_point(field_get:NetGameInfo.raiseEveryHands) return raiseeveryhands_; } inline void NetGameInfo::set_raiseeveryhands(::google::protobuf::uint32 value) { set_has_raiseeveryhands(); raiseeveryhands_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.raiseEveryHands) } // optional uint32 raiseEveryMinutes = 6; @@ -12105,11 +12903,13 @@ inline void NetGameInfo::clear_raiseeveryminutes() { clear_has_raiseeveryminutes(); } inline ::google::protobuf::uint32 NetGameInfo::raiseeveryminutes() const { + // @@protoc_insertion_point(field_get:NetGameInfo.raiseEveryMinutes) return raiseeveryminutes_; } inline void NetGameInfo::set_raiseeveryminutes(::google::protobuf::uint32 value) { set_has_raiseeveryminutes(); raiseeveryminutes_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.raiseEveryMinutes) } // required .NetGameInfo.EndRaiseMode endRaiseMode = 7; @@ -12127,12 +12927,14 @@ inline void NetGameInfo::clear_endraisemode() { clear_has_endraisemode(); } inline ::NetGameInfo_EndRaiseMode NetGameInfo::endraisemode() const { + // @@protoc_insertion_point(field_get:NetGameInfo.endRaiseMode) return static_cast< ::NetGameInfo_EndRaiseMode >(endraisemode_); } inline void NetGameInfo::set_endraisemode(::NetGameInfo_EndRaiseMode value) { assert(::NetGameInfo_EndRaiseMode_IsValid(value)); set_has_endraisemode(); endraisemode_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.endRaiseMode) } // optional uint32 endRaiseSmallBlindValue = 8; @@ -12150,11 +12952,13 @@ inline void NetGameInfo::clear_endraisesmallblindvalue() { clear_has_endraisesmallblindvalue(); } inline ::google::protobuf::uint32 NetGameInfo::endraisesmallblindvalue() const { + // @@protoc_insertion_point(field_get:NetGameInfo.endRaiseSmallBlindValue) return endraisesmallblindvalue_; } inline void NetGameInfo::set_endraisesmallblindvalue(::google::protobuf::uint32 value) { set_has_endraisesmallblindvalue(); endraisesmallblindvalue_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.endRaiseSmallBlindValue) } // required uint32 proposedGuiSpeed = 9; @@ -12172,11 +12976,13 @@ inline void NetGameInfo::clear_proposedguispeed() { clear_has_proposedguispeed(); } inline ::google::protobuf::uint32 NetGameInfo::proposedguispeed() const { + // @@protoc_insertion_point(field_get:NetGameInfo.proposedGuiSpeed) return proposedguispeed_; } inline void NetGameInfo::set_proposedguispeed(::google::protobuf::uint32 value) { set_has_proposedguispeed(); proposedguispeed_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.proposedGuiSpeed) } // required uint32 delayBetweenHands = 10; @@ -12194,11 +13000,13 @@ inline void NetGameInfo::clear_delaybetweenhands() { clear_has_delaybetweenhands(); } inline ::google::protobuf::uint32 NetGameInfo::delaybetweenhands() const { + // @@protoc_insertion_point(field_get:NetGameInfo.delayBetweenHands) return delaybetweenhands_; } inline void NetGameInfo::set_delaybetweenhands(::google::protobuf::uint32 value) { set_has_delaybetweenhands(); delaybetweenhands_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.delayBetweenHands) } // required uint32 playerActionTimeout = 11; @@ -12216,11 +13024,13 @@ inline void NetGameInfo::clear_playeractiontimeout() { clear_has_playeractiontimeout(); } inline ::google::protobuf::uint32 NetGameInfo::playeractiontimeout() const { + // @@protoc_insertion_point(field_get:NetGameInfo.playerActionTimeout) return playeractiontimeout_; } inline void NetGameInfo::set_playeractiontimeout(::google::protobuf::uint32 value) { set_has_playeractiontimeout(); playeractiontimeout_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.playerActionTimeout) } // required uint32 firstSmallBlind = 12; @@ -12238,11 +13048,13 @@ inline void NetGameInfo::clear_firstsmallblind() { clear_has_firstsmallblind(); } inline ::google::protobuf::uint32 NetGameInfo::firstsmallblind() const { + // @@protoc_insertion_point(field_get:NetGameInfo.firstSmallBlind) return firstsmallblind_; } inline void NetGameInfo::set_firstsmallblind(::google::protobuf::uint32 value) { set_has_firstsmallblind(); firstsmallblind_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.firstSmallBlind) } // required uint32 startMoney = 13; @@ -12260,11 +13072,13 @@ inline void NetGameInfo::clear_startmoney() { clear_has_startmoney(); } inline ::google::protobuf::uint32 NetGameInfo::startmoney() const { + // @@protoc_insertion_point(field_get:NetGameInfo.startMoney) return startmoney_; } inline void NetGameInfo::set_startmoney(::google::protobuf::uint32 value) { set_has_startmoney(); startmoney_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.startMoney) } // repeated uint32 manualBlinds = 14 [packed = true]; @@ -12275,20 +13089,25 @@ inline void NetGameInfo::clear_manualblinds() { manualblinds_.Clear(); } inline ::google::protobuf::uint32 NetGameInfo::manualblinds(int index) const { + // @@protoc_insertion_point(field_get:NetGameInfo.manualBlinds) return manualblinds_.Get(index); } inline void NetGameInfo::set_manualblinds(int index, ::google::protobuf::uint32 value) { manualblinds_.Set(index, value); + // @@protoc_insertion_point(field_set:NetGameInfo.manualBlinds) } inline void NetGameInfo::add_manualblinds(::google::protobuf::uint32 value) { manualblinds_.Add(value); + // @@protoc_insertion_point(field_add:NetGameInfo.manualBlinds) } inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& NetGameInfo::manualblinds() const { + // @@protoc_insertion_point(field_list:NetGameInfo.manualBlinds) return manualblinds_; } inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* NetGameInfo::mutable_manualblinds() { + // @@protoc_insertion_point(field_mutable_list:NetGameInfo.manualBlinds) return &manualblinds_; } @@ -12307,11 +13126,13 @@ inline void NetGameInfo::clear_allowspectators() { clear_has_allowspectators(); } inline bool NetGameInfo::allowspectators() const { + // @@protoc_insertion_point(field_get:NetGameInfo.allowSpectators) return allowspectators_; } inline void NetGameInfo::set_allowspectators(bool value) { set_has_allowspectators(); allowspectators_ = value; + // @@protoc_insertion_point(field_set:NetGameInfo.allowSpectators) } // ------------------------------------------------------------------- @@ -12333,11 +13154,13 @@ inline void PlayerResult::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 PlayerResult::playerid() const { + // @@protoc_insertion_point(field_get:PlayerResult.playerId) return playerid_; } inline void PlayerResult::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:PlayerResult.playerId) } // required uint32 resultCard1 = 2; @@ -12355,11 +13178,13 @@ inline void PlayerResult::clear_resultcard1() { clear_has_resultcard1(); } inline ::google::protobuf::uint32 PlayerResult::resultcard1() const { + // @@protoc_insertion_point(field_get:PlayerResult.resultCard1) return resultcard1_; } inline void PlayerResult::set_resultcard1(::google::protobuf::uint32 value) { set_has_resultcard1(); resultcard1_ = value; + // @@protoc_insertion_point(field_set:PlayerResult.resultCard1) } // required uint32 resultCard2 = 3; @@ -12377,11 +13202,13 @@ inline void PlayerResult::clear_resultcard2() { clear_has_resultcard2(); } inline ::google::protobuf::uint32 PlayerResult::resultcard2() const { + // @@protoc_insertion_point(field_get:PlayerResult.resultCard2) return resultcard2_; } inline void PlayerResult::set_resultcard2(::google::protobuf::uint32 value) { set_has_resultcard2(); resultcard2_ = value; + // @@protoc_insertion_point(field_set:PlayerResult.resultCard2) } // repeated uint32 bestHandPosition = 4 [packed = true]; @@ -12392,20 +13219,25 @@ inline void PlayerResult::clear_besthandposition() { besthandposition_.Clear(); } inline ::google::protobuf::uint32 PlayerResult::besthandposition(int index) const { + // @@protoc_insertion_point(field_get:PlayerResult.bestHandPosition) return besthandposition_.Get(index); } inline void PlayerResult::set_besthandposition(int index, ::google::protobuf::uint32 value) { besthandposition_.Set(index, value); + // @@protoc_insertion_point(field_set:PlayerResult.bestHandPosition) } inline void PlayerResult::add_besthandposition(::google::protobuf::uint32 value) { besthandposition_.Add(value); + // @@protoc_insertion_point(field_add:PlayerResult.bestHandPosition) } inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& PlayerResult::besthandposition() const { + // @@protoc_insertion_point(field_list:PlayerResult.bestHandPosition) return besthandposition_; } inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* PlayerResult::mutable_besthandposition() { + // @@protoc_insertion_point(field_mutable_list:PlayerResult.bestHandPosition) return &besthandposition_; } @@ -12424,11 +13256,13 @@ inline void PlayerResult::clear_moneywon() { clear_has_moneywon(); } inline ::google::protobuf::uint32 PlayerResult::moneywon() const { + // @@protoc_insertion_point(field_get:PlayerResult.moneyWon) return moneywon_; } inline void PlayerResult::set_moneywon(::google::protobuf::uint32 value) { set_has_moneywon(); moneywon_ = value; + // @@protoc_insertion_point(field_set:PlayerResult.moneyWon) } // required uint32 playerMoney = 6; @@ -12446,11 +13280,13 @@ inline void PlayerResult::clear_playermoney() { clear_has_playermoney(); } inline ::google::protobuf::uint32 PlayerResult::playermoney() const { + // @@protoc_insertion_point(field_get:PlayerResult.playerMoney) return playermoney_; } inline void PlayerResult::set_playermoney(::google::protobuf::uint32 value) { set_has_playermoney(); playermoney_ = value; + // @@protoc_insertion_point(field_set:PlayerResult.playerMoney) } // optional uint32 cardsValue = 7; @@ -12468,11 +13304,13 @@ inline void PlayerResult::clear_cardsvalue() { clear_has_cardsvalue(); } inline ::google::protobuf::uint32 PlayerResult::cardsvalue() const { + // @@protoc_insertion_point(field_get:PlayerResult.cardsValue) return cardsvalue_; } inline void PlayerResult::set_cardsvalue(::google::protobuf::uint32 value) { set_has_cardsvalue(); cardsvalue_ = value; + // @@protoc_insertion_point(field_set:PlayerResult.cardsValue) } // ------------------------------------------------------------------- @@ -12494,11 +13332,13 @@ inline void AnnounceMessage_Version::clear_majorversion() { clear_has_majorversion(); } inline ::google::protobuf::uint32 AnnounceMessage_Version::majorversion() const { + // @@protoc_insertion_point(field_get:AnnounceMessage.Version.majorVersion) return majorversion_; } inline void AnnounceMessage_Version::set_majorversion(::google::protobuf::uint32 value) { set_has_majorversion(); majorversion_ = value; + // @@protoc_insertion_point(field_set:AnnounceMessage.Version.majorVersion) } // required uint32 minorVersion = 2; @@ -12516,11 +13356,13 @@ inline void AnnounceMessage_Version::clear_minorversion() { clear_has_minorversion(); } inline ::google::protobuf::uint32 AnnounceMessage_Version::minorversion() const { + // @@protoc_insertion_point(field_get:AnnounceMessage.Version.minorVersion) return minorversion_; } inline void AnnounceMessage_Version::set_minorversion(::google::protobuf::uint32 value) { set_has_minorversion(); minorversion_ = value; + // @@protoc_insertion_point(field_set:AnnounceMessage.Version.minorVersion) } // ------------------------------------------------------------------- @@ -12542,6 +13384,7 @@ inline void AnnounceMessage::clear_protocolversion() { clear_has_protocolversion(); } inline const ::AnnounceMessage_Version& AnnounceMessage::protocolversion() const { + // @@protoc_insertion_point(field_get:AnnounceMessage.protocolVersion) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return protocolversion_ != NULL ? *protocolversion_ : *default_instance().protocolversion_; #else @@ -12551,6 +13394,7 @@ inline const ::AnnounceMessage_Version& AnnounceMessage::protocolversion() const inline ::AnnounceMessage_Version* AnnounceMessage::mutable_protocolversion() { set_has_protocolversion(); if (protocolversion_ == NULL) protocolversion_ = new ::AnnounceMessage_Version; + // @@protoc_insertion_point(field_mutable:AnnounceMessage.protocolVersion) return protocolversion_; } inline ::AnnounceMessage_Version* AnnounceMessage::release_protocolversion() { @@ -12567,6 +13411,7 @@ inline void AnnounceMessage::set_allocated_protocolversion(::AnnounceMessage_Ver } else { clear_has_protocolversion(); } + // @@protoc_insertion_point(field_set_allocated:AnnounceMessage.protocolVersion) } // required .AnnounceMessage.Version latestGameVersion = 2; @@ -12584,6 +13429,7 @@ inline void AnnounceMessage::clear_latestgameversion() { clear_has_latestgameversion(); } inline const ::AnnounceMessage_Version& AnnounceMessage::latestgameversion() const { + // @@protoc_insertion_point(field_get:AnnounceMessage.latestGameVersion) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return latestgameversion_ != NULL ? *latestgameversion_ : *default_instance().latestgameversion_; #else @@ -12593,6 +13439,7 @@ inline const ::AnnounceMessage_Version& AnnounceMessage::latestgameversion() con inline ::AnnounceMessage_Version* AnnounceMessage::mutable_latestgameversion() { set_has_latestgameversion(); if (latestgameversion_ == NULL) latestgameversion_ = new ::AnnounceMessage_Version; + // @@protoc_insertion_point(field_mutable:AnnounceMessage.latestGameVersion) return latestgameversion_; } inline ::AnnounceMessage_Version* AnnounceMessage::release_latestgameversion() { @@ -12609,6 +13456,7 @@ inline void AnnounceMessage::set_allocated_latestgameversion(::AnnounceMessage_V } else { clear_has_latestgameversion(); } + // @@protoc_insertion_point(field_set_allocated:AnnounceMessage.latestGameVersion) } // required uint32 latestBetaRevision = 3; @@ -12626,11 +13474,13 @@ inline void AnnounceMessage::clear_latestbetarevision() { clear_has_latestbetarevision(); } inline ::google::protobuf::uint32 AnnounceMessage::latestbetarevision() const { + // @@protoc_insertion_point(field_get:AnnounceMessage.latestBetaRevision) return latestbetarevision_; } inline void AnnounceMessage::set_latestbetarevision(::google::protobuf::uint32 value) { set_has_latestbetarevision(); latestbetarevision_ = value; + // @@protoc_insertion_point(field_set:AnnounceMessage.latestBetaRevision) } // required .AnnounceMessage.ServerType serverType = 4; @@ -12648,12 +13498,14 @@ inline void AnnounceMessage::clear_servertype() { clear_has_servertype(); } inline ::AnnounceMessage_ServerType AnnounceMessage::servertype() const { + // @@protoc_insertion_point(field_get:AnnounceMessage.serverType) return static_cast< ::AnnounceMessage_ServerType >(servertype_); } inline void AnnounceMessage::set_servertype(::AnnounceMessage_ServerType value) { assert(::AnnounceMessage_ServerType_IsValid(value)); set_has_servertype(); servertype_ = value; + // @@protoc_insertion_point(field_set:AnnounceMessage.serverType) } // required uint32 numPlayersOnServer = 5; @@ -12671,11 +13523,13 @@ inline void AnnounceMessage::clear_numplayersonserver() { clear_has_numplayersonserver(); } inline ::google::protobuf::uint32 AnnounceMessage::numplayersonserver() const { + // @@protoc_insertion_point(field_get:AnnounceMessage.numPlayersOnServer) return numplayersonserver_; } inline void AnnounceMessage::set_numplayersonserver(::google::protobuf::uint32 value) { set_has_numplayersonserver(); numplayersonserver_ = value; + // @@protoc_insertion_point(field_set:AnnounceMessage.numPlayersOnServer) } // ------------------------------------------------------------------- @@ -12697,6 +13551,7 @@ inline void AuthClientRequestMessage::clear_requestedversion() { clear_has_requestedversion(); } inline const ::AnnounceMessage_Version& AuthClientRequestMessage::requestedversion() const { + // @@protoc_insertion_point(field_get:AuthClientRequestMessage.requestedVersion) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return requestedversion_ != NULL ? *requestedversion_ : *default_instance().requestedversion_; #else @@ -12706,6 +13561,7 @@ inline const ::AnnounceMessage_Version& AuthClientRequestMessage::requestedversi inline ::AnnounceMessage_Version* AuthClientRequestMessage::mutable_requestedversion() { set_has_requestedversion(); if (requestedversion_ == NULL) requestedversion_ = new ::AnnounceMessage_Version; + // @@protoc_insertion_point(field_mutable:AuthClientRequestMessage.requestedVersion) return requestedversion_; } inline ::AnnounceMessage_Version* AuthClientRequestMessage::release_requestedversion() { @@ -12722,6 +13578,7 @@ inline void AuthClientRequestMessage::set_allocated_requestedversion(::AnnounceM } else { clear_has_requestedversion(); } + // @@protoc_insertion_point(field_set_allocated:AuthClientRequestMessage.requestedVersion) } // required uint32 buildId = 2; @@ -12739,11 +13596,13 @@ inline void AuthClientRequestMessage::clear_buildid() { clear_has_buildid(); } inline ::google::protobuf::uint32 AuthClientRequestMessage::buildid() const { + // @@protoc_insertion_point(field_get:AuthClientRequestMessage.buildId) return buildid_; } inline void AuthClientRequestMessage::set_buildid(::google::protobuf::uint32 value) { set_has_buildid(); buildid_ = value; + // @@protoc_insertion_point(field_set:AuthClientRequestMessage.buildId) } // required .AuthClientRequestMessage.LoginType login = 3; @@ -12761,12 +13620,14 @@ inline void AuthClientRequestMessage::clear_login() { clear_has_login(); } inline ::AuthClientRequestMessage_LoginType AuthClientRequestMessage::login() const { + // @@protoc_insertion_point(field_get:AuthClientRequestMessage.login) return static_cast< ::AuthClientRequestMessage_LoginType >(login_); } inline void AuthClientRequestMessage::set_login(::AuthClientRequestMessage_LoginType value) { assert(::AuthClientRequestMessage_LoginType_IsValid(value)); set_has_login(); login_ = value; + // @@protoc_insertion_point(field_set:AuthClientRequestMessage.login) } // optional string authServerPassword = 4; @@ -12780,54 +13641,59 @@ inline void AuthClientRequestMessage::clear_has_authserverpassword() { _has_bits_[0] &= ~0x00000008u; } inline void AuthClientRequestMessage::clear_authserverpassword() { - if (authserverpassword_ != &::google::protobuf::internal::kEmptyString) { + if (authserverpassword_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { authserverpassword_->clear(); } clear_has_authserverpassword(); } inline const ::std::string& AuthClientRequestMessage::authserverpassword() const { + // @@protoc_insertion_point(field_get:AuthClientRequestMessage.authServerPassword) return *authserverpassword_; } inline void AuthClientRequestMessage::set_authserverpassword(const ::std::string& value) { set_has_authserverpassword(); - if (authserverpassword_ == &::google::protobuf::internal::kEmptyString) { + if (authserverpassword_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { authserverpassword_ = new ::std::string; } authserverpassword_->assign(value); + // @@protoc_insertion_point(field_set:AuthClientRequestMessage.authServerPassword) } inline void AuthClientRequestMessage::set_authserverpassword(const char* value) { set_has_authserverpassword(); - if (authserverpassword_ == &::google::protobuf::internal::kEmptyString) { + if (authserverpassword_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { authserverpassword_ = new ::std::string; } authserverpassword_->assign(value); + // @@protoc_insertion_point(field_set_char:AuthClientRequestMessage.authServerPassword) } inline void AuthClientRequestMessage::set_authserverpassword(const char* value, size_t size) { set_has_authserverpassword(); - if (authserverpassword_ == &::google::protobuf::internal::kEmptyString) { + if (authserverpassword_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { authserverpassword_ = new ::std::string; } authserverpassword_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AuthClientRequestMessage.authServerPassword) } inline ::std::string* AuthClientRequestMessage::mutable_authserverpassword() { set_has_authserverpassword(); - if (authserverpassword_ == &::google::protobuf::internal::kEmptyString) { + if (authserverpassword_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { authserverpassword_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AuthClientRequestMessage.authServerPassword) return authserverpassword_; } inline ::std::string* AuthClientRequestMessage::release_authserverpassword() { clear_has_authserverpassword(); - if (authserverpassword_ == &::google::protobuf::internal::kEmptyString) { + if (authserverpassword_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = authserverpassword_; - authserverpassword_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + authserverpassword_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AuthClientRequestMessage::set_allocated_authserverpassword(::std::string* authserverpassword) { - if (authserverpassword_ != &::google::protobuf::internal::kEmptyString) { + if (authserverpassword_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete authserverpassword_; } if (authserverpassword) { @@ -12835,8 +13701,9 @@ inline void AuthClientRequestMessage::set_allocated_authserverpassword(::std::st authserverpassword_ = authserverpassword; } else { clear_has_authserverpassword(); - authserverpassword_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + authserverpassword_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AuthClientRequestMessage.authServerPassword) } // optional string nickName = 5; @@ -12850,54 +13717,59 @@ inline void AuthClientRequestMessage::clear_has_nickname() { _has_bits_[0] &= ~0x00000010u; } inline void AuthClientRequestMessage::clear_nickname() { - if (nickname_ != &::google::protobuf::internal::kEmptyString) { + if (nickname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { nickname_->clear(); } clear_has_nickname(); } inline const ::std::string& AuthClientRequestMessage::nickname() const { + // @@protoc_insertion_point(field_get:AuthClientRequestMessage.nickName) return *nickname_; } inline void AuthClientRequestMessage::set_nickname(const ::std::string& value) { set_has_nickname(); - if (nickname_ == &::google::protobuf::internal::kEmptyString) { + if (nickname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { nickname_ = new ::std::string; } nickname_->assign(value); + // @@protoc_insertion_point(field_set:AuthClientRequestMessage.nickName) } inline void AuthClientRequestMessage::set_nickname(const char* value) { set_has_nickname(); - if (nickname_ == &::google::protobuf::internal::kEmptyString) { + if (nickname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { nickname_ = new ::std::string; } nickname_->assign(value); + // @@protoc_insertion_point(field_set_char:AuthClientRequestMessage.nickName) } inline void AuthClientRequestMessage::set_nickname(const char* value, size_t size) { set_has_nickname(); - if (nickname_ == &::google::protobuf::internal::kEmptyString) { + if (nickname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { nickname_ = new ::std::string; } nickname_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AuthClientRequestMessage.nickName) } inline ::std::string* AuthClientRequestMessage::mutable_nickname() { set_has_nickname(); - if (nickname_ == &::google::protobuf::internal::kEmptyString) { + if (nickname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { nickname_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AuthClientRequestMessage.nickName) return nickname_; } inline ::std::string* AuthClientRequestMessage::release_nickname() { clear_has_nickname(); - if (nickname_ == &::google::protobuf::internal::kEmptyString) { + if (nickname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = nickname_; - nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AuthClientRequestMessage::set_allocated_nickname(::std::string* nickname) { - if (nickname_ != &::google::protobuf::internal::kEmptyString) { + if (nickname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete nickname_; } if (nickname) { @@ -12905,8 +13777,9 @@ inline void AuthClientRequestMessage::set_allocated_nickname(::std::string* nick nickname_ = nickname; } else { clear_has_nickname(); - nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AuthClientRequestMessage.nickName) } // optional bytes clientUserData = 6; @@ -12920,54 +13793,59 @@ inline void AuthClientRequestMessage::clear_has_clientuserdata() { _has_bits_[0] &= ~0x00000020u; } inline void AuthClientRequestMessage::clear_clientuserdata() { - if (clientuserdata_ != &::google::protobuf::internal::kEmptyString) { + if (clientuserdata_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientuserdata_->clear(); } clear_has_clientuserdata(); } inline const ::std::string& AuthClientRequestMessage::clientuserdata() const { + // @@protoc_insertion_point(field_get:AuthClientRequestMessage.clientUserData) return *clientuserdata_; } inline void AuthClientRequestMessage::set_clientuserdata(const ::std::string& value) { set_has_clientuserdata(); - if (clientuserdata_ == &::google::protobuf::internal::kEmptyString) { + if (clientuserdata_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientuserdata_ = new ::std::string; } clientuserdata_->assign(value); + // @@protoc_insertion_point(field_set:AuthClientRequestMessage.clientUserData) } inline void AuthClientRequestMessage::set_clientuserdata(const char* value) { set_has_clientuserdata(); - if (clientuserdata_ == &::google::protobuf::internal::kEmptyString) { + if (clientuserdata_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientuserdata_ = new ::std::string; } clientuserdata_->assign(value); + // @@protoc_insertion_point(field_set_char:AuthClientRequestMessage.clientUserData) } inline void AuthClientRequestMessage::set_clientuserdata(const void* value, size_t size) { set_has_clientuserdata(); - if (clientuserdata_ == &::google::protobuf::internal::kEmptyString) { + if (clientuserdata_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientuserdata_ = new ::std::string; } clientuserdata_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AuthClientRequestMessage.clientUserData) } inline ::std::string* AuthClientRequestMessage::mutable_clientuserdata() { set_has_clientuserdata(); - if (clientuserdata_ == &::google::protobuf::internal::kEmptyString) { + if (clientuserdata_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientuserdata_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AuthClientRequestMessage.clientUserData) return clientuserdata_; } inline ::std::string* AuthClientRequestMessage::release_clientuserdata() { clear_has_clientuserdata(); - if (clientuserdata_ == &::google::protobuf::internal::kEmptyString) { + if (clientuserdata_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = clientuserdata_; - clientuserdata_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clientuserdata_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AuthClientRequestMessage::set_allocated_clientuserdata(::std::string* clientuserdata) { - if (clientuserdata_ != &::google::protobuf::internal::kEmptyString) { + if (clientuserdata_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete clientuserdata_; } if (clientuserdata) { @@ -12975,8 +13853,9 @@ inline void AuthClientRequestMessage::set_allocated_clientuserdata(::std::string clientuserdata_ = clientuserdata; } else { clear_has_clientuserdata(); - clientuserdata_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clientuserdata_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AuthClientRequestMessage.clientUserData) } // optional bytes myLastSessionId = 7; @@ -12990,54 +13869,59 @@ inline void AuthClientRequestMessage::clear_has_mylastsessionid() { _has_bits_[0] &= ~0x00000040u; } inline void AuthClientRequestMessage::clear_mylastsessionid() { - if (mylastsessionid_ != &::google::protobuf::internal::kEmptyString) { + if (mylastsessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { mylastsessionid_->clear(); } clear_has_mylastsessionid(); } inline const ::std::string& AuthClientRequestMessage::mylastsessionid() const { + // @@protoc_insertion_point(field_get:AuthClientRequestMessage.myLastSessionId) return *mylastsessionid_; } inline void AuthClientRequestMessage::set_mylastsessionid(const ::std::string& value) { set_has_mylastsessionid(); - if (mylastsessionid_ == &::google::protobuf::internal::kEmptyString) { + if (mylastsessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { mylastsessionid_ = new ::std::string; } mylastsessionid_->assign(value); + // @@protoc_insertion_point(field_set:AuthClientRequestMessage.myLastSessionId) } inline void AuthClientRequestMessage::set_mylastsessionid(const char* value) { set_has_mylastsessionid(); - if (mylastsessionid_ == &::google::protobuf::internal::kEmptyString) { + if (mylastsessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { mylastsessionid_ = new ::std::string; } mylastsessionid_->assign(value); + // @@protoc_insertion_point(field_set_char:AuthClientRequestMessage.myLastSessionId) } inline void AuthClientRequestMessage::set_mylastsessionid(const void* value, size_t size) { set_has_mylastsessionid(); - if (mylastsessionid_ == &::google::protobuf::internal::kEmptyString) { + if (mylastsessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { mylastsessionid_ = new ::std::string; } mylastsessionid_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AuthClientRequestMessage.myLastSessionId) } inline ::std::string* AuthClientRequestMessage::mutable_mylastsessionid() { set_has_mylastsessionid(); - if (mylastsessionid_ == &::google::protobuf::internal::kEmptyString) { + if (mylastsessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { mylastsessionid_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AuthClientRequestMessage.myLastSessionId) return mylastsessionid_; } inline ::std::string* AuthClientRequestMessage::release_mylastsessionid() { clear_has_mylastsessionid(); - if (mylastsessionid_ == &::google::protobuf::internal::kEmptyString) { + if (mylastsessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = mylastsessionid_; - mylastsessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + mylastsessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AuthClientRequestMessage::set_allocated_mylastsessionid(::std::string* mylastsessionid) { - if (mylastsessionid_ != &::google::protobuf::internal::kEmptyString) { + if (mylastsessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete mylastsessionid_; } if (mylastsessionid) { @@ -13045,8 +13929,9 @@ inline void AuthClientRequestMessage::set_allocated_mylastsessionid(::std::strin mylastsessionid_ = mylastsessionid; } else { clear_has_mylastsessionid(); - mylastsessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + mylastsessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AuthClientRequestMessage.myLastSessionId) } // optional bytes avatarHash = 8; @@ -13060,54 +13945,59 @@ inline void AuthClientRequestMessage::clear_has_avatarhash() { _has_bits_[0] &= ~0x00000080u; } inline void AuthClientRequestMessage::clear_avatarhash() { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_->clear(); } clear_has_avatarhash(); } inline const ::std::string& AuthClientRequestMessage::avatarhash() const { + // @@protoc_insertion_point(field_get:AuthClientRequestMessage.avatarHash) return *avatarhash_; } inline void AuthClientRequestMessage::set_avatarhash(const ::std::string& value) { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } avatarhash_->assign(value); + // @@protoc_insertion_point(field_set:AuthClientRequestMessage.avatarHash) } inline void AuthClientRequestMessage::set_avatarhash(const char* value) { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } avatarhash_->assign(value); + // @@protoc_insertion_point(field_set_char:AuthClientRequestMessage.avatarHash) } inline void AuthClientRequestMessage::set_avatarhash(const void* value, size_t size) { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } avatarhash_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AuthClientRequestMessage.avatarHash) } inline ::std::string* AuthClientRequestMessage::mutable_avatarhash() { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AuthClientRequestMessage.avatarHash) return avatarhash_; } inline ::std::string* AuthClientRequestMessage::release_avatarhash() { clear_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = avatarhash_; - avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AuthClientRequestMessage::set_allocated_avatarhash(::std::string* avatarhash) { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete avatarhash_; } if (avatarhash) { @@ -13115,8 +14005,9 @@ inline void AuthClientRequestMessage::set_allocated_avatarhash(::std::string* av avatarhash_ = avatarhash; } else { clear_has_avatarhash(); - avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AuthClientRequestMessage.avatarHash) } // ------------------------------------------------------------------- @@ -13134,54 +14025,59 @@ inline void AuthServerChallengeMessage::clear_has_serverchallenge() { _has_bits_[0] &= ~0x00000001u; } inline void AuthServerChallengeMessage::clear_serverchallenge() { - if (serverchallenge_ != &::google::protobuf::internal::kEmptyString) { + if (serverchallenge_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serverchallenge_->clear(); } clear_has_serverchallenge(); } inline const ::std::string& AuthServerChallengeMessage::serverchallenge() const { + // @@protoc_insertion_point(field_get:AuthServerChallengeMessage.serverChallenge) return *serverchallenge_; } inline void AuthServerChallengeMessage::set_serverchallenge(const ::std::string& value) { set_has_serverchallenge(); - if (serverchallenge_ == &::google::protobuf::internal::kEmptyString) { + if (serverchallenge_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serverchallenge_ = new ::std::string; } serverchallenge_->assign(value); + // @@protoc_insertion_point(field_set:AuthServerChallengeMessage.serverChallenge) } inline void AuthServerChallengeMessage::set_serverchallenge(const char* value) { set_has_serverchallenge(); - if (serverchallenge_ == &::google::protobuf::internal::kEmptyString) { + if (serverchallenge_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serverchallenge_ = new ::std::string; } serverchallenge_->assign(value); + // @@protoc_insertion_point(field_set_char:AuthServerChallengeMessage.serverChallenge) } inline void AuthServerChallengeMessage::set_serverchallenge(const void* value, size_t size) { set_has_serverchallenge(); - if (serverchallenge_ == &::google::protobuf::internal::kEmptyString) { + if (serverchallenge_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serverchallenge_ = new ::std::string; } serverchallenge_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AuthServerChallengeMessage.serverChallenge) } inline ::std::string* AuthServerChallengeMessage::mutable_serverchallenge() { set_has_serverchallenge(); - if (serverchallenge_ == &::google::protobuf::internal::kEmptyString) { + if (serverchallenge_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serverchallenge_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AuthServerChallengeMessage.serverChallenge) return serverchallenge_; } inline ::std::string* AuthServerChallengeMessage::release_serverchallenge() { clear_has_serverchallenge(); - if (serverchallenge_ == &::google::protobuf::internal::kEmptyString) { + if (serverchallenge_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = serverchallenge_; - serverchallenge_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + serverchallenge_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AuthServerChallengeMessage::set_allocated_serverchallenge(::std::string* serverchallenge) { - if (serverchallenge_ != &::google::protobuf::internal::kEmptyString) { + if (serverchallenge_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete serverchallenge_; } if (serverchallenge) { @@ -13189,8 +14085,9 @@ inline void AuthServerChallengeMessage::set_allocated_serverchallenge(::std::str serverchallenge_ = serverchallenge; } else { clear_has_serverchallenge(); - serverchallenge_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + serverchallenge_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AuthServerChallengeMessage.serverChallenge) } // ------------------------------------------------------------------- @@ -13208,54 +14105,59 @@ inline void AuthClientResponseMessage::clear_has_clientresponse() { _has_bits_[0] &= ~0x00000001u; } inline void AuthClientResponseMessage::clear_clientresponse() { - if (clientresponse_ != &::google::protobuf::internal::kEmptyString) { + if (clientresponse_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientresponse_->clear(); } clear_has_clientresponse(); } inline const ::std::string& AuthClientResponseMessage::clientresponse() const { + // @@protoc_insertion_point(field_get:AuthClientResponseMessage.clientResponse) return *clientresponse_; } inline void AuthClientResponseMessage::set_clientresponse(const ::std::string& value) { set_has_clientresponse(); - if (clientresponse_ == &::google::protobuf::internal::kEmptyString) { + if (clientresponse_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientresponse_ = new ::std::string; } clientresponse_->assign(value); + // @@protoc_insertion_point(field_set:AuthClientResponseMessage.clientResponse) } inline void AuthClientResponseMessage::set_clientresponse(const char* value) { set_has_clientresponse(); - if (clientresponse_ == &::google::protobuf::internal::kEmptyString) { + if (clientresponse_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientresponse_ = new ::std::string; } clientresponse_->assign(value); + // @@protoc_insertion_point(field_set_char:AuthClientResponseMessage.clientResponse) } inline void AuthClientResponseMessage::set_clientresponse(const void* value, size_t size) { set_has_clientresponse(); - if (clientresponse_ == &::google::protobuf::internal::kEmptyString) { + if (clientresponse_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientresponse_ = new ::std::string; } clientresponse_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AuthClientResponseMessage.clientResponse) } inline ::std::string* AuthClientResponseMessage::mutable_clientresponse() { set_has_clientresponse(); - if (clientresponse_ == &::google::protobuf::internal::kEmptyString) { + if (clientresponse_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { clientresponse_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AuthClientResponseMessage.clientResponse) return clientresponse_; } inline ::std::string* AuthClientResponseMessage::release_clientresponse() { clear_has_clientresponse(); - if (clientresponse_ == &::google::protobuf::internal::kEmptyString) { + if (clientresponse_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = clientresponse_; - clientresponse_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clientresponse_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AuthClientResponseMessage::set_allocated_clientresponse(::std::string* clientresponse) { - if (clientresponse_ != &::google::protobuf::internal::kEmptyString) { + if (clientresponse_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete clientresponse_; } if (clientresponse) { @@ -13263,8 +14165,9 @@ inline void AuthClientResponseMessage::set_allocated_clientresponse(::std::strin clientresponse_ = clientresponse; } else { clear_has_clientresponse(); - clientresponse_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clientresponse_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AuthClientResponseMessage.clientResponse) } // ------------------------------------------------------------------- @@ -13282,54 +14185,59 @@ inline void AuthServerVerificationMessage::clear_has_serververification() { _has_bits_[0] &= ~0x00000001u; } inline void AuthServerVerificationMessage::clear_serververification() { - if (serververification_ != &::google::protobuf::internal::kEmptyString) { + if (serververification_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serververification_->clear(); } clear_has_serververification(); } inline const ::std::string& AuthServerVerificationMessage::serververification() const { + // @@protoc_insertion_point(field_get:AuthServerVerificationMessage.serverVerification) return *serververification_; } inline void AuthServerVerificationMessage::set_serververification(const ::std::string& value) { set_has_serververification(); - if (serververification_ == &::google::protobuf::internal::kEmptyString) { + if (serververification_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serververification_ = new ::std::string; } serververification_->assign(value); + // @@protoc_insertion_point(field_set:AuthServerVerificationMessage.serverVerification) } inline void AuthServerVerificationMessage::set_serververification(const char* value) { set_has_serververification(); - if (serververification_ == &::google::protobuf::internal::kEmptyString) { + if (serververification_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serververification_ = new ::std::string; } serververification_->assign(value); + // @@protoc_insertion_point(field_set_char:AuthServerVerificationMessage.serverVerification) } inline void AuthServerVerificationMessage::set_serververification(const void* value, size_t size) { set_has_serververification(); - if (serververification_ == &::google::protobuf::internal::kEmptyString) { + if (serververification_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serververification_ = new ::std::string; } serververification_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AuthServerVerificationMessage.serverVerification) } inline ::std::string* AuthServerVerificationMessage::mutable_serververification() { set_has_serververification(); - if (serververification_ == &::google::protobuf::internal::kEmptyString) { + if (serververification_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { serververification_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AuthServerVerificationMessage.serverVerification) return serververification_; } inline ::std::string* AuthServerVerificationMessage::release_serververification() { clear_has_serververification(); - if (serververification_ == &::google::protobuf::internal::kEmptyString) { + if (serververification_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = serververification_; - serververification_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + serververification_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AuthServerVerificationMessage::set_allocated_serververification(::std::string* serververification) { - if (serververification_ != &::google::protobuf::internal::kEmptyString) { + if (serververification_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete serververification_; } if (serververification) { @@ -13337,8 +14245,9 @@ inline void AuthServerVerificationMessage::set_allocated_serververification(::st serververification_ = serververification; } else { clear_has_serververification(); - serververification_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + serververification_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AuthServerVerificationMessage.serverVerification) } // ------------------------------------------------------------------- @@ -13356,54 +14265,59 @@ inline void InitDoneMessage::clear_has_yoursessionid() { _has_bits_[0] &= ~0x00000001u; } inline void InitDoneMessage::clear_yoursessionid() { - if (yoursessionid_ != &::google::protobuf::internal::kEmptyString) { + if (yoursessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { yoursessionid_->clear(); } clear_has_yoursessionid(); } inline const ::std::string& InitDoneMessage::yoursessionid() const { + // @@protoc_insertion_point(field_get:InitDoneMessage.yourSessionId) return *yoursessionid_; } inline void InitDoneMessage::set_yoursessionid(const ::std::string& value) { set_has_yoursessionid(); - if (yoursessionid_ == &::google::protobuf::internal::kEmptyString) { + if (yoursessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { yoursessionid_ = new ::std::string; } yoursessionid_->assign(value); + // @@protoc_insertion_point(field_set:InitDoneMessage.yourSessionId) } inline void InitDoneMessage::set_yoursessionid(const char* value) { set_has_yoursessionid(); - if (yoursessionid_ == &::google::protobuf::internal::kEmptyString) { + if (yoursessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { yoursessionid_ = new ::std::string; } yoursessionid_->assign(value); + // @@protoc_insertion_point(field_set_char:InitDoneMessage.yourSessionId) } inline void InitDoneMessage::set_yoursessionid(const void* value, size_t size) { set_has_yoursessionid(); - if (yoursessionid_ == &::google::protobuf::internal::kEmptyString) { + if (yoursessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { yoursessionid_ = new ::std::string; } yoursessionid_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:InitDoneMessage.yourSessionId) } inline ::std::string* InitDoneMessage::mutable_yoursessionid() { set_has_yoursessionid(); - if (yoursessionid_ == &::google::protobuf::internal::kEmptyString) { + if (yoursessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { yoursessionid_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:InitDoneMessage.yourSessionId) return yoursessionid_; } inline ::std::string* InitDoneMessage::release_yoursessionid() { clear_has_yoursessionid(); - if (yoursessionid_ == &::google::protobuf::internal::kEmptyString) { + if (yoursessionid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = yoursessionid_; - yoursessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + yoursessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void InitDoneMessage::set_allocated_yoursessionid(::std::string* yoursessionid) { - if (yoursessionid_ != &::google::protobuf::internal::kEmptyString) { + if (yoursessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete yoursessionid_; } if (yoursessionid) { @@ -13411,8 +14325,9 @@ inline void InitDoneMessage::set_allocated_yoursessionid(::std::string* yoursess yoursessionid_ = yoursessionid; } else { clear_has_yoursessionid(); - yoursessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + yoursessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:InitDoneMessage.yourSessionId) } // required uint32 yourPlayerId = 2; @@ -13430,11 +14345,13 @@ inline void InitDoneMessage::clear_yourplayerid() { clear_has_yourplayerid(); } inline ::google::protobuf::uint32 InitDoneMessage::yourplayerid() const { + // @@protoc_insertion_point(field_get:InitDoneMessage.yourPlayerId) return yourplayerid_; } inline void InitDoneMessage::set_yourplayerid(::google::protobuf::uint32 value) { set_has_yourplayerid(); yourplayerid_ = value; + // @@protoc_insertion_point(field_set:InitDoneMessage.yourPlayerId) } // optional bytes yourAvatarHash = 3; @@ -13448,54 +14365,59 @@ inline void InitDoneMessage::clear_has_youravatarhash() { _has_bits_[0] &= ~0x00000004u; } inline void InitDoneMessage::clear_youravatarhash() { - if (youravatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (youravatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { youravatarhash_->clear(); } clear_has_youravatarhash(); } inline const ::std::string& InitDoneMessage::youravatarhash() const { + // @@protoc_insertion_point(field_get:InitDoneMessage.yourAvatarHash) return *youravatarhash_; } inline void InitDoneMessage::set_youravatarhash(const ::std::string& value) { set_has_youravatarhash(); - if (youravatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (youravatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { youravatarhash_ = new ::std::string; } youravatarhash_->assign(value); + // @@protoc_insertion_point(field_set:InitDoneMessage.yourAvatarHash) } inline void InitDoneMessage::set_youravatarhash(const char* value) { set_has_youravatarhash(); - if (youravatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (youravatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { youravatarhash_ = new ::std::string; } youravatarhash_->assign(value); + // @@protoc_insertion_point(field_set_char:InitDoneMessage.yourAvatarHash) } inline void InitDoneMessage::set_youravatarhash(const void* value, size_t size) { set_has_youravatarhash(); - if (youravatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (youravatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { youravatarhash_ = new ::std::string; } youravatarhash_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:InitDoneMessage.yourAvatarHash) } inline ::std::string* InitDoneMessage::mutable_youravatarhash() { set_has_youravatarhash(); - if (youravatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (youravatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { youravatarhash_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:InitDoneMessage.yourAvatarHash) return youravatarhash_; } inline ::std::string* InitDoneMessage::release_youravatarhash() { clear_has_youravatarhash(); - if (youravatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (youravatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = youravatarhash_; - youravatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + youravatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void InitDoneMessage::set_allocated_youravatarhash(::std::string* youravatarhash) { - if (youravatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (youravatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete youravatarhash_; } if (youravatarhash) { @@ -13503,8 +14425,9 @@ inline void InitDoneMessage::set_allocated_youravatarhash(::std::string* yourava youravatarhash_ = youravatarhash; } else { clear_has_youravatarhash(); - youravatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + youravatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:InitDoneMessage.yourAvatarHash) } // optional uint32 rejoinGameId = 4; @@ -13522,11 +14445,13 @@ inline void InitDoneMessage::clear_rejoingameid() { clear_has_rejoingameid(); } inline ::google::protobuf::uint32 InitDoneMessage::rejoingameid() const { + // @@protoc_insertion_point(field_get:InitDoneMessage.rejoinGameId) return rejoingameid_; } inline void InitDoneMessage::set_rejoingameid(::google::protobuf::uint32 value) { set_has_rejoingameid(); rejoingameid_ = value; + // @@protoc_insertion_point(field_set:InitDoneMessage.rejoinGameId) } // ------------------------------------------------------------------- @@ -13548,11 +14473,13 @@ inline void AvatarRequestMessage::clear_requestid() { clear_has_requestid(); } inline ::google::protobuf::uint32 AvatarRequestMessage::requestid() const { + // @@protoc_insertion_point(field_get:AvatarRequestMessage.requestId) return requestid_; } inline void AvatarRequestMessage::set_requestid(::google::protobuf::uint32 value) { set_has_requestid(); requestid_ = value; + // @@protoc_insertion_point(field_set:AvatarRequestMessage.requestId) } // required bytes avatarHash = 2; @@ -13566,54 +14493,59 @@ inline void AvatarRequestMessage::clear_has_avatarhash() { _has_bits_[0] &= ~0x00000002u; } inline void AvatarRequestMessage::clear_avatarhash() { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_->clear(); } clear_has_avatarhash(); } inline const ::std::string& AvatarRequestMessage::avatarhash() const { + // @@protoc_insertion_point(field_get:AvatarRequestMessage.avatarHash) return *avatarhash_; } inline void AvatarRequestMessage::set_avatarhash(const ::std::string& value) { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } avatarhash_->assign(value); + // @@protoc_insertion_point(field_set:AvatarRequestMessage.avatarHash) } inline void AvatarRequestMessage::set_avatarhash(const char* value) { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } avatarhash_->assign(value); + // @@protoc_insertion_point(field_set_char:AvatarRequestMessage.avatarHash) } inline void AvatarRequestMessage::set_avatarhash(const void* value, size_t size) { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } avatarhash_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AvatarRequestMessage.avatarHash) } inline ::std::string* AvatarRequestMessage::mutable_avatarhash() { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AvatarRequestMessage.avatarHash) return avatarhash_; } inline ::std::string* AvatarRequestMessage::release_avatarhash() { clear_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = avatarhash_; - avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AvatarRequestMessage::set_allocated_avatarhash(::std::string* avatarhash) { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete avatarhash_; } if (avatarhash) { @@ -13621,8 +14553,9 @@ inline void AvatarRequestMessage::set_allocated_avatarhash(::std::string* avatar avatarhash_ = avatarhash; } else { clear_has_avatarhash(); - avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AvatarRequestMessage.avatarHash) } // ------------------------------------------------------------------- @@ -13644,11 +14577,13 @@ inline void AvatarHeaderMessage::clear_requestid() { clear_has_requestid(); } inline ::google::protobuf::uint32 AvatarHeaderMessage::requestid() const { + // @@protoc_insertion_point(field_get:AvatarHeaderMessage.requestId) return requestid_; } inline void AvatarHeaderMessage::set_requestid(::google::protobuf::uint32 value) { set_has_requestid(); requestid_ = value; + // @@protoc_insertion_point(field_set:AvatarHeaderMessage.requestId) } // required .NetAvatarType avatarType = 2; @@ -13666,12 +14601,14 @@ inline void AvatarHeaderMessage::clear_avatartype() { clear_has_avatartype(); } inline ::NetAvatarType AvatarHeaderMessage::avatartype() const { + // @@protoc_insertion_point(field_get:AvatarHeaderMessage.avatarType) return static_cast< ::NetAvatarType >(avatartype_); } inline void AvatarHeaderMessage::set_avatartype(::NetAvatarType value) { assert(::NetAvatarType_IsValid(value)); set_has_avatartype(); avatartype_ = value; + // @@protoc_insertion_point(field_set:AvatarHeaderMessage.avatarType) } // required uint32 avatarSize = 3; @@ -13689,11 +14626,13 @@ inline void AvatarHeaderMessage::clear_avatarsize() { clear_has_avatarsize(); } inline ::google::protobuf::uint32 AvatarHeaderMessage::avatarsize() const { + // @@protoc_insertion_point(field_get:AvatarHeaderMessage.avatarSize) return avatarsize_; } inline void AvatarHeaderMessage::set_avatarsize(::google::protobuf::uint32 value) { set_has_avatarsize(); avatarsize_ = value; + // @@protoc_insertion_point(field_set:AvatarHeaderMessage.avatarSize) } // ------------------------------------------------------------------- @@ -13715,11 +14654,13 @@ inline void AvatarDataMessage::clear_requestid() { clear_has_requestid(); } inline ::google::protobuf::uint32 AvatarDataMessage::requestid() const { + // @@protoc_insertion_point(field_get:AvatarDataMessage.requestId) return requestid_; } inline void AvatarDataMessage::set_requestid(::google::protobuf::uint32 value) { set_has_requestid(); requestid_ = value; + // @@protoc_insertion_point(field_set:AvatarDataMessage.requestId) } // required bytes avatarBlock = 2; @@ -13733,54 +14674,59 @@ inline void AvatarDataMessage::clear_has_avatarblock() { _has_bits_[0] &= ~0x00000002u; } inline void AvatarDataMessage::clear_avatarblock() { - if (avatarblock_ != &::google::protobuf::internal::kEmptyString) { + if (avatarblock_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarblock_->clear(); } clear_has_avatarblock(); } inline const ::std::string& AvatarDataMessage::avatarblock() const { + // @@protoc_insertion_point(field_get:AvatarDataMessage.avatarBlock) return *avatarblock_; } inline void AvatarDataMessage::set_avatarblock(const ::std::string& value) { set_has_avatarblock(); - if (avatarblock_ == &::google::protobuf::internal::kEmptyString) { + if (avatarblock_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarblock_ = new ::std::string; } avatarblock_->assign(value); + // @@protoc_insertion_point(field_set:AvatarDataMessage.avatarBlock) } inline void AvatarDataMessage::set_avatarblock(const char* value) { set_has_avatarblock(); - if (avatarblock_ == &::google::protobuf::internal::kEmptyString) { + if (avatarblock_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarblock_ = new ::std::string; } avatarblock_->assign(value); + // @@protoc_insertion_point(field_set_char:AvatarDataMessage.avatarBlock) } inline void AvatarDataMessage::set_avatarblock(const void* value, size_t size) { set_has_avatarblock(); - if (avatarblock_ == &::google::protobuf::internal::kEmptyString) { + if (avatarblock_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarblock_ = new ::std::string; } avatarblock_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:AvatarDataMessage.avatarBlock) } inline ::std::string* AvatarDataMessage::mutable_avatarblock() { set_has_avatarblock(); - if (avatarblock_ == &::google::protobuf::internal::kEmptyString) { + if (avatarblock_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarblock_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:AvatarDataMessage.avatarBlock) return avatarblock_; } inline ::std::string* AvatarDataMessage::release_avatarblock() { clear_has_avatarblock(); - if (avatarblock_ == &::google::protobuf::internal::kEmptyString) { + if (avatarblock_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = avatarblock_; - avatarblock_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarblock_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void AvatarDataMessage::set_allocated_avatarblock(::std::string* avatarblock) { - if (avatarblock_ != &::google::protobuf::internal::kEmptyString) { + if (avatarblock_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete avatarblock_; } if (avatarblock) { @@ -13788,8 +14734,9 @@ inline void AvatarDataMessage::set_allocated_avatarblock(::std::string* avatarbl avatarblock_ = avatarblock; } else { clear_has_avatarblock(); - avatarblock_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarblock_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:AvatarDataMessage.avatarBlock) } // ------------------------------------------------------------------- @@ -13811,11 +14758,13 @@ inline void AvatarEndMessage::clear_requestid() { clear_has_requestid(); } inline ::google::protobuf::uint32 AvatarEndMessage::requestid() const { + // @@protoc_insertion_point(field_get:AvatarEndMessage.requestId) return requestid_; } inline void AvatarEndMessage::set_requestid(::google::protobuf::uint32 value) { set_has_requestid(); requestid_ = value; + // @@protoc_insertion_point(field_set:AvatarEndMessage.requestId) } // ------------------------------------------------------------------- @@ -13837,11 +14786,13 @@ inline void UnknownAvatarMessage::clear_requestid() { clear_has_requestid(); } inline ::google::protobuf::uint32 UnknownAvatarMessage::requestid() const { + // @@protoc_insertion_point(field_get:UnknownAvatarMessage.requestId) return requestid_; } inline void UnknownAvatarMessage::set_requestid(::google::protobuf::uint32 value) { set_has_requestid(); requestid_ = value; + // @@protoc_insertion_point(field_set:UnknownAvatarMessage.requestId) } // ------------------------------------------------------------------- @@ -13863,11 +14814,13 @@ inline void PlayerListMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 PlayerListMessage::playerid() const { + // @@protoc_insertion_point(field_get:PlayerListMessage.playerId) return playerid_; } inline void PlayerListMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:PlayerListMessage.playerId) } // required .PlayerListMessage.PlayerListNotification playerListNotification = 2; @@ -13885,12 +14838,14 @@ inline void PlayerListMessage::clear_playerlistnotification() { clear_has_playerlistnotification(); } inline ::PlayerListMessage_PlayerListNotification PlayerListMessage::playerlistnotification() const { + // @@protoc_insertion_point(field_get:PlayerListMessage.playerListNotification) return static_cast< ::PlayerListMessage_PlayerListNotification >(playerlistnotification_); } inline void PlayerListMessage::set_playerlistnotification(::PlayerListMessage_PlayerListNotification value) { assert(::PlayerListMessage_PlayerListNotification_IsValid(value)); set_has_playerlistnotification(); playerlistnotification_ = value; + // @@protoc_insertion_point(field_set:PlayerListMessage.playerListNotification) } // ------------------------------------------------------------------- @@ -13912,11 +14867,13 @@ inline void GameListNewMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 GameListNewMessage::gameid() const { + // @@protoc_insertion_point(field_get:GameListNewMessage.gameId) return gameid_; } inline void GameListNewMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:GameListNewMessage.gameId) } // required .NetGameMode gameMode = 2; @@ -13934,12 +14891,14 @@ inline void GameListNewMessage::clear_gamemode() { clear_has_gamemode(); } inline ::NetGameMode GameListNewMessage::gamemode() const { + // @@protoc_insertion_point(field_get:GameListNewMessage.gameMode) return static_cast< ::NetGameMode >(gamemode_); } inline void GameListNewMessage::set_gamemode(::NetGameMode value) { assert(::NetGameMode_IsValid(value)); set_has_gamemode(); gamemode_ = value; + // @@protoc_insertion_point(field_set:GameListNewMessage.gameMode) } // required bool isPrivate = 3; @@ -13957,11 +14916,13 @@ inline void GameListNewMessage::clear_isprivate() { clear_has_isprivate(); } inline bool GameListNewMessage::isprivate() const { + // @@protoc_insertion_point(field_get:GameListNewMessage.isPrivate) return isprivate_; } inline void GameListNewMessage::set_isprivate(bool value) { set_has_isprivate(); isprivate_ = value; + // @@protoc_insertion_point(field_set:GameListNewMessage.isPrivate) } // repeated uint32 playerIds = 4 [packed = true]; @@ -13972,20 +14933,25 @@ inline void GameListNewMessage::clear_playerids() { playerids_.Clear(); } inline ::google::protobuf::uint32 GameListNewMessage::playerids(int index) const { + // @@protoc_insertion_point(field_get:GameListNewMessage.playerIds) return playerids_.Get(index); } inline void GameListNewMessage::set_playerids(int index, ::google::protobuf::uint32 value) { playerids_.Set(index, value); + // @@protoc_insertion_point(field_set:GameListNewMessage.playerIds) } inline void GameListNewMessage::add_playerids(::google::protobuf::uint32 value) { playerids_.Add(value); + // @@protoc_insertion_point(field_add:GameListNewMessage.playerIds) } inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& GameListNewMessage::playerids() const { + // @@protoc_insertion_point(field_list:GameListNewMessage.playerIds) return playerids_; } inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* GameListNewMessage::mutable_playerids() { + // @@protoc_insertion_point(field_mutable_list:GameListNewMessage.playerIds) return &playerids_; } @@ -14004,11 +14970,13 @@ inline void GameListNewMessage::clear_adminplayerid() { clear_has_adminplayerid(); } inline ::google::protobuf::uint32 GameListNewMessage::adminplayerid() const { + // @@protoc_insertion_point(field_get:GameListNewMessage.adminPlayerId) return adminplayerid_; } inline void GameListNewMessage::set_adminplayerid(::google::protobuf::uint32 value) { set_has_adminplayerid(); adminplayerid_ = value; + // @@protoc_insertion_point(field_set:GameListNewMessage.adminPlayerId) } // required .NetGameInfo gameInfo = 6; @@ -14026,6 +14994,7 @@ inline void GameListNewMessage::clear_gameinfo() { clear_has_gameinfo(); } inline const ::NetGameInfo& GameListNewMessage::gameinfo() const { + // @@protoc_insertion_point(field_get:GameListNewMessage.gameInfo) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gameinfo_ != NULL ? *gameinfo_ : *default_instance().gameinfo_; #else @@ -14035,6 +15004,7 @@ inline const ::NetGameInfo& GameListNewMessage::gameinfo() const { inline ::NetGameInfo* GameListNewMessage::mutable_gameinfo() { set_has_gameinfo(); if (gameinfo_ == NULL) gameinfo_ = new ::NetGameInfo; + // @@protoc_insertion_point(field_mutable:GameListNewMessage.gameInfo) return gameinfo_; } inline ::NetGameInfo* GameListNewMessage::release_gameinfo() { @@ -14051,6 +15021,7 @@ inline void GameListNewMessage::set_allocated_gameinfo(::NetGameInfo* gameinfo) } else { clear_has_gameinfo(); } + // @@protoc_insertion_point(field_set_allocated:GameListNewMessage.gameInfo) } // repeated uint32 spectatorIds = 7 [packed = true]; @@ -14061,20 +15032,25 @@ inline void GameListNewMessage::clear_spectatorids() { spectatorids_.Clear(); } inline ::google::protobuf::uint32 GameListNewMessage::spectatorids(int index) const { + // @@protoc_insertion_point(field_get:GameListNewMessage.spectatorIds) return spectatorids_.Get(index); } inline void GameListNewMessage::set_spectatorids(int index, ::google::protobuf::uint32 value) { spectatorids_.Set(index, value); + // @@protoc_insertion_point(field_set:GameListNewMessage.spectatorIds) } inline void GameListNewMessage::add_spectatorids(::google::protobuf::uint32 value) { spectatorids_.Add(value); + // @@protoc_insertion_point(field_add:GameListNewMessage.spectatorIds) } inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& GameListNewMessage::spectatorids() const { + // @@protoc_insertion_point(field_list:GameListNewMessage.spectatorIds) return spectatorids_; } inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* GameListNewMessage::mutable_spectatorids() { + // @@protoc_insertion_point(field_mutable_list:GameListNewMessage.spectatorIds) return &spectatorids_; } @@ -14097,11 +15073,13 @@ inline void GameListUpdateMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 GameListUpdateMessage::gameid() const { + // @@protoc_insertion_point(field_get:GameListUpdateMessage.gameId) return gameid_; } inline void GameListUpdateMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:GameListUpdateMessage.gameId) } // required .NetGameMode gameMode = 2; @@ -14119,12 +15097,14 @@ inline void GameListUpdateMessage::clear_gamemode() { clear_has_gamemode(); } inline ::NetGameMode GameListUpdateMessage::gamemode() const { + // @@protoc_insertion_point(field_get:GameListUpdateMessage.gameMode) return static_cast< ::NetGameMode >(gamemode_); } inline void GameListUpdateMessage::set_gamemode(::NetGameMode value) { assert(::NetGameMode_IsValid(value)); set_has_gamemode(); gamemode_ = value; + // @@protoc_insertion_point(field_set:GameListUpdateMessage.gameMode) } // ------------------------------------------------------------------- @@ -14146,11 +15126,13 @@ inline void GameListPlayerJoinedMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 GameListPlayerJoinedMessage::gameid() const { + // @@protoc_insertion_point(field_get:GameListPlayerJoinedMessage.gameId) return gameid_; } inline void GameListPlayerJoinedMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:GameListPlayerJoinedMessage.gameId) } // required uint32 playerId = 2; @@ -14168,11 +15150,13 @@ inline void GameListPlayerJoinedMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 GameListPlayerJoinedMessage::playerid() const { + // @@protoc_insertion_point(field_get:GameListPlayerJoinedMessage.playerId) return playerid_; } inline void GameListPlayerJoinedMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:GameListPlayerJoinedMessage.playerId) } // ------------------------------------------------------------------- @@ -14194,11 +15178,13 @@ inline void GameListPlayerLeftMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 GameListPlayerLeftMessage::gameid() const { + // @@protoc_insertion_point(field_get:GameListPlayerLeftMessage.gameId) return gameid_; } inline void GameListPlayerLeftMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:GameListPlayerLeftMessage.gameId) } // required uint32 playerId = 2; @@ -14216,11 +15202,13 @@ inline void GameListPlayerLeftMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 GameListPlayerLeftMessage::playerid() const { + // @@protoc_insertion_point(field_get:GameListPlayerLeftMessage.playerId) return playerid_; } inline void GameListPlayerLeftMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:GameListPlayerLeftMessage.playerId) } // ------------------------------------------------------------------- @@ -14242,11 +15230,13 @@ inline void GameListSpectatorJoinedMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 GameListSpectatorJoinedMessage::gameid() const { + // @@protoc_insertion_point(field_get:GameListSpectatorJoinedMessage.gameId) return gameid_; } inline void GameListSpectatorJoinedMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:GameListSpectatorJoinedMessage.gameId) } // required uint32 playerId = 2; @@ -14264,11 +15254,13 @@ inline void GameListSpectatorJoinedMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 GameListSpectatorJoinedMessage::playerid() const { + // @@protoc_insertion_point(field_get:GameListSpectatorJoinedMessage.playerId) return playerid_; } inline void GameListSpectatorJoinedMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:GameListSpectatorJoinedMessage.playerId) } // ------------------------------------------------------------------- @@ -14290,11 +15282,13 @@ inline void GameListSpectatorLeftMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 GameListSpectatorLeftMessage::gameid() const { + // @@protoc_insertion_point(field_get:GameListSpectatorLeftMessage.gameId) return gameid_; } inline void GameListSpectatorLeftMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:GameListSpectatorLeftMessage.gameId) } // required uint32 playerId = 2; @@ -14312,11 +15306,13 @@ inline void GameListSpectatorLeftMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 GameListSpectatorLeftMessage::playerid() const { + // @@protoc_insertion_point(field_get:GameListSpectatorLeftMessage.playerId) return playerid_; } inline void GameListSpectatorLeftMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:GameListSpectatorLeftMessage.playerId) } // ------------------------------------------------------------------- @@ -14338,11 +15334,13 @@ inline void GameListAdminChangedMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 GameListAdminChangedMessage::gameid() const { + // @@protoc_insertion_point(field_get:GameListAdminChangedMessage.gameId) return gameid_; } inline void GameListAdminChangedMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:GameListAdminChangedMessage.gameId) } // required uint32 newAdminPlayerId = 2; @@ -14360,11 +15358,13 @@ inline void GameListAdminChangedMessage::clear_newadminplayerid() { clear_has_newadminplayerid(); } inline ::google::protobuf::uint32 GameListAdminChangedMessage::newadminplayerid() const { + // @@protoc_insertion_point(field_get:GameListAdminChangedMessage.newAdminPlayerId) return newadminplayerid_; } inline void GameListAdminChangedMessage::set_newadminplayerid(::google::protobuf::uint32 value) { set_has_newadminplayerid(); newadminplayerid_ = value; + // @@protoc_insertion_point(field_set:GameListAdminChangedMessage.newAdminPlayerId) } // ------------------------------------------------------------------- @@ -14379,20 +15379,25 @@ inline void PlayerInfoRequestMessage::clear_playerid() { playerid_.Clear(); } inline ::google::protobuf::uint32 PlayerInfoRequestMessage::playerid(int index) const { + // @@protoc_insertion_point(field_get:PlayerInfoRequestMessage.playerId) return playerid_.Get(index); } inline void PlayerInfoRequestMessage::set_playerid(int index, ::google::protobuf::uint32 value) { playerid_.Set(index, value); + // @@protoc_insertion_point(field_set:PlayerInfoRequestMessage.playerId) } inline void PlayerInfoRequestMessage::add_playerid(::google::protobuf::uint32 value) { playerid_.Add(value); + // @@protoc_insertion_point(field_add:PlayerInfoRequestMessage.playerId) } inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& PlayerInfoRequestMessage::playerid() const { + // @@protoc_insertion_point(field_list:PlayerInfoRequestMessage.playerId) return playerid_; } inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* PlayerInfoRequestMessage::mutable_playerid() { + // @@protoc_insertion_point(field_mutable_list:PlayerInfoRequestMessage.playerId) return &playerid_; } @@ -14415,12 +15420,14 @@ inline void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::clear_avatartype() clear_has_avatartype(); } inline ::NetAvatarType PlayerInfoReplyMessage_PlayerInfoData_AvatarData::avatartype() const { + // @@protoc_insertion_point(field_get:PlayerInfoReplyMessage.PlayerInfoData.AvatarData.avatarType) return static_cast< ::NetAvatarType >(avatartype_); } inline void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::set_avatartype(::NetAvatarType value) { assert(::NetAvatarType_IsValid(value)); set_has_avatartype(); avatartype_ = value; + // @@protoc_insertion_point(field_set:PlayerInfoReplyMessage.PlayerInfoData.AvatarData.avatarType) } // required bytes avatarHash = 2; @@ -14434,54 +15441,59 @@ inline void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::clear_has_avatarha _has_bits_[0] &= ~0x00000002u; } inline void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::clear_avatarhash() { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_->clear(); } clear_has_avatarhash(); } inline const ::std::string& PlayerInfoReplyMessage_PlayerInfoData_AvatarData::avatarhash() const { + // @@protoc_insertion_point(field_get:PlayerInfoReplyMessage.PlayerInfoData.AvatarData.avatarHash) return *avatarhash_; } inline void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::set_avatarhash(const ::std::string& value) { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } avatarhash_->assign(value); + // @@protoc_insertion_point(field_set:PlayerInfoReplyMessage.PlayerInfoData.AvatarData.avatarHash) } inline void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::set_avatarhash(const char* value) { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } avatarhash_->assign(value); + // @@protoc_insertion_point(field_set_char:PlayerInfoReplyMessage.PlayerInfoData.AvatarData.avatarHash) } inline void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::set_avatarhash(const void* value, size_t size) { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } avatarhash_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:PlayerInfoReplyMessage.PlayerInfoData.AvatarData.avatarHash) } inline ::std::string* PlayerInfoReplyMessage_PlayerInfoData_AvatarData::mutable_avatarhash() { set_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { avatarhash_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:PlayerInfoReplyMessage.PlayerInfoData.AvatarData.avatarHash) return avatarhash_; } inline ::std::string* PlayerInfoReplyMessage_PlayerInfoData_AvatarData::release_avatarhash() { clear_has_avatarhash(); - if (avatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = avatarhash_; - avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::set_allocated_avatarhash(::std::string* avatarhash) { - if (avatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete avatarhash_; } if (avatarhash) { @@ -14489,8 +15501,9 @@ inline void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::set_allocated_avat avatarhash_ = avatarhash; } else { clear_has_avatarhash(); - avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:PlayerInfoReplyMessage.PlayerInfoData.AvatarData.avatarHash) } // ------------------------------------------------------------------- @@ -14508,54 +15521,59 @@ inline void PlayerInfoReplyMessage_PlayerInfoData::clear_has_playername() { _has_bits_[0] &= ~0x00000001u; } inline void PlayerInfoReplyMessage_PlayerInfoData::clear_playername() { - if (playername_ != &::google::protobuf::internal::kEmptyString) { + if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { playername_->clear(); } clear_has_playername(); } inline const ::std::string& PlayerInfoReplyMessage_PlayerInfoData::playername() const { + // @@protoc_insertion_point(field_get:PlayerInfoReplyMessage.PlayerInfoData.playerName) return *playername_; } inline void PlayerInfoReplyMessage_PlayerInfoData::set_playername(const ::std::string& value) { set_has_playername(); - if (playername_ == &::google::protobuf::internal::kEmptyString) { + if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { playername_ = new ::std::string; } playername_->assign(value); + // @@protoc_insertion_point(field_set:PlayerInfoReplyMessage.PlayerInfoData.playerName) } inline void PlayerInfoReplyMessage_PlayerInfoData::set_playername(const char* value) { set_has_playername(); - if (playername_ == &::google::protobuf::internal::kEmptyString) { + if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { playername_ = new ::std::string; } playername_->assign(value); + // @@protoc_insertion_point(field_set_char:PlayerInfoReplyMessage.PlayerInfoData.playerName) } inline void PlayerInfoReplyMessage_PlayerInfoData::set_playername(const char* value, size_t size) { set_has_playername(); - if (playername_ == &::google::protobuf::internal::kEmptyString) { + if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { playername_ = new ::std::string; } playername_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:PlayerInfoReplyMessage.PlayerInfoData.playerName) } inline ::std::string* PlayerInfoReplyMessage_PlayerInfoData::mutable_playername() { set_has_playername(); - if (playername_ == &::google::protobuf::internal::kEmptyString) { + if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { playername_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:PlayerInfoReplyMessage.PlayerInfoData.playerName) return playername_; } inline ::std::string* PlayerInfoReplyMessage_PlayerInfoData::release_playername() { clear_has_playername(); - if (playername_ == &::google::protobuf::internal::kEmptyString) { + if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = playername_; - playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void PlayerInfoReplyMessage_PlayerInfoData::set_allocated_playername(::std::string* playername) { - if (playername_ != &::google::protobuf::internal::kEmptyString) { + if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete playername_; } if (playername) { @@ -14563,8 +15581,9 @@ inline void PlayerInfoReplyMessage_PlayerInfoData::set_allocated_playername(::st playername_ = playername; } else { clear_has_playername(); - playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:PlayerInfoReplyMessage.PlayerInfoData.playerName) } // required bool isHuman = 2; @@ -14582,11 +15601,13 @@ inline void PlayerInfoReplyMessage_PlayerInfoData::clear_ishuman() { clear_has_ishuman(); } inline bool PlayerInfoReplyMessage_PlayerInfoData::ishuman() const { + // @@protoc_insertion_point(field_get:PlayerInfoReplyMessage.PlayerInfoData.isHuman) return ishuman_; } inline void PlayerInfoReplyMessage_PlayerInfoData::set_ishuman(bool value) { set_has_ishuman(); ishuman_ = value; + // @@protoc_insertion_point(field_set:PlayerInfoReplyMessage.PlayerInfoData.isHuman) } // required .NetPlayerInfoRights playerRights = 3; @@ -14604,12 +15625,14 @@ inline void PlayerInfoReplyMessage_PlayerInfoData::clear_playerrights() { clear_has_playerrights(); } inline ::NetPlayerInfoRights PlayerInfoReplyMessage_PlayerInfoData::playerrights() const { + // @@protoc_insertion_point(field_get:PlayerInfoReplyMessage.PlayerInfoData.playerRights) return static_cast< ::NetPlayerInfoRights >(playerrights_); } inline void PlayerInfoReplyMessage_PlayerInfoData::set_playerrights(::NetPlayerInfoRights value) { assert(::NetPlayerInfoRights_IsValid(value)); set_has_playerrights(); playerrights_ = value; + // @@protoc_insertion_point(field_set:PlayerInfoReplyMessage.PlayerInfoData.playerRights) } // optional string countryCode = 4; @@ -14623,54 +15646,59 @@ inline void PlayerInfoReplyMessage_PlayerInfoData::clear_has_countrycode() { _has_bits_[0] &= ~0x00000008u; } inline void PlayerInfoReplyMessage_PlayerInfoData::clear_countrycode() { - if (countrycode_ != &::google::protobuf::internal::kEmptyString) { + if (countrycode_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { countrycode_->clear(); } clear_has_countrycode(); } inline const ::std::string& PlayerInfoReplyMessage_PlayerInfoData::countrycode() const { + // @@protoc_insertion_point(field_get:PlayerInfoReplyMessage.PlayerInfoData.countryCode) return *countrycode_; } inline void PlayerInfoReplyMessage_PlayerInfoData::set_countrycode(const ::std::string& value) { set_has_countrycode(); - if (countrycode_ == &::google::protobuf::internal::kEmptyString) { + if (countrycode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { countrycode_ = new ::std::string; } countrycode_->assign(value); + // @@protoc_insertion_point(field_set:PlayerInfoReplyMessage.PlayerInfoData.countryCode) } inline void PlayerInfoReplyMessage_PlayerInfoData::set_countrycode(const char* value) { set_has_countrycode(); - if (countrycode_ == &::google::protobuf::internal::kEmptyString) { + if (countrycode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { countrycode_ = new ::std::string; } countrycode_->assign(value); + // @@protoc_insertion_point(field_set_char:PlayerInfoReplyMessage.PlayerInfoData.countryCode) } inline void PlayerInfoReplyMessage_PlayerInfoData::set_countrycode(const char* value, size_t size) { set_has_countrycode(); - if (countrycode_ == &::google::protobuf::internal::kEmptyString) { + if (countrycode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { countrycode_ = new ::std::string; } countrycode_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:PlayerInfoReplyMessage.PlayerInfoData.countryCode) } inline ::std::string* PlayerInfoReplyMessage_PlayerInfoData::mutable_countrycode() { set_has_countrycode(); - if (countrycode_ == &::google::protobuf::internal::kEmptyString) { + if (countrycode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { countrycode_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:PlayerInfoReplyMessage.PlayerInfoData.countryCode) return countrycode_; } inline ::std::string* PlayerInfoReplyMessage_PlayerInfoData::release_countrycode() { clear_has_countrycode(); - if (countrycode_ == &::google::protobuf::internal::kEmptyString) { + if (countrycode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = countrycode_; - countrycode_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + countrycode_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void PlayerInfoReplyMessage_PlayerInfoData::set_allocated_countrycode(::std::string* countrycode) { - if (countrycode_ != &::google::protobuf::internal::kEmptyString) { + if (countrycode_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete countrycode_; } if (countrycode) { @@ -14678,8 +15706,9 @@ inline void PlayerInfoReplyMessage_PlayerInfoData::set_allocated_countrycode(::s countrycode_ = countrycode; } else { clear_has_countrycode(); - countrycode_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + countrycode_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:PlayerInfoReplyMessage.PlayerInfoData.countryCode) } // optional .PlayerInfoReplyMessage.PlayerInfoData.AvatarData avatarData = 5; @@ -14697,6 +15726,7 @@ inline void PlayerInfoReplyMessage_PlayerInfoData::clear_avatardata() { clear_has_avatardata(); } inline const ::PlayerInfoReplyMessage_PlayerInfoData_AvatarData& PlayerInfoReplyMessage_PlayerInfoData::avatardata() const { + // @@protoc_insertion_point(field_get:PlayerInfoReplyMessage.PlayerInfoData.avatarData) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return avatardata_ != NULL ? *avatardata_ : *default_instance().avatardata_; #else @@ -14706,6 +15736,7 @@ inline const ::PlayerInfoReplyMessage_PlayerInfoData_AvatarData& PlayerInfoReply inline ::PlayerInfoReplyMessage_PlayerInfoData_AvatarData* PlayerInfoReplyMessage_PlayerInfoData::mutable_avatardata() { set_has_avatardata(); if (avatardata_ == NULL) avatardata_ = new ::PlayerInfoReplyMessage_PlayerInfoData_AvatarData; + // @@protoc_insertion_point(field_mutable:PlayerInfoReplyMessage.PlayerInfoData.avatarData) return avatardata_; } inline ::PlayerInfoReplyMessage_PlayerInfoData_AvatarData* PlayerInfoReplyMessage_PlayerInfoData::release_avatardata() { @@ -14722,6 +15753,7 @@ inline void PlayerInfoReplyMessage_PlayerInfoData::set_allocated_avatardata(::Pl } else { clear_has_avatardata(); } + // @@protoc_insertion_point(field_set_allocated:PlayerInfoReplyMessage.PlayerInfoData.avatarData) } // ------------------------------------------------------------------- @@ -14743,11 +15775,13 @@ inline void PlayerInfoReplyMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 PlayerInfoReplyMessage::playerid() const { + // @@protoc_insertion_point(field_get:PlayerInfoReplyMessage.playerId) return playerid_; } inline void PlayerInfoReplyMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:PlayerInfoReplyMessage.playerId) } // optional .PlayerInfoReplyMessage.PlayerInfoData playerInfoData = 2; @@ -14765,6 +15799,7 @@ inline void PlayerInfoReplyMessage::clear_playerinfodata() { clear_has_playerinfodata(); } inline const ::PlayerInfoReplyMessage_PlayerInfoData& PlayerInfoReplyMessage::playerinfodata() const { + // @@protoc_insertion_point(field_get:PlayerInfoReplyMessage.playerInfoData) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return playerinfodata_ != NULL ? *playerinfodata_ : *default_instance().playerinfodata_; #else @@ -14774,6 +15809,7 @@ inline const ::PlayerInfoReplyMessage_PlayerInfoData& PlayerInfoReplyMessage::pl inline ::PlayerInfoReplyMessage_PlayerInfoData* PlayerInfoReplyMessage::mutable_playerinfodata() { set_has_playerinfodata(); if (playerinfodata_ == NULL) playerinfodata_ = new ::PlayerInfoReplyMessage_PlayerInfoData; + // @@protoc_insertion_point(field_mutable:PlayerInfoReplyMessage.playerInfoData) return playerinfodata_; } inline ::PlayerInfoReplyMessage_PlayerInfoData* PlayerInfoReplyMessage::release_playerinfodata() { @@ -14790,6 +15826,7 @@ inline void PlayerInfoReplyMessage::set_allocated_playerinfodata(::PlayerInfoRep } else { clear_has_playerinfodata(); } + // @@protoc_insertion_point(field_set_allocated:PlayerInfoReplyMessage.playerInfoData) } // ------------------------------------------------------------------- @@ -14811,11 +15848,13 @@ inline void SubscriptionRequestMessage::clear_requestid() { clear_has_requestid(); } inline ::google::protobuf::uint32 SubscriptionRequestMessage::requestid() const { + // @@protoc_insertion_point(field_get:SubscriptionRequestMessage.requestId) return requestid_; } inline void SubscriptionRequestMessage::set_requestid(::google::protobuf::uint32 value) { set_has_requestid(); requestid_ = value; + // @@protoc_insertion_point(field_set:SubscriptionRequestMessage.requestId) } // required .SubscriptionRequestMessage.SubscriptionAction subscriptionAction = 2; @@ -14833,12 +15872,14 @@ inline void SubscriptionRequestMessage::clear_subscriptionaction() { clear_has_subscriptionaction(); } inline ::SubscriptionRequestMessage_SubscriptionAction SubscriptionRequestMessage::subscriptionaction() const { + // @@protoc_insertion_point(field_get:SubscriptionRequestMessage.subscriptionAction) return static_cast< ::SubscriptionRequestMessage_SubscriptionAction >(subscriptionaction_); } inline void SubscriptionRequestMessage::set_subscriptionaction(::SubscriptionRequestMessage_SubscriptionAction value) { assert(::SubscriptionRequestMessage_SubscriptionAction_IsValid(value)); set_has_subscriptionaction(); subscriptionaction_ = value; + // @@protoc_insertion_point(field_set:SubscriptionRequestMessage.subscriptionAction) } // ------------------------------------------------------------------- @@ -14860,11 +15901,13 @@ inline void SubscriptionReplyMessage::clear_requestid() { clear_has_requestid(); } inline ::google::protobuf::uint32 SubscriptionReplyMessage::requestid() const { + // @@protoc_insertion_point(field_get:SubscriptionReplyMessage.requestId) return requestid_; } inline void SubscriptionReplyMessage::set_requestid(::google::protobuf::uint32 value) { set_has_requestid(); requestid_ = value; + // @@protoc_insertion_point(field_set:SubscriptionReplyMessage.requestId) } // required bool ack = 2; @@ -14882,11 +15925,13 @@ inline void SubscriptionReplyMessage::clear_ack() { clear_has_ack(); } inline bool SubscriptionReplyMessage::ack() const { + // @@protoc_insertion_point(field_get:SubscriptionReplyMessage.ack) return ack_; } inline void SubscriptionReplyMessage::set_ack(bool value) { set_has_ack(); ack_ = value; + // @@protoc_insertion_point(field_set:SubscriptionReplyMessage.ack) } // ------------------------------------------------------------------- @@ -14908,11 +15953,13 @@ inline void CreateGameMessage::clear_requestid() { clear_has_requestid(); } inline ::google::protobuf::uint32 CreateGameMessage::requestid() const { + // @@protoc_insertion_point(field_get:CreateGameMessage.requestId) return requestid_; } inline void CreateGameMessage::set_requestid(::google::protobuf::uint32 value) { set_has_requestid(); requestid_ = value; + // @@protoc_insertion_point(field_set:CreateGameMessage.requestId) } // required .NetGameInfo gameInfo = 2; @@ -14930,6 +15977,7 @@ inline void CreateGameMessage::clear_gameinfo() { clear_has_gameinfo(); } inline const ::NetGameInfo& CreateGameMessage::gameinfo() const { + // @@protoc_insertion_point(field_get:CreateGameMessage.gameInfo) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gameinfo_ != NULL ? *gameinfo_ : *default_instance().gameinfo_; #else @@ -14939,6 +15987,7 @@ inline const ::NetGameInfo& CreateGameMessage::gameinfo() const { inline ::NetGameInfo* CreateGameMessage::mutable_gameinfo() { set_has_gameinfo(); if (gameinfo_ == NULL) gameinfo_ = new ::NetGameInfo; + // @@protoc_insertion_point(field_mutable:CreateGameMessage.gameInfo) return gameinfo_; } inline ::NetGameInfo* CreateGameMessage::release_gameinfo() { @@ -14955,6 +16004,7 @@ inline void CreateGameMessage::set_allocated_gameinfo(::NetGameInfo* gameinfo) { } else { clear_has_gameinfo(); } + // @@protoc_insertion_point(field_set_allocated:CreateGameMessage.gameInfo) } // optional string password = 3; @@ -14968,54 +16018,59 @@ inline void CreateGameMessage::clear_has_password() { _has_bits_[0] &= ~0x00000004u; } inline void CreateGameMessage::clear_password() { - if (password_ != &::google::protobuf::internal::kEmptyString) { + if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_->clear(); } clear_has_password(); } inline const ::std::string& CreateGameMessage::password() const { + // @@protoc_insertion_point(field_get:CreateGameMessage.password) return *password_; } inline void CreateGameMessage::set_password(const ::std::string& value) { set_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_ = new ::std::string; } password_->assign(value); + // @@protoc_insertion_point(field_set:CreateGameMessage.password) } inline void CreateGameMessage::set_password(const char* value) { set_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_ = new ::std::string; } password_->assign(value); + // @@protoc_insertion_point(field_set_char:CreateGameMessage.password) } inline void CreateGameMessage::set_password(const char* value, size_t size) { set_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_ = new ::std::string; } password_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:CreateGameMessage.password) } inline ::std::string* CreateGameMessage::mutable_password() { set_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:CreateGameMessage.password) return password_; } inline ::std::string* CreateGameMessage::release_password() { clear_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = password_; - password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + password_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void CreateGameMessage::set_allocated_password(::std::string* password) { - if (password_ != &::google::protobuf::internal::kEmptyString) { + if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete password_; } if (password) { @@ -15023,8 +16078,9 @@ inline void CreateGameMessage::set_allocated_password(::std::string* password) { password_ = password; } else { clear_has_password(); - password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + password_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:CreateGameMessage.password) } // optional bool autoLeave = 4; @@ -15042,11 +16098,13 @@ inline void CreateGameMessage::clear_autoleave() { clear_has_autoleave(); } inline bool CreateGameMessage::autoleave() const { + // @@protoc_insertion_point(field_get:CreateGameMessage.autoLeave) return autoleave_; } inline void CreateGameMessage::set_autoleave(bool value) { set_has_autoleave(); autoleave_ = value; + // @@protoc_insertion_point(field_set:CreateGameMessage.autoLeave) } // ------------------------------------------------------------------- @@ -15068,11 +16126,13 @@ inline void CreateGameFailedMessage::clear_requestid() { clear_has_requestid(); } inline ::google::protobuf::uint32 CreateGameFailedMessage::requestid() const { + // @@protoc_insertion_point(field_get:CreateGameFailedMessage.requestId) return requestid_; } inline void CreateGameFailedMessage::set_requestid(::google::protobuf::uint32 value) { set_has_requestid(); requestid_ = value; + // @@protoc_insertion_point(field_set:CreateGameFailedMessage.requestId) } // required .CreateGameFailedMessage.CreateGameFailureReason createGameFailureReason = 2; @@ -15090,12 +16150,14 @@ inline void CreateGameFailedMessage::clear_creategamefailurereason() { clear_has_creategamefailurereason(); } inline ::CreateGameFailedMessage_CreateGameFailureReason CreateGameFailedMessage::creategamefailurereason() const { + // @@protoc_insertion_point(field_get:CreateGameFailedMessage.createGameFailureReason) return static_cast< ::CreateGameFailedMessage_CreateGameFailureReason >(creategamefailurereason_); } inline void CreateGameFailedMessage::set_creategamefailurereason(::CreateGameFailedMessage_CreateGameFailureReason value) { assert(::CreateGameFailedMessage_CreateGameFailureReason_IsValid(value)); set_has_creategamefailurereason(); creategamefailurereason_ = value; + // @@protoc_insertion_point(field_set:CreateGameFailedMessage.createGameFailureReason) } // ------------------------------------------------------------------- @@ -15117,11 +16179,13 @@ inline void JoinGameMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 JoinGameMessage::gameid() const { + // @@protoc_insertion_point(field_get:JoinGameMessage.gameId) return gameid_; } inline void JoinGameMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:JoinGameMessage.gameId) } // optional string password = 2; @@ -15135,54 +16199,59 @@ inline void JoinGameMessage::clear_has_password() { _has_bits_[0] &= ~0x00000002u; } inline void JoinGameMessage::clear_password() { - if (password_ != &::google::protobuf::internal::kEmptyString) { + if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_->clear(); } clear_has_password(); } inline const ::std::string& JoinGameMessage::password() const { + // @@protoc_insertion_point(field_get:JoinGameMessage.password) return *password_; } inline void JoinGameMessage::set_password(const ::std::string& value) { set_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_ = new ::std::string; } password_->assign(value); + // @@protoc_insertion_point(field_set:JoinGameMessage.password) } inline void JoinGameMessage::set_password(const char* value) { set_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_ = new ::std::string; } password_->assign(value); + // @@protoc_insertion_point(field_set_char:JoinGameMessage.password) } inline void JoinGameMessage::set_password(const char* value, size_t size) { set_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_ = new ::std::string; } password_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:JoinGameMessage.password) } inline ::std::string* JoinGameMessage::mutable_password() { set_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { password_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:JoinGameMessage.password) return password_; } inline ::std::string* JoinGameMessage::release_password() { clear_has_password(); - if (password_ == &::google::protobuf::internal::kEmptyString) { + if (password_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = password_; - password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + password_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void JoinGameMessage::set_allocated_password(::std::string* password) { - if (password_ != &::google::protobuf::internal::kEmptyString) { + if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete password_; } if (password) { @@ -15190,8 +16259,9 @@ inline void JoinGameMessage::set_allocated_password(::std::string* password) { password_ = password; } else { clear_has_password(); - password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + password_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:JoinGameMessage.password) } // optional bool autoLeave = 3 [default = false]; @@ -15209,11 +16279,13 @@ inline void JoinGameMessage::clear_autoleave() { clear_has_autoleave(); } inline bool JoinGameMessage::autoleave() const { + // @@protoc_insertion_point(field_get:JoinGameMessage.autoLeave) return autoleave_; } inline void JoinGameMessage::set_autoleave(bool value) { set_has_autoleave(); autoleave_ = value; + // @@protoc_insertion_point(field_set:JoinGameMessage.autoLeave) } // optional bool spectateOnly = 4 [default = false]; @@ -15231,11 +16303,13 @@ inline void JoinGameMessage::clear_spectateonly() { clear_has_spectateonly(); } inline bool JoinGameMessage::spectateonly() const { + // @@protoc_insertion_point(field_get:JoinGameMessage.spectateOnly) return spectateonly_; } inline void JoinGameMessage::set_spectateonly(bool value) { set_has_spectateonly(); spectateonly_ = value; + // @@protoc_insertion_point(field_set:JoinGameMessage.spectateOnly) } // ------------------------------------------------------------------- @@ -15257,11 +16331,13 @@ inline void RejoinGameMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 RejoinGameMessage::gameid() const { + // @@protoc_insertion_point(field_get:RejoinGameMessage.gameId) return gameid_; } inline void RejoinGameMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:RejoinGameMessage.gameId) } // optional bool autoLeave = 2 [default = false]; @@ -15279,11 +16355,13 @@ inline void RejoinGameMessage::clear_autoleave() { clear_has_autoleave(); } inline bool RejoinGameMessage::autoleave() const { + // @@protoc_insertion_point(field_get:RejoinGameMessage.autoLeave) return autoleave_; } inline void RejoinGameMessage::set_autoleave(bool value) { set_has_autoleave(); autoleave_ = value; + // @@protoc_insertion_point(field_set:RejoinGameMessage.autoLeave) } // ------------------------------------------------------------------- @@ -15305,11 +16383,13 @@ inline void JoinGameAckMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 JoinGameAckMessage::gameid() const { + // @@protoc_insertion_point(field_get:JoinGameAckMessage.gameId) return gameid_; } inline void JoinGameAckMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:JoinGameAckMessage.gameId) } // required bool areYouGameAdmin = 2; @@ -15327,11 +16407,13 @@ inline void JoinGameAckMessage::clear_areyougameadmin() { clear_has_areyougameadmin(); } inline bool JoinGameAckMessage::areyougameadmin() const { + // @@protoc_insertion_point(field_get:JoinGameAckMessage.areYouGameAdmin) return areyougameadmin_; } inline void JoinGameAckMessage::set_areyougameadmin(bool value) { set_has_areyougameadmin(); areyougameadmin_ = value; + // @@protoc_insertion_point(field_set:JoinGameAckMessage.areYouGameAdmin) } // required .NetGameInfo gameInfo = 3; @@ -15349,6 +16431,7 @@ inline void JoinGameAckMessage::clear_gameinfo() { clear_has_gameinfo(); } inline const ::NetGameInfo& JoinGameAckMessage::gameinfo() const { + // @@protoc_insertion_point(field_get:JoinGameAckMessage.gameInfo) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gameinfo_ != NULL ? *gameinfo_ : *default_instance().gameinfo_; #else @@ -15358,6 +16441,7 @@ inline const ::NetGameInfo& JoinGameAckMessage::gameinfo() const { inline ::NetGameInfo* JoinGameAckMessage::mutable_gameinfo() { set_has_gameinfo(); if (gameinfo_ == NULL) gameinfo_ = new ::NetGameInfo; + // @@protoc_insertion_point(field_mutable:JoinGameAckMessage.gameInfo) return gameinfo_; } inline ::NetGameInfo* JoinGameAckMessage::release_gameinfo() { @@ -15374,6 +16458,7 @@ inline void JoinGameAckMessage::set_allocated_gameinfo(::NetGameInfo* gameinfo) } else { clear_has_gameinfo(); } + // @@protoc_insertion_point(field_set_allocated:JoinGameAckMessage.gameInfo) } // optional bool spectateOnly = 4; @@ -15391,11 +16476,13 @@ inline void JoinGameAckMessage::clear_spectateonly() { clear_has_spectateonly(); } inline bool JoinGameAckMessage::spectateonly() const { + // @@protoc_insertion_point(field_get:JoinGameAckMessage.spectateOnly) return spectateonly_; } inline void JoinGameAckMessage::set_spectateonly(bool value) { set_has_spectateonly(); spectateonly_ = value; + // @@protoc_insertion_point(field_set:JoinGameAckMessage.spectateOnly) } // ------------------------------------------------------------------- @@ -15417,11 +16504,13 @@ inline void JoinGameFailedMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 JoinGameFailedMessage::gameid() const { + // @@protoc_insertion_point(field_get:JoinGameFailedMessage.gameId) return gameid_; } inline void JoinGameFailedMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:JoinGameFailedMessage.gameId) } // required .JoinGameFailedMessage.JoinGameFailureReason joinGameFailureReason = 2; @@ -15439,12 +16528,14 @@ inline void JoinGameFailedMessage::clear_joingamefailurereason() { clear_has_joingamefailurereason(); } inline ::JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::joingamefailurereason() const { + // @@protoc_insertion_point(field_get:JoinGameFailedMessage.joinGameFailureReason) return static_cast< ::JoinGameFailedMessage_JoinGameFailureReason >(joingamefailurereason_); } inline void JoinGameFailedMessage::set_joingamefailurereason(::JoinGameFailedMessage_JoinGameFailureReason value) { assert(::JoinGameFailedMessage_JoinGameFailureReason_IsValid(value)); set_has_joingamefailurereason(); joingamefailurereason_ = value; + // @@protoc_insertion_point(field_set:JoinGameFailedMessage.joinGameFailureReason) } // ------------------------------------------------------------------- @@ -15466,11 +16557,13 @@ inline void GamePlayerJoinedMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 GamePlayerJoinedMessage::playerid() const { + // @@protoc_insertion_point(field_get:GamePlayerJoinedMessage.playerId) return playerid_; } inline void GamePlayerJoinedMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:GamePlayerJoinedMessage.playerId) } // required bool isGameAdmin = 2; @@ -15488,11 +16581,13 @@ inline void GamePlayerJoinedMessage::clear_isgameadmin() { clear_has_isgameadmin(); } inline bool GamePlayerJoinedMessage::isgameadmin() const { + // @@protoc_insertion_point(field_get:GamePlayerJoinedMessage.isGameAdmin) return isgameadmin_; } inline void GamePlayerJoinedMessage::set_isgameadmin(bool value) { set_has_isgameadmin(); isgameadmin_ = value; + // @@protoc_insertion_point(field_set:GamePlayerJoinedMessage.isGameAdmin) } // ------------------------------------------------------------------- @@ -15514,11 +16609,13 @@ inline void GamePlayerLeftMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 GamePlayerLeftMessage::playerid() const { + // @@protoc_insertion_point(field_get:GamePlayerLeftMessage.playerId) return playerid_; } inline void GamePlayerLeftMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:GamePlayerLeftMessage.playerId) } // required .GamePlayerLeftMessage.GamePlayerLeftReason gamePlayerLeftReason = 2; @@ -15536,12 +16633,14 @@ inline void GamePlayerLeftMessage::clear_gameplayerleftreason() { clear_has_gameplayerleftreason(); } inline ::GamePlayerLeftMessage_GamePlayerLeftReason GamePlayerLeftMessage::gameplayerleftreason() const { + // @@protoc_insertion_point(field_get:GamePlayerLeftMessage.gamePlayerLeftReason) return static_cast< ::GamePlayerLeftMessage_GamePlayerLeftReason >(gameplayerleftreason_); } inline void GamePlayerLeftMessage::set_gameplayerleftreason(::GamePlayerLeftMessage_GamePlayerLeftReason value) { assert(::GamePlayerLeftMessage_GamePlayerLeftReason_IsValid(value)); set_has_gameplayerleftreason(); gameplayerleftreason_ = value; + // @@protoc_insertion_point(field_set:GamePlayerLeftMessage.gamePlayerLeftReason) } // ------------------------------------------------------------------- @@ -15563,11 +16662,13 @@ inline void GameSpectatorJoinedMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 GameSpectatorJoinedMessage::playerid() const { + // @@protoc_insertion_point(field_get:GameSpectatorJoinedMessage.playerId) return playerid_; } inline void GameSpectatorJoinedMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:GameSpectatorJoinedMessage.playerId) } // ------------------------------------------------------------------- @@ -15589,11 +16690,13 @@ inline void GameSpectatorLeftMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 GameSpectatorLeftMessage::playerid() const { + // @@protoc_insertion_point(field_get:GameSpectatorLeftMessage.playerId) return playerid_; } inline void GameSpectatorLeftMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:GameSpectatorLeftMessage.playerId) } // required .GamePlayerLeftMessage.GamePlayerLeftReason gameSpectatorLeftReason = 2; @@ -15611,12 +16714,14 @@ inline void GameSpectatorLeftMessage::clear_gamespectatorleftreason() { clear_has_gamespectatorleftreason(); } inline ::GamePlayerLeftMessage_GamePlayerLeftReason GameSpectatorLeftMessage::gamespectatorleftreason() const { + // @@protoc_insertion_point(field_get:GameSpectatorLeftMessage.gameSpectatorLeftReason) return static_cast< ::GamePlayerLeftMessage_GamePlayerLeftReason >(gamespectatorleftreason_); } inline void GameSpectatorLeftMessage::set_gamespectatorleftreason(::GamePlayerLeftMessage_GamePlayerLeftReason value) { assert(::GamePlayerLeftMessage_GamePlayerLeftReason_IsValid(value)); set_has_gamespectatorleftreason(); gamespectatorleftreason_ = value; + // @@protoc_insertion_point(field_set:GameSpectatorLeftMessage.gameSpectatorLeftReason) } // ------------------------------------------------------------------- @@ -15638,11 +16743,13 @@ inline void GameAdminChangedMessage::clear_newadminplayerid() { clear_has_newadminplayerid(); } inline ::google::protobuf::uint32 GameAdminChangedMessage::newadminplayerid() const { + // @@protoc_insertion_point(field_get:GameAdminChangedMessage.newAdminPlayerId) return newadminplayerid_; } inline void GameAdminChangedMessage::set_newadminplayerid(::google::protobuf::uint32 value) { set_has_newadminplayerid(); newadminplayerid_ = value; + // @@protoc_insertion_point(field_set:GameAdminChangedMessage.newAdminPlayerId) } // ------------------------------------------------------------------- @@ -15664,12 +16771,14 @@ inline void RemovedFromGameMessage::clear_removedfromgamereason() { clear_has_removedfromgamereason(); } inline ::RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::removedfromgamereason() const { + // @@protoc_insertion_point(field_get:RemovedFromGameMessage.removedFromGameReason) return static_cast< ::RemovedFromGameMessage_RemovedFromGameReason >(removedfromgamereason_); } inline void RemovedFromGameMessage::set_removedfromgamereason(::RemovedFromGameMessage_RemovedFromGameReason value) { assert(::RemovedFromGameMessage_RemovedFromGameReason_IsValid(value)); set_has_removedfromgamereason(); removedfromgamereason_ = value; + // @@protoc_insertion_point(field_set:RemovedFromGameMessage.removedFromGameReason) } // ------------------------------------------------------------------- @@ -15691,11 +16800,13 @@ inline void KickPlayerRequestMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 KickPlayerRequestMessage::playerid() const { + // @@protoc_insertion_point(field_get:KickPlayerRequestMessage.playerId) return playerid_; } inline void KickPlayerRequestMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:KickPlayerRequestMessage.playerId) } // ------------------------------------------------------------------- @@ -15721,11 +16832,13 @@ inline void InvitePlayerToGameMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 InvitePlayerToGameMessage::gameid() const { + // @@protoc_insertion_point(field_get:InvitePlayerToGameMessage.gameId) return gameid_; } inline void InvitePlayerToGameMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:InvitePlayerToGameMessage.gameId) } // required uint32 playerId = 2; @@ -15743,11 +16856,13 @@ inline void InvitePlayerToGameMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 InvitePlayerToGameMessage::playerid() const { + // @@protoc_insertion_point(field_get:InvitePlayerToGameMessage.playerId) return playerid_; } inline void InvitePlayerToGameMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:InvitePlayerToGameMessage.playerId) } // ------------------------------------------------------------------- @@ -15769,11 +16884,13 @@ inline void InviteNotifyMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 InviteNotifyMessage::gameid() const { + // @@protoc_insertion_point(field_get:InviteNotifyMessage.gameId) return gameid_; } inline void InviteNotifyMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:InviteNotifyMessage.gameId) } // required uint32 playerIdWho = 2; @@ -15791,11 +16908,13 @@ inline void InviteNotifyMessage::clear_playeridwho() { clear_has_playeridwho(); } inline ::google::protobuf::uint32 InviteNotifyMessage::playeridwho() const { + // @@protoc_insertion_point(field_get:InviteNotifyMessage.playerIdWho) return playeridwho_; } inline void InviteNotifyMessage::set_playeridwho(::google::protobuf::uint32 value) { set_has_playeridwho(); playeridwho_ = value; + // @@protoc_insertion_point(field_set:InviteNotifyMessage.playerIdWho) } // required uint32 playerIdByWhom = 3; @@ -15813,11 +16932,13 @@ inline void InviteNotifyMessage::clear_playeridbywhom() { clear_has_playeridbywhom(); } inline ::google::protobuf::uint32 InviteNotifyMessage::playeridbywhom() const { + // @@protoc_insertion_point(field_get:InviteNotifyMessage.playerIdByWhom) return playeridbywhom_; } inline void InviteNotifyMessage::set_playeridbywhom(::google::protobuf::uint32 value) { set_has_playeridbywhom(); playeridbywhom_ = value; + // @@protoc_insertion_point(field_set:InviteNotifyMessage.playerIdByWhom) } // ------------------------------------------------------------------- @@ -15839,11 +16960,13 @@ inline void RejectGameInvitationMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 RejectGameInvitationMessage::gameid() const { + // @@protoc_insertion_point(field_get:RejectGameInvitationMessage.gameId) return gameid_; } inline void RejectGameInvitationMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:RejectGameInvitationMessage.gameId) } // required .RejectGameInvitationMessage.RejectGameInvReason myRejectReason = 2; @@ -15861,12 +16984,14 @@ inline void RejectGameInvitationMessage::clear_myrejectreason() { clear_has_myrejectreason(); } inline ::RejectGameInvitationMessage_RejectGameInvReason RejectGameInvitationMessage::myrejectreason() const { + // @@protoc_insertion_point(field_get:RejectGameInvitationMessage.myRejectReason) return static_cast< ::RejectGameInvitationMessage_RejectGameInvReason >(myrejectreason_); } inline void RejectGameInvitationMessage::set_myrejectreason(::RejectGameInvitationMessage_RejectGameInvReason value) { assert(::RejectGameInvitationMessage_RejectGameInvReason_IsValid(value)); set_has_myrejectreason(); myrejectreason_ = value; + // @@protoc_insertion_point(field_set:RejectGameInvitationMessage.myRejectReason) } // ------------------------------------------------------------------- @@ -15888,11 +17013,13 @@ inline void RejectInvNotifyMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 RejectInvNotifyMessage::gameid() const { + // @@protoc_insertion_point(field_get:RejectInvNotifyMessage.gameId) return gameid_; } inline void RejectInvNotifyMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:RejectInvNotifyMessage.gameId) } // required uint32 playerId = 2; @@ -15910,11 +17037,13 @@ inline void RejectInvNotifyMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 RejectInvNotifyMessage::playerid() const { + // @@protoc_insertion_point(field_get:RejectInvNotifyMessage.playerId) return playerid_; } inline void RejectInvNotifyMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:RejectInvNotifyMessage.playerId) } // required .RejectGameInvitationMessage.RejectGameInvReason playerRejectReason = 3; @@ -15932,12 +17061,14 @@ inline void RejectInvNotifyMessage::clear_playerrejectreason() { clear_has_playerrejectreason(); } inline ::RejectGameInvitationMessage_RejectGameInvReason RejectInvNotifyMessage::playerrejectreason() const { + // @@protoc_insertion_point(field_get:RejectInvNotifyMessage.playerRejectReason) return static_cast< ::RejectGameInvitationMessage_RejectGameInvReason >(playerrejectreason_); } inline void RejectInvNotifyMessage::set_playerrejectreason(::RejectGameInvitationMessage_RejectGameInvReason value) { assert(::RejectGameInvitationMessage_RejectGameInvReason_IsValid(value)); set_has_playerrejectreason(); playerrejectreason_ = value; + // @@protoc_insertion_point(field_set:RejectInvNotifyMessage.playerRejectReason) } // ------------------------------------------------------------------- @@ -15959,12 +17090,14 @@ inline void StartEventMessage::clear_starteventtype() { clear_has_starteventtype(); } inline ::StartEventMessage_StartEventType StartEventMessage::starteventtype() const { + // @@protoc_insertion_point(field_get:StartEventMessage.startEventType) return static_cast< ::StartEventMessage_StartEventType >(starteventtype_); } inline void StartEventMessage::set_starteventtype(::StartEventMessage_StartEventType value) { assert(::StartEventMessage_StartEventType_IsValid(value)); set_has_starteventtype(); starteventtype_ = value; + // @@protoc_insertion_point(field_set:StartEventMessage.startEventType) } // optional bool fillWithComputerPlayers = 2; @@ -15982,11 +17115,13 @@ inline void StartEventMessage::clear_fillwithcomputerplayers() { clear_has_fillwithcomputerplayers(); } inline bool StartEventMessage::fillwithcomputerplayers() const { + // @@protoc_insertion_point(field_get:StartEventMessage.fillWithComputerPlayers) return fillwithcomputerplayers_; } inline void StartEventMessage::set_fillwithcomputerplayers(bool value) { set_has_fillwithcomputerplayers(); fillwithcomputerplayers_ = value; + // @@protoc_insertion_point(field_set:StartEventMessage.fillWithComputerPlayers) } // ------------------------------------------------------------------- @@ -16012,11 +17147,13 @@ inline void GameStartInitialMessage::clear_startdealerplayerid() { clear_has_startdealerplayerid(); } inline ::google::protobuf::uint32 GameStartInitialMessage::startdealerplayerid() const { + // @@protoc_insertion_point(field_get:GameStartInitialMessage.startDealerPlayerId) return startdealerplayerid_; } inline void GameStartInitialMessage::set_startdealerplayerid(::google::protobuf::uint32 value) { set_has_startdealerplayerid(); startdealerplayerid_ = value; + // @@protoc_insertion_point(field_set:GameStartInitialMessage.startDealerPlayerId) } // repeated uint32 playerSeats = 2 [packed = true]; @@ -16027,20 +17164,25 @@ inline void GameStartInitialMessage::clear_playerseats() { playerseats_.Clear(); } inline ::google::protobuf::uint32 GameStartInitialMessage::playerseats(int index) const { + // @@protoc_insertion_point(field_get:GameStartInitialMessage.playerSeats) return playerseats_.Get(index); } inline void GameStartInitialMessage::set_playerseats(int index, ::google::protobuf::uint32 value) { playerseats_.Set(index, value); + // @@protoc_insertion_point(field_set:GameStartInitialMessage.playerSeats) } inline void GameStartInitialMessage::add_playerseats(::google::protobuf::uint32 value) { playerseats_.Add(value); + // @@protoc_insertion_point(field_add:GameStartInitialMessage.playerSeats) } inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& GameStartInitialMessage::playerseats() const { + // @@protoc_insertion_point(field_list:GameStartInitialMessage.playerSeats) return playerseats_; } inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* GameStartInitialMessage::mutable_playerseats() { + // @@protoc_insertion_point(field_mutable_list:GameStartInitialMessage.playerSeats) return &playerseats_; } @@ -16063,11 +17205,13 @@ inline void GameStartRejoinMessage_RejoinPlayerData::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 GameStartRejoinMessage_RejoinPlayerData::playerid() const { + // @@protoc_insertion_point(field_get:GameStartRejoinMessage.RejoinPlayerData.playerId) return playerid_; } inline void GameStartRejoinMessage_RejoinPlayerData::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:GameStartRejoinMessage.RejoinPlayerData.playerId) } // required uint32 playerMoney = 2; @@ -16085,11 +17229,13 @@ inline void GameStartRejoinMessage_RejoinPlayerData::clear_playermoney() { clear_has_playermoney(); } inline ::google::protobuf::uint32 GameStartRejoinMessage_RejoinPlayerData::playermoney() const { + // @@protoc_insertion_point(field_get:GameStartRejoinMessage.RejoinPlayerData.playerMoney) return playermoney_; } inline void GameStartRejoinMessage_RejoinPlayerData::set_playermoney(::google::protobuf::uint32 value) { set_has_playermoney(); playermoney_ = value; + // @@protoc_insertion_point(field_set:GameStartRejoinMessage.RejoinPlayerData.playerMoney) } // ------------------------------------------------------------------- @@ -16111,11 +17257,13 @@ inline void GameStartRejoinMessage::clear_startdealerplayerid() { clear_has_startdealerplayerid(); } inline ::google::protobuf::uint32 GameStartRejoinMessage::startdealerplayerid() const { + // @@protoc_insertion_point(field_get:GameStartRejoinMessage.startDealerPlayerId) return startdealerplayerid_; } inline void GameStartRejoinMessage::set_startdealerplayerid(::google::protobuf::uint32 value) { set_has_startdealerplayerid(); startdealerplayerid_ = value; + // @@protoc_insertion_point(field_set:GameStartRejoinMessage.startDealerPlayerId) } // required uint32 handNum = 2; @@ -16133,11 +17281,13 @@ inline void GameStartRejoinMessage::clear_handnum() { clear_has_handnum(); } inline ::google::protobuf::uint32 GameStartRejoinMessage::handnum() const { + // @@protoc_insertion_point(field_get:GameStartRejoinMessage.handNum) return handnum_; } inline void GameStartRejoinMessage::set_handnum(::google::protobuf::uint32 value) { set_has_handnum(); handnum_ = value; + // @@protoc_insertion_point(field_set:GameStartRejoinMessage.handNum) } // repeated .GameStartRejoinMessage.RejoinPlayerData rejoinPlayerData = 3; @@ -16148,20 +17298,25 @@ inline void GameStartRejoinMessage::clear_rejoinplayerdata() { rejoinplayerdata_.Clear(); } inline const ::GameStartRejoinMessage_RejoinPlayerData& GameStartRejoinMessage::rejoinplayerdata(int index) const { + // @@protoc_insertion_point(field_get:GameStartRejoinMessage.rejoinPlayerData) return rejoinplayerdata_.Get(index); } inline ::GameStartRejoinMessage_RejoinPlayerData* GameStartRejoinMessage::mutable_rejoinplayerdata(int index) { + // @@protoc_insertion_point(field_mutable:GameStartRejoinMessage.rejoinPlayerData) return rejoinplayerdata_.Mutable(index); } inline ::GameStartRejoinMessage_RejoinPlayerData* GameStartRejoinMessage::add_rejoinplayerdata() { + // @@protoc_insertion_point(field_add:GameStartRejoinMessage.rejoinPlayerData) return rejoinplayerdata_.Add(); } inline const ::google::protobuf::RepeatedPtrField< ::GameStartRejoinMessage_RejoinPlayerData >& GameStartRejoinMessage::rejoinplayerdata() const { + // @@protoc_insertion_point(field_list:GameStartRejoinMessage.rejoinPlayerData) return rejoinplayerdata_; } inline ::google::protobuf::RepeatedPtrField< ::GameStartRejoinMessage_RejoinPlayerData >* GameStartRejoinMessage::mutable_rejoinplayerdata() { + // @@protoc_insertion_point(field_mutable_list:GameStartRejoinMessage.rejoinPlayerData) return &rejoinplayerdata_; } @@ -16184,11 +17339,13 @@ inline void HandStartMessage_PlainCards::clear_plaincard1() { clear_has_plaincard1(); } inline ::google::protobuf::uint32 HandStartMessage_PlainCards::plaincard1() const { + // @@protoc_insertion_point(field_get:HandStartMessage.PlainCards.plainCard1) return plaincard1_; } inline void HandStartMessage_PlainCards::set_plaincard1(::google::protobuf::uint32 value) { set_has_plaincard1(); plaincard1_ = value; + // @@protoc_insertion_point(field_set:HandStartMessage.PlainCards.plainCard1) } // required uint32 plainCard2 = 2; @@ -16206,11 +17363,13 @@ inline void HandStartMessage_PlainCards::clear_plaincard2() { clear_has_plaincard2(); } inline ::google::protobuf::uint32 HandStartMessage_PlainCards::plaincard2() const { + // @@protoc_insertion_point(field_get:HandStartMessage.PlainCards.plainCard2) return plaincard2_; } inline void HandStartMessage_PlainCards::set_plaincard2(::google::protobuf::uint32 value) { set_has_plaincard2(); plaincard2_ = value; + // @@protoc_insertion_point(field_set:HandStartMessage.PlainCards.plainCard2) } // ------------------------------------------------------------------- @@ -16232,6 +17391,7 @@ inline void HandStartMessage::clear_plaincards() { clear_has_plaincards(); } inline const ::HandStartMessage_PlainCards& HandStartMessage::plaincards() const { + // @@protoc_insertion_point(field_get:HandStartMessage.plainCards) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return plaincards_ != NULL ? *plaincards_ : *default_instance().plaincards_; #else @@ -16241,6 +17401,7 @@ inline const ::HandStartMessage_PlainCards& HandStartMessage::plaincards() const inline ::HandStartMessage_PlainCards* HandStartMessage::mutable_plaincards() { set_has_plaincards(); if (plaincards_ == NULL) plaincards_ = new ::HandStartMessage_PlainCards; + // @@protoc_insertion_point(field_mutable:HandStartMessage.plainCards) return plaincards_; } inline ::HandStartMessage_PlainCards* HandStartMessage::release_plaincards() { @@ -16257,6 +17418,7 @@ inline void HandStartMessage::set_allocated_plaincards(::HandStartMessage_PlainC } else { clear_has_plaincards(); } + // @@protoc_insertion_point(field_set_allocated:HandStartMessage.plainCards) } // optional bytes encryptedCards = 2; @@ -16270,54 +17432,59 @@ inline void HandStartMessage::clear_has_encryptedcards() { _has_bits_[0] &= ~0x00000002u; } inline void HandStartMessage::clear_encryptedcards() { - if (encryptedcards_ != &::google::protobuf::internal::kEmptyString) { + if (encryptedcards_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { encryptedcards_->clear(); } clear_has_encryptedcards(); } inline const ::std::string& HandStartMessage::encryptedcards() const { + // @@protoc_insertion_point(field_get:HandStartMessage.encryptedCards) return *encryptedcards_; } inline void HandStartMessage::set_encryptedcards(const ::std::string& value) { set_has_encryptedcards(); - if (encryptedcards_ == &::google::protobuf::internal::kEmptyString) { + if (encryptedcards_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { encryptedcards_ = new ::std::string; } encryptedcards_->assign(value); + // @@protoc_insertion_point(field_set:HandStartMessage.encryptedCards) } inline void HandStartMessage::set_encryptedcards(const char* value) { set_has_encryptedcards(); - if (encryptedcards_ == &::google::protobuf::internal::kEmptyString) { + if (encryptedcards_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { encryptedcards_ = new ::std::string; } encryptedcards_->assign(value); + // @@protoc_insertion_point(field_set_char:HandStartMessage.encryptedCards) } inline void HandStartMessage::set_encryptedcards(const void* value, size_t size) { set_has_encryptedcards(); - if (encryptedcards_ == &::google::protobuf::internal::kEmptyString) { + if (encryptedcards_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { encryptedcards_ = new ::std::string; } encryptedcards_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:HandStartMessage.encryptedCards) } inline ::std::string* HandStartMessage::mutable_encryptedcards() { set_has_encryptedcards(); - if (encryptedcards_ == &::google::protobuf::internal::kEmptyString) { + if (encryptedcards_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { encryptedcards_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:HandStartMessage.encryptedCards) return encryptedcards_; } inline ::std::string* HandStartMessage::release_encryptedcards() { clear_has_encryptedcards(); - if (encryptedcards_ == &::google::protobuf::internal::kEmptyString) { + if (encryptedcards_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = encryptedcards_; - encryptedcards_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + encryptedcards_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void HandStartMessage::set_allocated_encryptedcards(::std::string* encryptedcards) { - if (encryptedcards_ != &::google::protobuf::internal::kEmptyString) { + if (encryptedcards_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete encryptedcards_; } if (encryptedcards) { @@ -16325,8 +17492,9 @@ inline void HandStartMessage::set_allocated_encryptedcards(::std::string* encryp encryptedcards_ = encryptedcards; } else { clear_has_encryptedcards(); - encryptedcards_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + encryptedcards_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:HandStartMessage.encryptedCards) } // required uint32 smallBlind = 3; @@ -16344,11 +17512,13 @@ inline void HandStartMessage::clear_smallblind() { clear_has_smallblind(); } inline ::google::protobuf::uint32 HandStartMessage::smallblind() const { + // @@protoc_insertion_point(field_get:HandStartMessage.smallBlind) return smallblind_; } inline void HandStartMessage::set_smallblind(::google::protobuf::uint32 value) { set_has_smallblind(); smallblind_ = value; + // @@protoc_insertion_point(field_set:HandStartMessage.smallBlind) } // repeated .NetPlayerState seatStates = 4; @@ -16359,22 +17529,27 @@ inline void HandStartMessage::clear_seatstates() { seatstates_.Clear(); } inline ::NetPlayerState HandStartMessage::seatstates(int index) const { + // @@protoc_insertion_point(field_get:HandStartMessage.seatStates) return static_cast< ::NetPlayerState >(seatstates_.Get(index)); } inline void HandStartMessage::set_seatstates(int index, ::NetPlayerState value) { assert(::NetPlayerState_IsValid(value)); seatstates_.Set(index, value); + // @@protoc_insertion_point(field_set:HandStartMessage.seatStates) } inline void HandStartMessage::add_seatstates(::NetPlayerState value) { assert(::NetPlayerState_IsValid(value)); seatstates_.Add(value); + // @@protoc_insertion_point(field_add:HandStartMessage.seatStates) } inline const ::google::protobuf::RepeatedField& HandStartMessage::seatstates() const { + // @@protoc_insertion_point(field_list:HandStartMessage.seatStates) return seatstates_; } inline ::google::protobuf::RepeatedField* HandStartMessage::mutable_seatstates() { + // @@protoc_insertion_point(field_mutable_list:HandStartMessage.seatStates) return &seatstates_; } @@ -16393,11 +17568,13 @@ inline void HandStartMessage::clear_dealerplayerid() { clear_has_dealerplayerid(); } inline ::google::protobuf::uint32 HandStartMessage::dealerplayerid() const { + // @@protoc_insertion_point(field_get:HandStartMessage.dealerPlayerId) return dealerplayerid_; } inline void HandStartMessage::set_dealerplayerid(::google::protobuf::uint32 value) { set_has_dealerplayerid(); dealerplayerid_ = value; + // @@protoc_insertion_point(field_set:HandStartMessage.dealerPlayerId) } // ------------------------------------------------------------------- @@ -16419,11 +17596,13 @@ inline void PlayersTurnMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 PlayersTurnMessage::playerid() const { + // @@protoc_insertion_point(field_get:PlayersTurnMessage.playerId) return playerid_; } inline void PlayersTurnMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:PlayersTurnMessage.playerId) } // required .NetGameState gameState = 2; @@ -16441,12 +17620,14 @@ inline void PlayersTurnMessage::clear_gamestate() { clear_has_gamestate(); } inline ::NetGameState PlayersTurnMessage::gamestate() const { + // @@protoc_insertion_point(field_get:PlayersTurnMessage.gameState) return static_cast< ::NetGameState >(gamestate_); } inline void PlayersTurnMessage::set_gamestate(::NetGameState value) { assert(::NetGameState_IsValid(value)); set_has_gamestate(); gamestate_ = value; + // @@protoc_insertion_point(field_set:PlayersTurnMessage.gameState) } // ------------------------------------------------------------------- @@ -16468,11 +17649,13 @@ inline void MyActionRequestMessage::clear_handnum() { clear_has_handnum(); } inline ::google::protobuf::uint32 MyActionRequestMessage::handnum() const { + // @@protoc_insertion_point(field_get:MyActionRequestMessage.handNum) return handnum_; } inline void MyActionRequestMessage::set_handnum(::google::protobuf::uint32 value) { set_has_handnum(); handnum_ = value; + // @@protoc_insertion_point(field_set:MyActionRequestMessage.handNum) } // required .NetGameState gameState = 2; @@ -16490,12 +17673,14 @@ inline void MyActionRequestMessage::clear_gamestate() { clear_has_gamestate(); } inline ::NetGameState MyActionRequestMessage::gamestate() const { + // @@protoc_insertion_point(field_get:MyActionRequestMessage.gameState) return static_cast< ::NetGameState >(gamestate_); } inline void MyActionRequestMessage::set_gamestate(::NetGameState value) { assert(::NetGameState_IsValid(value)); set_has_gamestate(); gamestate_ = value; + // @@protoc_insertion_point(field_set:MyActionRequestMessage.gameState) } // required .NetPlayerAction myAction = 3; @@ -16513,12 +17698,14 @@ inline void MyActionRequestMessage::clear_myaction() { clear_has_myaction(); } inline ::NetPlayerAction MyActionRequestMessage::myaction() const { + // @@protoc_insertion_point(field_get:MyActionRequestMessage.myAction) return static_cast< ::NetPlayerAction >(myaction_); } inline void MyActionRequestMessage::set_myaction(::NetPlayerAction value) { assert(::NetPlayerAction_IsValid(value)); set_has_myaction(); myaction_ = value; + // @@protoc_insertion_point(field_set:MyActionRequestMessage.myAction) } // required uint32 myRelativeBet = 4; @@ -16536,11 +17723,13 @@ inline void MyActionRequestMessage::clear_myrelativebet() { clear_has_myrelativebet(); } inline ::google::protobuf::uint32 MyActionRequestMessage::myrelativebet() const { + // @@protoc_insertion_point(field_get:MyActionRequestMessage.myRelativeBet) return myrelativebet_; } inline void MyActionRequestMessage::set_myrelativebet(::google::protobuf::uint32 value) { set_has_myrelativebet(); myrelativebet_ = value; + // @@protoc_insertion_point(field_set:MyActionRequestMessage.myRelativeBet) } // ------------------------------------------------------------------- @@ -16562,12 +17751,14 @@ inline void YourActionRejectedMessage::clear_gamestate() { clear_has_gamestate(); } inline ::NetGameState YourActionRejectedMessage::gamestate() const { + // @@protoc_insertion_point(field_get:YourActionRejectedMessage.gameState) return static_cast< ::NetGameState >(gamestate_); } inline void YourActionRejectedMessage::set_gamestate(::NetGameState value) { assert(::NetGameState_IsValid(value)); set_has_gamestate(); gamestate_ = value; + // @@protoc_insertion_point(field_set:YourActionRejectedMessage.gameState) } // required .NetPlayerAction yourAction = 2; @@ -16585,12 +17776,14 @@ inline void YourActionRejectedMessage::clear_youraction() { clear_has_youraction(); } inline ::NetPlayerAction YourActionRejectedMessage::youraction() const { + // @@protoc_insertion_point(field_get:YourActionRejectedMessage.yourAction) return static_cast< ::NetPlayerAction >(youraction_); } inline void YourActionRejectedMessage::set_youraction(::NetPlayerAction value) { assert(::NetPlayerAction_IsValid(value)); set_has_youraction(); youraction_ = value; + // @@protoc_insertion_point(field_set:YourActionRejectedMessage.yourAction) } // required uint32 yourRelativeBet = 3; @@ -16608,11 +17801,13 @@ inline void YourActionRejectedMessage::clear_yourrelativebet() { clear_has_yourrelativebet(); } inline ::google::protobuf::uint32 YourActionRejectedMessage::yourrelativebet() const { + // @@protoc_insertion_point(field_get:YourActionRejectedMessage.yourRelativeBet) return yourrelativebet_; } inline void YourActionRejectedMessage::set_yourrelativebet(::google::protobuf::uint32 value) { set_has_yourrelativebet(); yourrelativebet_ = value; + // @@protoc_insertion_point(field_set:YourActionRejectedMessage.yourRelativeBet) } // required .YourActionRejectedMessage.RejectionReason rejectionReason = 4; @@ -16630,12 +17825,14 @@ inline void YourActionRejectedMessage::clear_rejectionreason() { clear_has_rejectionreason(); } inline ::YourActionRejectedMessage_RejectionReason YourActionRejectedMessage::rejectionreason() const { + // @@protoc_insertion_point(field_get:YourActionRejectedMessage.rejectionReason) return static_cast< ::YourActionRejectedMessage_RejectionReason >(rejectionreason_); } inline void YourActionRejectedMessage::set_rejectionreason(::YourActionRejectedMessage_RejectionReason value) { assert(::YourActionRejectedMessage_RejectionReason_IsValid(value)); set_has_rejectionreason(); rejectionreason_ = value; + // @@protoc_insertion_point(field_set:YourActionRejectedMessage.rejectionReason) } // ------------------------------------------------------------------- @@ -16657,11 +17854,13 @@ inline void PlayersActionDoneMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 PlayersActionDoneMessage::playerid() const { + // @@protoc_insertion_point(field_get:PlayersActionDoneMessage.playerId) return playerid_; } inline void PlayersActionDoneMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:PlayersActionDoneMessage.playerId) } // required .NetGameState gameState = 2; @@ -16679,12 +17878,14 @@ inline void PlayersActionDoneMessage::clear_gamestate() { clear_has_gamestate(); } inline ::NetGameState PlayersActionDoneMessage::gamestate() const { + // @@protoc_insertion_point(field_get:PlayersActionDoneMessage.gameState) return static_cast< ::NetGameState >(gamestate_); } inline void PlayersActionDoneMessage::set_gamestate(::NetGameState value) { assert(::NetGameState_IsValid(value)); set_has_gamestate(); gamestate_ = value; + // @@protoc_insertion_point(field_set:PlayersActionDoneMessage.gameState) } // required .NetPlayerAction playerAction = 3; @@ -16702,12 +17903,14 @@ inline void PlayersActionDoneMessage::clear_playeraction() { clear_has_playeraction(); } inline ::NetPlayerAction PlayersActionDoneMessage::playeraction() const { + // @@protoc_insertion_point(field_get:PlayersActionDoneMessage.playerAction) return static_cast< ::NetPlayerAction >(playeraction_); } inline void PlayersActionDoneMessage::set_playeraction(::NetPlayerAction value) { assert(::NetPlayerAction_IsValid(value)); set_has_playeraction(); playeraction_ = value; + // @@protoc_insertion_point(field_set:PlayersActionDoneMessage.playerAction) } // required uint32 totalPlayerBet = 4; @@ -16725,11 +17928,13 @@ inline void PlayersActionDoneMessage::clear_totalplayerbet() { clear_has_totalplayerbet(); } inline ::google::protobuf::uint32 PlayersActionDoneMessage::totalplayerbet() const { + // @@protoc_insertion_point(field_get:PlayersActionDoneMessage.totalPlayerBet) return totalplayerbet_; } inline void PlayersActionDoneMessage::set_totalplayerbet(::google::protobuf::uint32 value) { set_has_totalplayerbet(); totalplayerbet_ = value; + // @@protoc_insertion_point(field_set:PlayersActionDoneMessage.totalPlayerBet) } // required uint32 playerMoney = 5; @@ -16747,11 +17952,13 @@ inline void PlayersActionDoneMessage::clear_playermoney() { clear_has_playermoney(); } inline ::google::protobuf::uint32 PlayersActionDoneMessage::playermoney() const { + // @@protoc_insertion_point(field_get:PlayersActionDoneMessage.playerMoney) return playermoney_; } inline void PlayersActionDoneMessage::set_playermoney(::google::protobuf::uint32 value) { set_has_playermoney(); playermoney_ = value; + // @@protoc_insertion_point(field_set:PlayersActionDoneMessage.playerMoney) } // required uint32 highestSet = 6; @@ -16769,11 +17976,13 @@ inline void PlayersActionDoneMessage::clear_highestset() { clear_has_highestset(); } inline ::google::protobuf::uint32 PlayersActionDoneMessage::highestset() const { + // @@protoc_insertion_point(field_get:PlayersActionDoneMessage.highestSet) return highestset_; } inline void PlayersActionDoneMessage::set_highestset(::google::protobuf::uint32 value) { set_has_highestset(); highestset_ = value; + // @@protoc_insertion_point(field_set:PlayersActionDoneMessage.highestSet) } // required uint32 minimumRaise = 7; @@ -16791,11 +18000,13 @@ inline void PlayersActionDoneMessage::clear_minimumraise() { clear_has_minimumraise(); } inline ::google::protobuf::uint32 PlayersActionDoneMessage::minimumraise() const { + // @@protoc_insertion_point(field_get:PlayersActionDoneMessage.minimumRaise) return minimumraise_; } inline void PlayersActionDoneMessage::set_minimumraise(::google::protobuf::uint32 value) { set_has_minimumraise(); minimumraise_ = value; + // @@protoc_insertion_point(field_set:PlayersActionDoneMessage.minimumRaise) } // ------------------------------------------------------------------- @@ -16817,11 +18028,13 @@ inline void DealFlopCardsMessage::clear_flopcard1() { clear_has_flopcard1(); } inline ::google::protobuf::uint32 DealFlopCardsMessage::flopcard1() const { + // @@protoc_insertion_point(field_get:DealFlopCardsMessage.flopCard1) return flopcard1_; } inline void DealFlopCardsMessage::set_flopcard1(::google::protobuf::uint32 value) { set_has_flopcard1(); flopcard1_ = value; + // @@protoc_insertion_point(field_set:DealFlopCardsMessage.flopCard1) } // required uint32 flopCard2 = 2; @@ -16839,11 +18052,13 @@ inline void DealFlopCardsMessage::clear_flopcard2() { clear_has_flopcard2(); } inline ::google::protobuf::uint32 DealFlopCardsMessage::flopcard2() const { + // @@protoc_insertion_point(field_get:DealFlopCardsMessage.flopCard2) return flopcard2_; } inline void DealFlopCardsMessage::set_flopcard2(::google::protobuf::uint32 value) { set_has_flopcard2(); flopcard2_ = value; + // @@protoc_insertion_point(field_set:DealFlopCardsMessage.flopCard2) } // required uint32 flopCard3 = 3; @@ -16861,11 +18076,13 @@ inline void DealFlopCardsMessage::clear_flopcard3() { clear_has_flopcard3(); } inline ::google::protobuf::uint32 DealFlopCardsMessage::flopcard3() const { + // @@protoc_insertion_point(field_get:DealFlopCardsMessage.flopCard3) return flopcard3_; } inline void DealFlopCardsMessage::set_flopcard3(::google::protobuf::uint32 value) { set_has_flopcard3(); flopcard3_ = value; + // @@protoc_insertion_point(field_set:DealFlopCardsMessage.flopCard3) } // ------------------------------------------------------------------- @@ -16887,11 +18104,13 @@ inline void DealTurnCardMessage::clear_turncard() { clear_has_turncard(); } inline ::google::protobuf::uint32 DealTurnCardMessage::turncard() const { + // @@protoc_insertion_point(field_get:DealTurnCardMessage.turnCard) return turncard_; } inline void DealTurnCardMessage::set_turncard(::google::protobuf::uint32 value) { set_has_turncard(); turncard_ = value; + // @@protoc_insertion_point(field_set:DealTurnCardMessage.turnCard) } // ------------------------------------------------------------------- @@ -16913,11 +18132,13 @@ inline void DealRiverCardMessage::clear_rivercard() { clear_has_rivercard(); } inline ::google::protobuf::uint32 DealRiverCardMessage::rivercard() const { + // @@protoc_insertion_point(field_get:DealRiverCardMessage.riverCard) return rivercard_; } inline void DealRiverCardMessage::set_rivercard(::google::protobuf::uint32 value) { set_has_rivercard(); rivercard_ = value; + // @@protoc_insertion_point(field_set:DealRiverCardMessage.riverCard) } // ------------------------------------------------------------------- @@ -16939,11 +18160,13 @@ inline void AllInShowCardsMessage_PlayerAllIn::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 AllInShowCardsMessage_PlayerAllIn::playerid() const { + // @@protoc_insertion_point(field_get:AllInShowCardsMessage.PlayerAllIn.playerId) return playerid_; } inline void AllInShowCardsMessage_PlayerAllIn::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:AllInShowCardsMessage.PlayerAllIn.playerId) } // required uint32 allInCard1 = 2; @@ -16961,11 +18184,13 @@ inline void AllInShowCardsMessage_PlayerAllIn::clear_allincard1() { clear_has_allincard1(); } inline ::google::protobuf::uint32 AllInShowCardsMessage_PlayerAllIn::allincard1() const { + // @@protoc_insertion_point(field_get:AllInShowCardsMessage.PlayerAllIn.allInCard1) return allincard1_; } inline void AllInShowCardsMessage_PlayerAllIn::set_allincard1(::google::protobuf::uint32 value) { set_has_allincard1(); allincard1_ = value; + // @@protoc_insertion_point(field_set:AllInShowCardsMessage.PlayerAllIn.allInCard1) } // required uint32 allInCard2 = 3; @@ -16983,11 +18208,13 @@ inline void AllInShowCardsMessage_PlayerAllIn::clear_allincard2() { clear_has_allincard2(); } inline ::google::protobuf::uint32 AllInShowCardsMessage_PlayerAllIn::allincard2() const { + // @@protoc_insertion_point(field_get:AllInShowCardsMessage.PlayerAllIn.allInCard2) return allincard2_; } inline void AllInShowCardsMessage_PlayerAllIn::set_allincard2(::google::protobuf::uint32 value) { set_has_allincard2(); allincard2_ = value; + // @@protoc_insertion_point(field_set:AllInShowCardsMessage.PlayerAllIn.allInCard2) } // ------------------------------------------------------------------- @@ -17002,20 +18229,25 @@ inline void AllInShowCardsMessage::clear_playersallin() { playersallin_.Clear(); } inline const ::AllInShowCardsMessage_PlayerAllIn& AllInShowCardsMessage::playersallin(int index) const { + // @@protoc_insertion_point(field_get:AllInShowCardsMessage.playersAllIn) return playersallin_.Get(index); } inline ::AllInShowCardsMessage_PlayerAllIn* AllInShowCardsMessage::mutable_playersallin(int index) { + // @@protoc_insertion_point(field_mutable:AllInShowCardsMessage.playersAllIn) return playersallin_.Mutable(index); } inline ::AllInShowCardsMessage_PlayerAllIn* AllInShowCardsMessage::add_playersallin() { + // @@protoc_insertion_point(field_add:AllInShowCardsMessage.playersAllIn) return playersallin_.Add(); } inline const ::google::protobuf::RepeatedPtrField< ::AllInShowCardsMessage_PlayerAllIn >& AllInShowCardsMessage::playersallin() const { + // @@protoc_insertion_point(field_list:AllInShowCardsMessage.playersAllIn) return playersallin_; } inline ::google::protobuf::RepeatedPtrField< ::AllInShowCardsMessage_PlayerAllIn >* AllInShowCardsMessage::mutable_playersallin() { + // @@protoc_insertion_point(field_mutable_list:AllInShowCardsMessage.playersAllIn) return &playersallin_; } @@ -17031,20 +18263,25 @@ inline void EndOfHandShowCardsMessage::clear_playerresults() { playerresults_.Clear(); } inline const ::PlayerResult& EndOfHandShowCardsMessage::playerresults(int index) const { + // @@protoc_insertion_point(field_get:EndOfHandShowCardsMessage.playerResults) return playerresults_.Get(index); } inline ::PlayerResult* EndOfHandShowCardsMessage::mutable_playerresults(int index) { + // @@protoc_insertion_point(field_mutable:EndOfHandShowCardsMessage.playerResults) return playerresults_.Mutable(index); } inline ::PlayerResult* EndOfHandShowCardsMessage::add_playerresults() { + // @@protoc_insertion_point(field_add:EndOfHandShowCardsMessage.playerResults) return playerresults_.Add(); } inline const ::google::protobuf::RepeatedPtrField< ::PlayerResult >& EndOfHandShowCardsMessage::playerresults() const { + // @@protoc_insertion_point(field_list:EndOfHandShowCardsMessage.playerResults) return playerresults_; } inline ::google::protobuf::RepeatedPtrField< ::PlayerResult >* EndOfHandShowCardsMessage::mutable_playerresults() { + // @@protoc_insertion_point(field_mutable_list:EndOfHandShowCardsMessage.playerResults) return &playerresults_; } @@ -17067,11 +18304,13 @@ inline void EndOfHandHideCardsMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 EndOfHandHideCardsMessage::playerid() const { + // @@protoc_insertion_point(field_get:EndOfHandHideCardsMessage.playerId) return playerid_; } inline void EndOfHandHideCardsMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:EndOfHandHideCardsMessage.playerId) } // required uint32 moneyWon = 2; @@ -17089,11 +18328,13 @@ inline void EndOfHandHideCardsMessage::clear_moneywon() { clear_has_moneywon(); } inline ::google::protobuf::uint32 EndOfHandHideCardsMessage::moneywon() const { + // @@protoc_insertion_point(field_get:EndOfHandHideCardsMessage.moneyWon) return moneywon_; } inline void EndOfHandHideCardsMessage::set_moneywon(::google::protobuf::uint32 value) { set_has_moneywon(); moneywon_ = value; + // @@protoc_insertion_point(field_set:EndOfHandHideCardsMessage.moneyWon) } // required uint32 playerMoney = 3; @@ -17111,11 +18352,13 @@ inline void EndOfHandHideCardsMessage::clear_playermoney() { clear_has_playermoney(); } inline ::google::protobuf::uint32 EndOfHandHideCardsMessage::playermoney() const { + // @@protoc_insertion_point(field_get:EndOfHandHideCardsMessage.playerMoney) return playermoney_; } inline void EndOfHandHideCardsMessage::set_playermoney(::google::protobuf::uint32 value) { set_has_playermoney(); playermoney_ = value; + // @@protoc_insertion_point(field_set:EndOfHandHideCardsMessage.playerMoney) } // ------------------------------------------------------------------- @@ -17141,6 +18384,7 @@ inline void AfterHandShowCardsMessage::clear_playerresult() { clear_has_playerresult(); } inline const ::PlayerResult& AfterHandShowCardsMessage::playerresult() const { + // @@protoc_insertion_point(field_get:AfterHandShowCardsMessage.playerResult) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return playerresult_ != NULL ? *playerresult_ : *default_instance().playerresult_; #else @@ -17150,6 +18394,7 @@ inline const ::PlayerResult& AfterHandShowCardsMessage::playerresult() const { inline ::PlayerResult* AfterHandShowCardsMessage::mutable_playerresult() { set_has_playerresult(); if (playerresult_ == NULL) playerresult_ = new ::PlayerResult; + // @@protoc_insertion_point(field_mutable:AfterHandShowCardsMessage.playerResult) return playerresult_; } inline ::PlayerResult* AfterHandShowCardsMessage::release_playerresult() { @@ -17166,6 +18411,7 @@ inline void AfterHandShowCardsMessage::set_allocated_playerresult(::PlayerResult } else { clear_has_playerresult(); } + // @@protoc_insertion_point(field_set_allocated:AfterHandShowCardsMessage.playerResult) } // ------------------------------------------------------------------- @@ -17187,11 +18433,13 @@ inline void EndOfGameMessage::clear_winnerplayerid() { clear_has_winnerplayerid(); } inline ::google::protobuf::uint32 EndOfGameMessage::winnerplayerid() const { + // @@protoc_insertion_point(field_get:EndOfGameMessage.winnerPlayerId) return winnerplayerid_; } inline void EndOfGameMessage::set_winnerplayerid(::google::protobuf::uint32 value) { set_has_winnerplayerid(); winnerplayerid_ = value; + // @@protoc_insertion_point(field_set:EndOfGameMessage.winnerPlayerId) } // ------------------------------------------------------------------- @@ -17213,11 +18461,13 @@ inline void PlayerIdChangedMessage::clear_oldplayerid() { clear_has_oldplayerid(); } inline ::google::protobuf::uint32 PlayerIdChangedMessage::oldplayerid() const { + // @@protoc_insertion_point(field_get:PlayerIdChangedMessage.oldPlayerId) return oldplayerid_; } inline void PlayerIdChangedMessage::set_oldplayerid(::google::protobuf::uint32 value) { set_has_oldplayerid(); oldplayerid_ = value; + // @@protoc_insertion_point(field_set:PlayerIdChangedMessage.oldPlayerId) } // required uint32 newPlayerId = 2; @@ -17235,11 +18485,13 @@ inline void PlayerIdChangedMessage::clear_newplayerid() { clear_has_newplayerid(); } inline ::google::protobuf::uint32 PlayerIdChangedMessage::newplayerid() const { + // @@protoc_insertion_point(field_get:PlayerIdChangedMessage.newPlayerId) return newplayerid_; } inline void PlayerIdChangedMessage::set_newplayerid(::google::protobuf::uint32 value) { set_has_newplayerid(); newplayerid_ = value; + // @@protoc_insertion_point(field_set:PlayerIdChangedMessage.newPlayerId) } // ------------------------------------------------------------------- @@ -17261,11 +18513,13 @@ inline void AskKickPlayerMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 AskKickPlayerMessage::playerid() const { + // @@protoc_insertion_point(field_get:AskKickPlayerMessage.playerId) return playerid_; } inline void AskKickPlayerMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:AskKickPlayerMessage.playerId) } // ------------------------------------------------------------------- @@ -17287,11 +18541,13 @@ inline void AskKickDeniedMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 AskKickDeniedMessage::playerid() const { + // @@protoc_insertion_point(field_get:AskKickDeniedMessage.playerId) return playerid_; } inline void AskKickDeniedMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:AskKickDeniedMessage.playerId) } // required .AskKickDeniedMessage.KickDeniedReason kickDeniedReason = 2; @@ -17309,12 +18565,14 @@ inline void AskKickDeniedMessage::clear_kickdeniedreason() { clear_has_kickdeniedreason(); } inline ::AskKickDeniedMessage_KickDeniedReason AskKickDeniedMessage::kickdeniedreason() const { + // @@protoc_insertion_point(field_get:AskKickDeniedMessage.kickDeniedReason) return static_cast< ::AskKickDeniedMessage_KickDeniedReason >(kickdeniedreason_); } inline void AskKickDeniedMessage::set_kickdeniedreason(::AskKickDeniedMessage_KickDeniedReason value) { assert(::AskKickDeniedMessage_KickDeniedReason_IsValid(value)); set_has_kickdeniedreason(); kickdeniedreason_ = value; + // @@protoc_insertion_point(field_set:AskKickDeniedMessage.kickDeniedReason) } // ------------------------------------------------------------------- @@ -17336,11 +18594,13 @@ inline void StartKickPetitionMessage::clear_petitionid() { clear_has_petitionid(); } inline ::google::protobuf::uint32 StartKickPetitionMessage::petitionid() const { + // @@protoc_insertion_point(field_get:StartKickPetitionMessage.petitionId) return petitionid_; } inline void StartKickPetitionMessage::set_petitionid(::google::protobuf::uint32 value) { set_has_petitionid(); petitionid_ = value; + // @@protoc_insertion_point(field_set:StartKickPetitionMessage.petitionId) } // required uint32 proposingPlayerId = 2; @@ -17358,11 +18618,13 @@ inline void StartKickPetitionMessage::clear_proposingplayerid() { clear_has_proposingplayerid(); } inline ::google::protobuf::uint32 StartKickPetitionMessage::proposingplayerid() const { + // @@protoc_insertion_point(field_get:StartKickPetitionMessage.proposingPlayerId) return proposingplayerid_; } inline void StartKickPetitionMessage::set_proposingplayerid(::google::protobuf::uint32 value) { set_has_proposingplayerid(); proposingplayerid_ = value; + // @@protoc_insertion_point(field_set:StartKickPetitionMessage.proposingPlayerId) } // required uint32 kickPlayerId = 3; @@ -17380,11 +18642,13 @@ inline void StartKickPetitionMessage::clear_kickplayerid() { clear_has_kickplayerid(); } inline ::google::protobuf::uint32 StartKickPetitionMessage::kickplayerid() const { + // @@protoc_insertion_point(field_get:StartKickPetitionMessage.kickPlayerId) return kickplayerid_; } inline void StartKickPetitionMessage::set_kickplayerid(::google::protobuf::uint32 value) { set_has_kickplayerid(); kickplayerid_ = value; + // @@protoc_insertion_point(field_set:StartKickPetitionMessage.kickPlayerId) } // required uint32 kickTimeoutSec = 4; @@ -17402,11 +18666,13 @@ inline void StartKickPetitionMessage::clear_kicktimeoutsec() { clear_has_kicktimeoutsec(); } inline ::google::protobuf::uint32 StartKickPetitionMessage::kicktimeoutsec() const { + // @@protoc_insertion_point(field_get:StartKickPetitionMessage.kickTimeoutSec) return kicktimeoutsec_; } inline void StartKickPetitionMessage::set_kicktimeoutsec(::google::protobuf::uint32 value) { set_has_kicktimeoutsec(); kicktimeoutsec_ = value; + // @@protoc_insertion_point(field_set:StartKickPetitionMessage.kickTimeoutSec) } // required uint32 numVotesNeededToKick = 5; @@ -17424,11 +18690,13 @@ inline void StartKickPetitionMessage::clear_numvotesneededtokick() { clear_has_numvotesneededtokick(); } inline ::google::protobuf::uint32 StartKickPetitionMessage::numvotesneededtokick() const { + // @@protoc_insertion_point(field_get:StartKickPetitionMessage.numVotesNeededToKick) return numvotesneededtokick_; } inline void StartKickPetitionMessage::set_numvotesneededtokick(::google::protobuf::uint32 value) { set_has_numvotesneededtokick(); numvotesneededtokick_ = value; + // @@protoc_insertion_point(field_set:StartKickPetitionMessage.numVotesNeededToKick) } // ------------------------------------------------------------------- @@ -17450,11 +18718,13 @@ inline void VoteKickRequestMessage::clear_petitionid() { clear_has_petitionid(); } inline ::google::protobuf::uint32 VoteKickRequestMessage::petitionid() const { + // @@protoc_insertion_point(field_get:VoteKickRequestMessage.petitionId) return petitionid_; } inline void VoteKickRequestMessage::set_petitionid(::google::protobuf::uint32 value) { set_has_petitionid(); petitionid_ = value; + // @@protoc_insertion_point(field_set:VoteKickRequestMessage.petitionId) } // required bool voteKick = 2; @@ -17472,11 +18742,13 @@ inline void VoteKickRequestMessage::clear_votekick() { clear_has_votekick(); } inline bool VoteKickRequestMessage::votekick() const { + // @@protoc_insertion_point(field_get:VoteKickRequestMessage.voteKick) return votekick_; } inline void VoteKickRequestMessage::set_votekick(bool value) { set_has_votekick(); votekick_ = value; + // @@protoc_insertion_point(field_set:VoteKickRequestMessage.voteKick) } // ------------------------------------------------------------------- @@ -17498,11 +18770,13 @@ inline void VoteKickReplyMessage::clear_petitionid() { clear_has_petitionid(); } inline ::google::protobuf::uint32 VoteKickReplyMessage::petitionid() const { + // @@protoc_insertion_point(field_get:VoteKickReplyMessage.petitionId) return petitionid_; } inline void VoteKickReplyMessage::set_petitionid(::google::protobuf::uint32 value) { set_has_petitionid(); petitionid_ = value; + // @@protoc_insertion_point(field_set:VoteKickReplyMessage.petitionId) } // required .VoteKickReplyMessage.VoteKickReplyType voteKickReplyType = 2; @@ -17520,12 +18794,14 @@ inline void VoteKickReplyMessage::clear_votekickreplytype() { clear_has_votekickreplytype(); } inline ::VoteKickReplyMessage_VoteKickReplyType VoteKickReplyMessage::votekickreplytype() const { + // @@protoc_insertion_point(field_get:VoteKickReplyMessage.voteKickReplyType) return static_cast< ::VoteKickReplyMessage_VoteKickReplyType >(votekickreplytype_); } inline void VoteKickReplyMessage::set_votekickreplytype(::VoteKickReplyMessage_VoteKickReplyType value) { assert(::VoteKickReplyMessage_VoteKickReplyType_IsValid(value)); set_has_votekickreplytype(); votekickreplytype_ = value; + // @@protoc_insertion_point(field_set:VoteKickReplyMessage.voteKickReplyType) } // ------------------------------------------------------------------- @@ -17547,11 +18823,13 @@ inline void KickPetitionUpdateMessage::clear_petitionid() { clear_has_petitionid(); } inline ::google::protobuf::uint32 KickPetitionUpdateMessage::petitionid() const { + // @@protoc_insertion_point(field_get:KickPetitionUpdateMessage.petitionId) return petitionid_; } inline void KickPetitionUpdateMessage::set_petitionid(::google::protobuf::uint32 value) { set_has_petitionid(); petitionid_ = value; + // @@protoc_insertion_point(field_set:KickPetitionUpdateMessage.petitionId) } // required uint32 numVotesAgainstKicking = 2; @@ -17569,11 +18847,13 @@ inline void KickPetitionUpdateMessage::clear_numvotesagainstkicking() { clear_has_numvotesagainstkicking(); } inline ::google::protobuf::uint32 KickPetitionUpdateMessage::numvotesagainstkicking() const { + // @@protoc_insertion_point(field_get:KickPetitionUpdateMessage.numVotesAgainstKicking) return numvotesagainstkicking_; } inline void KickPetitionUpdateMessage::set_numvotesagainstkicking(::google::protobuf::uint32 value) { set_has_numvotesagainstkicking(); numvotesagainstkicking_ = value; + // @@protoc_insertion_point(field_set:KickPetitionUpdateMessage.numVotesAgainstKicking) } // required uint32 numVotesInFavourOfKicking = 3; @@ -17591,11 +18871,13 @@ inline void KickPetitionUpdateMessage::clear_numvotesinfavourofkicking() { clear_has_numvotesinfavourofkicking(); } inline ::google::protobuf::uint32 KickPetitionUpdateMessage::numvotesinfavourofkicking() const { + // @@protoc_insertion_point(field_get:KickPetitionUpdateMessage.numVotesInFavourOfKicking) return numvotesinfavourofkicking_; } inline void KickPetitionUpdateMessage::set_numvotesinfavourofkicking(::google::protobuf::uint32 value) { set_has_numvotesinfavourofkicking(); numvotesinfavourofkicking_ = value; + // @@protoc_insertion_point(field_set:KickPetitionUpdateMessage.numVotesInFavourOfKicking) } // required uint32 numVotesNeededToKick = 4; @@ -17613,11 +18895,13 @@ inline void KickPetitionUpdateMessage::clear_numvotesneededtokick() { clear_has_numvotesneededtokick(); } inline ::google::protobuf::uint32 KickPetitionUpdateMessage::numvotesneededtokick() const { + // @@protoc_insertion_point(field_get:KickPetitionUpdateMessage.numVotesNeededToKick) return numvotesneededtokick_; } inline void KickPetitionUpdateMessage::set_numvotesneededtokick(::google::protobuf::uint32 value) { set_has_numvotesneededtokick(); numvotesneededtokick_ = value; + // @@protoc_insertion_point(field_set:KickPetitionUpdateMessage.numVotesNeededToKick) } // ------------------------------------------------------------------- @@ -17639,11 +18923,13 @@ inline void EndKickPetitionMessage::clear_petitionid() { clear_has_petitionid(); } inline ::google::protobuf::uint32 EndKickPetitionMessage::petitionid() const { + // @@protoc_insertion_point(field_get:EndKickPetitionMessage.petitionId) return petitionid_; } inline void EndKickPetitionMessage::set_petitionid(::google::protobuf::uint32 value) { set_has_petitionid(); petitionid_ = value; + // @@protoc_insertion_point(field_set:EndKickPetitionMessage.petitionId) } // required uint32 numVotesAgainstKicking = 2; @@ -17661,11 +18947,13 @@ inline void EndKickPetitionMessage::clear_numvotesagainstkicking() { clear_has_numvotesagainstkicking(); } inline ::google::protobuf::uint32 EndKickPetitionMessage::numvotesagainstkicking() const { + // @@protoc_insertion_point(field_get:EndKickPetitionMessage.numVotesAgainstKicking) return numvotesagainstkicking_; } inline void EndKickPetitionMessage::set_numvotesagainstkicking(::google::protobuf::uint32 value) { set_has_numvotesagainstkicking(); numvotesagainstkicking_ = value; + // @@protoc_insertion_point(field_set:EndKickPetitionMessage.numVotesAgainstKicking) } // required uint32 numVotesInFavourOfKicking = 3; @@ -17683,11 +18971,13 @@ inline void EndKickPetitionMessage::clear_numvotesinfavourofkicking() { clear_has_numvotesinfavourofkicking(); } inline ::google::protobuf::uint32 EndKickPetitionMessage::numvotesinfavourofkicking() const { + // @@protoc_insertion_point(field_get:EndKickPetitionMessage.numVotesInFavourOfKicking) return numvotesinfavourofkicking_; } inline void EndKickPetitionMessage::set_numvotesinfavourofkicking(::google::protobuf::uint32 value) { set_has_numvotesinfavourofkicking(); numvotesinfavourofkicking_ = value; + // @@protoc_insertion_point(field_set:EndKickPetitionMessage.numVotesInFavourOfKicking) } // required uint32 resultPlayerKicked = 4; @@ -17705,11 +18995,13 @@ inline void EndKickPetitionMessage::clear_resultplayerkicked() { clear_has_resultplayerkicked(); } inline ::google::protobuf::uint32 EndKickPetitionMessage::resultplayerkicked() const { + // @@protoc_insertion_point(field_get:EndKickPetitionMessage.resultPlayerKicked) return resultplayerkicked_; } inline void EndKickPetitionMessage::set_resultplayerkicked(::google::protobuf::uint32 value) { set_has_resultplayerkicked(); resultplayerkicked_ = value; + // @@protoc_insertion_point(field_set:EndKickPetitionMessage.resultPlayerKicked) } // required .EndKickPetitionMessage.PetitionEndReason petitionEndReason = 5; @@ -17727,12 +19019,14 @@ inline void EndKickPetitionMessage::clear_petitionendreason() { clear_has_petitionendreason(); } inline ::EndKickPetitionMessage_PetitionEndReason EndKickPetitionMessage::petitionendreason() const { + // @@protoc_insertion_point(field_get:EndKickPetitionMessage.petitionEndReason) return static_cast< ::EndKickPetitionMessage_PetitionEndReason >(petitionendreason_); } inline void EndKickPetitionMessage::set_petitionendreason(::EndKickPetitionMessage_PetitionEndReason value) { assert(::EndKickPetitionMessage_PetitionEndReason_IsValid(value)); set_has_petitionendreason(); petitionendreason_ = value; + // @@protoc_insertion_point(field_set:EndKickPetitionMessage.petitionEndReason) } // ------------------------------------------------------------------- @@ -17754,12 +19048,14 @@ inline void StatisticsMessage_StatisticsData::clear_statisticstype() { clear_has_statisticstype(); } inline ::StatisticsMessage_StatisticsData_StatisticsType StatisticsMessage_StatisticsData::statisticstype() const { + // @@protoc_insertion_point(field_get:StatisticsMessage.StatisticsData.statisticsType) return static_cast< ::StatisticsMessage_StatisticsData_StatisticsType >(statisticstype_); } inline void StatisticsMessage_StatisticsData::set_statisticstype(::StatisticsMessage_StatisticsData_StatisticsType value) { assert(::StatisticsMessage_StatisticsData_StatisticsType_IsValid(value)); set_has_statisticstype(); statisticstype_ = value; + // @@protoc_insertion_point(field_set:StatisticsMessage.StatisticsData.statisticsType) } // required uint32 statisticsValue = 2; @@ -17777,11 +19073,13 @@ inline void StatisticsMessage_StatisticsData::clear_statisticsvalue() { clear_has_statisticsvalue(); } inline ::google::protobuf::uint32 StatisticsMessage_StatisticsData::statisticsvalue() const { + // @@protoc_insertion_point(field_get:StatisticsMessage.StatisticsData.statisticsValue) return statisticsvalue_; } inline void StatisticsMessage_StatisticsData::set_statisticsvalue(::google::protobuf::uint32 value) { set_has_statisticsvalue(); statisticsvalue_ = value; + // @@protoc_insertion_point(field_set:StatisticsMessage.StatisticsData.statisticsValue) } // ------------------------------------------------------------------- @@ -17796,20 +19094,25 @@ inline void StatisticsMessage::clear_statisticsdata() { statisticsdata_.Clear(); } inline const ::StatisticsMessage_StatisticsData& StatisticsMessage::statisticsdata(int index) const { + // @@protoc_insertion_point(field_get:StatisticsMessage.statisticsData) return statisticsdata_.Get(index); } inline ::StatisticsMessage_StatisticsData* StatisticsMessage::mutable_statisticsdata(int index) { + // @@protoc_insertion_point(field_mutable:StatisticsMessage.statisticsData) return statisticsdata_.Mutable(index); } inline ::StatisticsMessage_StatisticsData* StatisticsMessage::add_statisticsdata() { + // @@protoc_insertion_point(field_add:StatisticsMessage.statisticsData) return statisticsdata_.Add(); } inline const ::google::protobuf::RepeatedPtrField< ::StatisticsMessage_StatisticsData >& StatisticsMessage::statisticsdata() const { + // @@protoc_insertion_point(field_list:StatisticsMessage.statisticsData) return statisticsdata_; } inline ::google::protobuf::RepeatedPtrField< ::StatisticsMessage_StatisticsData >* StatisticsMessage::mutable_statisticsdata() { + // @@protoc_insertion_point(field_mutable_list:StatisticsMessage.statisticsData) return &statisticsdata_; } @@ -17832,11 +19135,13 @@ inline void ChatRequestMessage::clear_targetplayerid() { clear_has_targetplayerid(); } inline ::google::protobuf::uint32 ChatRequestMessage::targetplayerid() const { + // @@protoc_insertion_point(field_get:ChatRequestMessage.targetPlayerId) return targetplayerid_; } inline void ChatRequestMessage::set_targetplayerid(::google::protobuf::uint32 value) { set_has_targetplayerid(); targetplayerid_ = value; + // @@protoc_insertion_point(field_set:ChatRequestMessage.targetPlayerId) } // required string chatText = 3; @@ -17850,54 +19155,59 @@ inline void ChatRequestMessage::clear_has_chattext() { _has_bits_[0] &= ~0x00000002u; } inline void ChatRequestMessage::clear_chattext() { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_->clear(); } clear_has_chattext(); } inline const ::std::string& ChatRequestMessage::chattext() const { + // @@protoc_insertion_point(field_get:ChatRequestMessage.chatText) return *chattext_; } inline void ChatRequestMessage::set_chattext(const ::std::string& value) { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } chattext_->assign(value); + // @@protoc_insertion_point(field_set:ChatRequestMessage.chatText) } inline void ChatRequestMessage::set_chattext(const char* value) { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } chattext_->assign(value); + // @@protoc_insertion_point(field_set_char:ChatRequestMessage.chatText) } inline void ChatRequestMessage::set_chattext(const char* value, size_t size) { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } chattext_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:ChatRequestMessage.chatText) } inline ::std::string* ChatRequestMessage::mutable_chattext() { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:ChatRequestMessage.chatText) return chattext_; } inline ::std::string* ChatRequestMessage::release_chattext() { clear_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = chattext_; - chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void ChatRequestMessage::set_allocated_chattext(::std::string* chattext) { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete chattext_; } if (chattext) { @@ -17905,8 +19215,9 @@ inline void ChatRequestMessage::set_allocated_chattext(::std::string* chattext) chattext_ = chattext; } else { clear_has_chattext(); - chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:ChatRequestMessage.chatText) } // ------------------------------------------------------------------- @@ -17928,11 +19239,13 @@ inline void ChatMessage::clear_playerid() { clear_has_playerid(); } inline ::google::protobuf::uint32 ChatMessage::playerid() const { + // @@protoc_insertion_point(field_get:ChatMessage.playerId) return playerid_; } inline void ChatMessage::set_playerid(::google::protobuf::uint32 value) { set_has_playerid(); playerid_ = value; + // @@protoc_insertion_point(field_set:ChatMessage.playerId) } // required .ChatMessage.ChatType chatType = 2; @@ -17950,12 +19263,14 @@ inline void ChatMessage::clear_chattype() { clear_has_chattype(); } inline ::ChatMessage_ChatType ChatMessage::chattype() const { + // @@protoc_insertion_point(field_get:ChatMessage.chatType) return static_cast< ::ChatMessage_ChatType >(chattype_); } inline void ChatMessage::set_chattype(::ChatMessage_ChatType value) { assert(::ChatMessage_ChatType_IsValid(value)); set_has_chattype(); chattype_ = value; + // @@protoc_insertion_point(field_set:ChatMessage.chatType) } // required string chatText = 3; @@ -17969,54 +19284,59 @@ inline void ChatMessage::clear_has_chattext() { _has_bits_[0] &= ~0x00000004u; } inline void ChatMessage::clear_chattext() { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_->clear(); } clear_has_chattext(); } inline const ::std::string& ChatMessage::chattext() const { + // @@protoc_insertion_point(field_get:ChatMessage.chatText) return *chattext_; } inline void ChatMessage::set_chattext(const ::std::string& value) { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } chattext_->assign(value); + // @@protoc_insertion_point(field_set:ChatMessage.chatText) } inline void ChatMessage::set_chattext(const char* value) { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } chattext_->assign(value); + // @@protoc_insertion_point(field_set_char:ChatMessage.chatText) } inline void ChatMessage::set_chattext(const char* value, size_t size) { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } chattext_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:ChatMessage.chatText) } inline ::std::string* ChatMessage::mutable_chattext() { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:ChatMessage.chatText) return chattext_; } inline ::std::string* ChatMessage::release_chattext() { clear_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = chattext_; - chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void ChatMessage::set_allocated_chattext(::std::string* chattext) { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete chattext_; } if (chattext) { @@ -18024,8 +19344,9 @@ inline void ChatMessage::set_allocated_chattext(::std::string* chattext) { chattext_ = chattext; } else { clear_has_chattext(); - chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:ChatMessage.chatText) } // ------------------------------------------------------------------- @@ -18043,54 +19364,59 @@ inline void ChatRejectMessage::clear_has_chattext() { _has_bits_[0] &= ~0x00000001u; } inline void ChatRejectMessage::clear_chattext() { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_->clear(); } clear_has_chattext(); } inline const ::std::string& ChatRejectMessage::chattext() const { + // @@protoc_insertion_point(field_get:ChatRejectMessage.chatText) return *chattext_; } inline void ChatRejectMessage::set_chattext(const ::std::string& value) { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } chattext_->assign(value); + // @@protoc_insertion_point(field_set:ChatRejectMessage.chatText) } inline void ChatRejectMessage::set_chattext(const char* value) { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } chattext_->assign(value); + // @@protoc_insertion_point(field_set_char:ChatRejectMessage.chatText) } inline void ChatRejectMessage::set_chattext(const char* value, size_t size) { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } chattext_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:ChatRejectMessage.chatText) } inline ::std::string* ChatRejectMessage::mutable_chattext() { set_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { chattext_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:ChatRejectMessage.chatText) return chattext_; } inline ::std::string* ChatRejectMessage::release_chattext() { clear_has_chattext(); - if (chattext_ == &::google::protobuf::internal::kEmptyString) { + if (chattext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = chattext_; - chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void ChatRejectMessage::set_allocated_chattext(::std::string* chattext) { - if (chattext_ != &::google::protobuf::internal::kEmptyString) { + if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete chattext_; } if (chattext) { @@ -18098,8 +19424,9 @@ inline void ChatRejectMessage::set_allocated_chattext(::std::string* chattext) { chattext_ = chattext; } else { clear_has_chattext(); - chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:ChatRejectMessage.chatText) } // ------------------------------------------------------------------- @@ -18117,54 +19444,59 @@ inline void DialogMessage::clear_has_notificationtext() { _has_bits_[0] &= ~0x00000001u; } inline void DialogMessage::clear_notificationtext() { - if (notificationtext_ != &::google::protobuf::internal::kEmptyString) { + if (notificationtext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { notificationtext_->clear(); } clear_has_notificationtext(); } inline const ::std::string& DialogMessage::notificationtext() const { + // @@protoc_insertion_point(field_get:DialogMessage.notificationText) return *notificationtext_; } inline void DialogMessage::set_notificationtext(const ::std::string& value) { set_has_notificationtext(); - if (notificationtext_ == &::google::protobuf::internal::kEmptyString) { + if (notificationtext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { notificationtext_ = new ::std::string; } notificationtext_->assign(value); + // @@protoc_insertion_point(field_set:DialogMessage.notificationText) } inline void DialogMessage::set_notificationtext(const char* value) { set_has_notificationtext(); - if (notificationtext_ == &::google::protobuf::internal::kEmptyString) { + if (notificationtext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { notificationtext_ = new ::std::string; } notificationtext_->assign(value); + // @@protoc_insertion_point(field_set_char:DialogMessage.notificationText) } inline void DialogMessage::set_notificationtext(const char* value, size_t size) { set_has_notificationtext(); - if (notificationtext_ == &::google::protobuf::internal::kEmptyString) { + if (notificationtext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { notificationtext_ = new ::std::string; } notificationtext_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:DialogMessage.notificationText) } inline ::std::string* DialogMessage::mutable_notificationtext() { set_has_notificationtext(); - if (notificationtext_ == &::google::protobuf::internal::kEmptyString) { + if (notificationtext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { notificationtext_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:DialogMessage.notificationText) return notificationtext_; } inline ::std::string* DialogMessage::release_notificationtext() { clear_has_notificationtext(); - if (notificationtext_ == &::google::protobuf::internal::kEmptyString) { + if (notificationtext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = notificationtext_; - notificationtext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + notificationtext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void DialogMessage::set_allocated_notificationtext(::std::string* notificationtext) { - if (notificationtext_ != &::google::protobuf::internal::kEmptyString) { + if (notificationtext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete notificationtext_; } if (notificationtext) { @@ -18172,8 +19504,9 @@ inline void DialogMessage::set_allocated_notificationtext(::std::string* notific notificationtext_ = notificationtext; } else { clear_has_notificationtext(); - notificationtext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + notificationtext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:DialogMessage.notificationText) } // ------------------------------------------------------------------- @@ -18195,12 +19528,14 @@ inline void TimeoutWarningMessage::clear_timeoutreason() { clear_has_timeoutreason(); } inline ::TimeoutWarningMessage_TimeoutReason TimeoutWarningMessage::timeoutreason() const { + // @@protoc_insertion_point(field_get:TimeoutWarningMessage.timeoutReason) return static_cast< ::TimeoutWarningMessage_TimeoutReason >(timeoutreason_); } inline void TimeoutWarningMessage::set_timeoutreason(::TimeoutWarningMessage_TimeoutReason value) { assert(::TimeoutWarningMessage_TimeoutReason_IsValid(value)); set_has_timeoutreason(); timeoutreason_ = value; + // @@protoc_insertion_point(field_set:TimeoutWarningMessage.timeoutReason) } // required uint32 remainingSeconds = 2; @@ -18218,11 +19553,13 @@ inline void TimeoutWarningMessage::clear_remainingseconds() { clear_has_remainingseconds(); } inline ::google::protobuf::uint32 TimeoutWarningMessage::remainingseconds() const { + // @@protoc_insertion_point(field_get:TimeoutWarningMessage.remainingSeconds) return remainingseconds_; } inline void TimeoutWarningMessage::set_remainingseconds(::google::protobuf::uint32 value) { set_has_remainingseconds(); remainingseconds_ = value; + // @@protoc_insertion_point(field_set:TimeoutWarningMessage.remainingSeconds) } // ------------------------------------------------------------------- @@ -18248,11 +19585,13 @@ inline void ReportAvatarMessage::clear_reportedplayerid() { clear_has_reportedplayerid(); } inline ::google::protobuf::uint32 ReportAvatarMessage::reportedplayerid() const { + // @@protoc_insertion_point(field_get:ReportAvatarMessage.reportedPlayerId) return reportedplayerid_; } inline void ReportAvatarMessage::set_reportedplayerid(::google::protobuf::uint32 value) { set_has_reportedplayerid(); reportedplayerid_ = value; + // @@protoc_insertion_point(field_set:ReportAvatarMessage.reportedPlayerId) } // required bytes reportedAvatarHash = 2; @@ -18266,54 +19605,59 @@ inline void ReportAvatarMessage::clear_has_reportedavatarhash() { _has_bits_[0] &= ~0x00000002u; } inline void ReportAvatarMessage::clear_reportedavatarhash() { - if (reportedavatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (reportedavatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { reportedavatarhash_->clear(); } clear_has_reportedavatarhash(); } inline const ::std::string& ReportAvatarMessage::reportedavatarhash() const { + // @@protoc_insertion_point(field_get:ReportAvatarMessage.reportedAvatarHash) return *reportedavatarhash_; } inline void ReportAvatarMessage::set_reportedavatarhash(const ::std::string& value) { set_has_reportedavatarhash(); - if (reportedavatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (reportedavatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { reportedavatarhash_ = new ::std::string; } reportedavatarhash_->assign(value); + // @@protoc_insertion_point(field_set:ReportAvatarMessage.reportedAvatarHash) } inline void ReportAvatarMessage::set_reportedavatarhash(const char* value) { set_has_reportedavatarhash(); - if (reportedavatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (reportedavatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { reportedavatarhash_ = new ::std::string; } reportedavatarhash_->assign(value); + // @@protoc_insertion_point(field_set_char:ReportAvatarMessage.reportedAvatarHash) } inline void ReportAvatarMessage::set_reportedavatarhash(const void* value, size_t size) { set_has_reportedavatarhash(); - if (reportedavatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (reportedavatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { reportedavatarhash_ = new ::std::string; } reportedavatarhash_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:ReportAvatarMessage.reportedAvatarHash) } inline ::std::string* ReportAvatarMessage::mutable_reportedavatarhash() { set_has_reportedavatarhash(); - if (reportedavatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (reportedavatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { reportedavatarhash_ = new ::std::string; } + // @@protoc_insertion_point(field_mutable:ReportAvatarMessage.reportedAvatarHash) return reportedavatarhash_; } inline ::std::string* ReportAvatarMessage::release_reportedavatarhash() { clear_has_reportedavatarhash(); - if (reportedavatarhash_ == &::google::protobuf::internal::kEmptyString) { + if (reportedavatarhash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { return NULL; } else { ::std::string* temp = reportedavatarhash_; - reportedavatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + reportedavatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); return temp; } } inline void ReportAvatarMessage::set_allocated_reportedavatarhash(::std::string* reportedavatarhash) { - if (reportedavatarhash_ != &::google::protobuf::internal::kEmptyString) { + if (reportedavatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { delete reportedavatarhash_; } if (reportedavatarhash) { @@ -18321,8 +19665,9 @@ inline void ReportAvatarMessage::set_allocated_reportedavatarhash(::std::string* reportedavatarhash_ = reportedavatarhash; } else { clear_has_reportedavatarhash(); - reportedavatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + reportedavatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); } + // @@protoc_insertion_point(field_set_allocated:ReportAvatarMessage.reportedAvatarHash) } // ------------------------------------------------------------------- @@ -18344,11 +19689,13 @@ inline void ReportAvatarAckMessage::clear_reportedplayerid() { clear_has_reportedplayerid(); } inline ::google::protobuf::uint32 ReportAvatarAckMessage::reportedplayerid() const { + // @@protoc_insertion_point(field_get:ReportAvatarAckMessage.reportedPlayerId) return reportedplayerid_; } inline void ReportAvatarAckMessage::set_reportedplayerid(::google::protobuf::uint32 value) { set_has_reportedplayerid(); reportedplayerid_ = value; + // @@protoc_insertion_point(field_set:ReportAvatarAckMessage.reportedPlayerId) } // required .ReportAvatarAckMessage.ReportAvatarResult reportAvatarResult = 2; @@ -18366,12 +19713,14 @@ inline void ReportAvatarAckMessage::clear_reportavatarresult() { clear_has_reportavatarresult(); } inline ::ReportAvatarAckMessage_ReportAvatarResult ReportAvatarAckMessage::reportavatarresult() const { + // @@protoc_insertion_point(field_get:ReportAvatarAckMessage.reportAvatarResult) return static_cast< ::ReportAvatarAckMessage_ReportAvatarResult >(reportavatarresult_); } inline void ReportAvatarAckMessage::set_reportavatarresult(::ReportAvatarAckMessage_ReportAvatarResult value) { assert(::ReportAvatarAckMessage_ReportAvatarResult_IsValid(value)); set_has_reportavatarresult(); reportavatarresult_ = value; + // @@protoc_insertion_point(field_set:ReportAvatarAckMessage.reportAvatarResult) } // ------------------------------------------------------------------- @@ -18393,11 +19742,13 @@ inline void ReportGameMessage::clear_reportedgameid() { clear_has_reportedgameid(); } inline ::google::protobuf::uint32 ReportGameMessage::reportedgameid() const { + // @@protoc_insertion_point(field_get:ReportGameMessage.reportedGameId) return reportedgameid_; } inline void ReportGameMessage::set_reportedgameid(::google::protobuf::uint32 value) { set_has_reportedgameid(); reportedgameid_ = value; + // @@protoc_insertion_point(field_set:ReportGameMessage.reportedGameId) } // ------------------------------------------------------------------- @@ -18419,11 +19770,13 @@ inline void ReportGameAckMessage::clear_reportedgameid() { clear_has_reportedgameid(); } inline ::google::protobuf::uint32 ReportGameAckMessage::reportedgameid() const { + // @@protoc_insertion_point(field_get:ReportGameAckMessage.reportedGameId) return reportedgameid_; } inline void ReportGameAckMessage::set_reportedgameid(::google::protobuf::uint32 value) { set_has_reportedgameid(); reportedgameid_ = value; + // @@protoc_insertion_point(field_set:ReportGameAckMessage.reportedGameId) } // required .ReportGameAckMessage.ReportGameResult reportGameResult = 2; @@ -18441,12 +19794,14 @@ inline void ReportGameAckMessage::clear_reportgameresult() { clear_has_reportgameresult(); } inline ::ReportGameAckMessage_ReportGameResult ReportGameAckMessage::reportgameresult() const { + // @@protoc_insertion_point(field_get:ReportGameAckMessage.reportGameResult) return static_cast< ::ReportGameAckMessage_ReportGameResult >(reportgameresult_); } inline void ReportGameAckMessage::set_reportgameresult(::ReportGameAckMessage_ReportGameResult value) { assert(::ReportGameAckMessage_ReportGameResult_IsValid(value)); set_has_reportgameresult(); reportgameresult_ = value; + // @@protoc_insertion_point(field_set:ReportGameAckMessage.reportGameResult) } // ------------------------------------------------------------------- @@ -18468,12 +19823,14 @@ inline void ErrorMessage::clear_errorreason() { clear_has_errorreason(); } inline ::ErrorMessage_ErrorReason ErrorMessage::errorreason() const { + // @@protoc_insertion_point(field_get:ErrorMessage.errorReason) return static_cast< ::ErrorMessage_ErrorReason >(errorreason_); } inline void ErrorMessage::set_errorreason(::ErrorMessage_ErrorReason value) { assert(::ErrorMessage_ErrorReason_IsValid(value)); set_has_errorreason(); errorreason_ = value; + // @@protoc_insertion_point(field_set:ErrorMessage.errorReason) } // ------------------------------------------------------------------- @@ -18495,11 +19852,13 @@ inline void AdminRemoveGameMessage::clear_removegameid() { clear_has_removegameid(); } inline ::google::protobuf::uint32 AdminRemoveGameMessage::removegameid() const { + // @@protoc_insertion_point(field_get:AdminRemoveGameMessage.removeGameId) return removegameid_; } inline void AdminRemoveGameMessage::set_removegameid(::google::protobuf::uint32 value) { set_has_removegameid(); removegameid_ = value; + // @@protoc_insertion_point(field_set:AdminRemoveGameMessage.removeGameId) } // ------------------------------------------------------------------- @@ -18521,11 +19880,13 @@ inline void AdminRemoveGameAckMessage::clear_removegameid() { clear_has_removegameid(); } inline ::google::protobuf::uint32 AdminRemoveGameAckMessage::removegameid() const { + // @@protoc_insertion_point(field_get:AdminRemoveGameAckMessage.removeGameId) return removegameid_; } inline void AdminRemoveGameAckMessage::set_removegameid(::google::protobuf::uint32 value) { set_has_removegameid(); removegameid_ = value; + // @@protoc_insertion_point(field_set:AdminRemoveGameAckMessage.removeGameId) } // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; @@ -18543,12 +19904,14 @@ inline void AdminRemoveGameAckMessage::clear_removegameresult() { clear_has_removegameresult(); } inline ::AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::removegameresult() const { + // @@protoc_insertion_point(field_get:AdminRemoveGameAckMessage.removeGameResult) return static_cast< ::AdminRemoveGameAckMessage_AdminRemoveGameResult >(removegameresult_); } inline void AdminRemoveGameAckMessage::set_removegameresult(::AdminRemoveGameAckMessage_AdminRemoveGameResult value) { assert(::AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(value)); set_has_removegameresult(); removegameresult_ = value; + // @@protoc_insertion_point(field_set:AdminRemoveGameAckMessage.removeGameResult) } // ------------------------------------------------------------------- @@ -18570,11 +19933,13 @@ inline void AdminBanPlayerMessage::clear_banplayerid() { clear_has_banplayerid(); } inline ::google::protobuf::uint32 AdminBanPlayerMessage::banplayerid() const { + // @@protoc_insertion_point(field_get:AdminBanPlayerMessage.banPlayerId) return banplayerid_; } inline void AdminBanPlayerMessage::set_banplayerid(::google::protobuf::uint32 value) { set_has_banplayerid(); banplayerid_ = value; + // @@protoc_insertion_point(field_set:AdminBanPlayerMessage.banPlayerId) } // ------------------------------------------------------------------- @@ -18596,11 +19961,13 @@ inline void AdminBanPlayerAckMessage::clear_banplayerid() { clear_has_banplayerid(); } inline ::google::protobuf::uint32 AdminBanPlayerAckMessage::banplayerid() const { + // @@protoc_insertion_point(field_get:AdminBanPlayerAckMessage.banPlayerId) return banplayerid_; } inline void AdminBanPlayerAckMessage::set_banplayerid(::google::protobuf::uint32 value) { set_has_banplayerid(); banplayerid_ = value; + // @@protoc_insertion_point(field_set:AdminBanPlayerAckMessage.banPlayerId) } // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; @@ -18618,12 +19985,14 @@ inline void AdminBanPlayerAckMessage::clear_banplayerresult() { clear_has_banplayerresult(); } inline ::AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banplayerresult() const { + // @@protoc_insertion_point(field_get:AdminBanPlayerAckMessage.banPlayerResult) return static_cast< ::AdminBanPlayerAckMessage_AdminBanPlayerResult >(banplayerresult_); } inline void AdminBanPlayerAckMessage::set_banplayerresult(::AdminBanPlayerAckMessage_AdminBanPlayerResult value) { assert(::AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(value)); set_has_banplayerresult(); banplayerresult_ = value; + // @@protoc_insertion_point(field_set:AdminBanPlayerAckMessage.banPlayerResult) } // ------------------------------------------------------------------- @@ -18645,12 +20014,14 @@ inline void AuthMessage::clear_messagetype() { clear_has_messagetype(); } inline ::AuthMessage_AuthMessageType AuthMessage::messagetype() const { + // @@protoc_insertion_point(field_get:AuthMessage.messageType) return static_cast< ::AuthMessage_AuthMessageType >(messagetype_); } inline void AuthMessage::set_messagetype(::AuthMessage_AuthMessageType value) { assert(::AuthMessage_AuthMessageType_IsValid(value)); set_has_messagetype(); messagetype_ = value; + // @@protoc_insertion_point(field_set:AuthMessage.messageType) } // optional .AuthClientRequestMessage authClientRequestMessage = 2; @@ -18668,6 +20039,7 @@ inline void AuthMessage::clear_authclientrequestmessage() { clear_has_authclientrequestmessage(); } inline const ::AuthClientRequestMessage& AuthMessage::authclientrequestmessage() const { + // @@protoc_insertion_point(field_get:AuthMessage.authClientRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return authclientrequestmessage_ != NULL ? *authclientrequestmessage_ : *default_instance().authclientrequestmessage_; #else @@ -18677,6 +20049,7 @@ inline const ::AuthClientRequestMessage& AuthMessage::authclientrequestmessage() inline ::AuthClientRequestMessage* AuthMessage::mutable_authclientrequestmessage() { set_has_authclientrequestmessage(); if (authclientrequestmessage_ == NULL) authclientrequestmessage_ = new ::AuthClientRequestMessage; + // @@protoc_insertion_point(field_mutable:AuthMessage.authClientRequestMessage) return authclientrequestmessage_; } inline ::AuthClientRequestMessage* AuthMessage::release_authclientrequestmessage() { @@ -18693,6 +20066,7 @@ inline void AuthMessage::set_allocated_authclientrequestmessage(::AuthClientRequ } else { clear_has_authclientrequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:AuthMessage.authClientRequestMessage) } // optional .AuthServerChallengeMessage authServerChallengeMessage = 3; @@ -18710,6 +20084,7 @@ inline void AuthMessage::clear_authserverchallengemessage() { clear_has_authserverchallengemessage(); } inline const ::AuthServerChallengeMessage& AuthMessage::authserverchallengemessage() const { + // @@protoc_insertion_point(field_get:AuthMessage.authServerChallengeMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return authserverchallengemessage_ != NULL ? *authserverchallengemessage_ : *default_instance().authserverchallengemessage_; #else @@ -18719,6 +20094,7 @@ inline const ::AuthServerChallengeMessage& AuthMessage::authserverchallengemessa inline ::AuthServerChallengeMessage* AuthMessage::mutable_authserverchallengemessage() { set_has_authserverchallengemessage(); if (authserverchallengemessage_ == NULL) authserverchallengemessage_ = new ::AuthServerChallengeMessage; + // @@protoc_insertion_point(field_mutable:AuthMessage.authServerChallengeMessage) return authserverchallengemessage_; } inline ::AuthServerChallengeMessage* AuthMessage::release_authserverchallengemessage() { @@ -18735,6 +20111,7 @@ inline void AuthMessage::set_allocated_authserverchallengemessage(::AuthServerCh } else { clear_has_authserverchallengemessage(); } + // @@protoc_insertion_point(field_set_allocated:AuthMessage.authServerChallengeMessage) } // optional .AuthClientResponseMessage authClientResponseMessage = 4; @@ -18752,6 +20129,7 @@ inline void AuthMessage::clear_authclientresponsemessage() { clear_has_authclientresponsemessage(); } inline const ::AuthClientResponseMessage& AuthMessage::authclientresponsemessage() const { + // @@protoc_insertion_point(field_get:AuthMessage.authClientResponseMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return authclientresponsemessage_ != NULL ? *authclientresponsemessage_ : *default_instance().authclientresponsemessage_; #else @@ -18761,6 +20139,7 @@ inline const ::AuthClientResponseMessage& AuthMessage::authclientresponsemessage inline ::AuthClientResponseMessage* AuthMessage::mutable_authclientresponsemessage() { set_has_authclientresponsemessage(); if (authclientresponsemessage_ == NULL) authclientresponsemessage_ = new ::AuthClientResponseMessage; + // @@protoc_insertion_point(field_mutable:AuthMessage.authClientResponseMessage) return authclientresponsemessage_; } inline ::AuthClientResponseMessage* AuthMessage::release_authclientresponsemessage() { @@ -18777,6 +20156,7 @@ inline void AuthMessage::set_allocated_authclientresponsemessage(::AuthClientRes } else { clear_has_authclientresponsemessage(); } + // @@protoc_insertion_point(field_set_allocated:AuthMessage.authClientResponseMessage) } // optional .AuthServerVerificationMessage authServerVerificationMessage = 5; @@ -18794,6 +20174,7 @@ inline void AuthMessage::clear_authserververificationmessage() { clear_has_authserververificationmessage(); } inline const ::AuthServerVerificationMessage& AuthMessage::authserververificationmessage() const { + // @@protoc_insertion_point(field_get:AuthMessage.authServerVerificationMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return authserververificationmessage_ != NULL ? *authserververificationmessage_ : *default_instance().authserververificationmessage_; #else @@ -18803,6 +20184,7 @@ inline const ::AuthServerVerificationMessage& AuthMessage::authserververificatio inline ::AuthServerVerificationMessage* AuthMessage::mutable_authserververificationmessage() { set_has_authserververificationmessage(); if (authserververificationmessage_ == NULL) authserververificationmessage_ = new ::AuthServerVerificationMessage; + // @@protoc_insertion_point(field_mutable:AuthMessage.authServerVerificationMessage) return authserververificationmessage_; } inline ::AuthServerVerificationMessage* AuthMessage::release_authserververificationmessage() { @@ -18819,6 +20201,7 @@ inline void AuthMessage::set_allocated_authserververificationmessage(::AuthServe } else { clear_has_authserververificationmessage(); } + // @@protoc_insertion_point(field_set_allocated:AuthMessage.authServerVerificationMessage) } // optional .ErrorMessage errorMessage = 1025; @@ -18836,6 +20219,7 @@ inline void AuthMessage::clear_errormessage() { clear_has_errormessage(); } inline const ::ErrorMessage& AuthMessage::errormessage() const { + // @@protoc_insertion_point(field_get:AuthMessage.errorMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return errormessage_ != NULL ? *errormessage_ : *default_instance().errormessage_; #else @@ -18845,6 +20229,7 @@ inline const ::ErrorMessage& AuthMessage::errormessage() const { inline ::ErrorMessage* AuthMessage::mutable_errormessage() { set_has_errormessage(); if (errormessage_ == NULL) errormessage_ = new ::ErrorMessage; + // @@protoc_insertion_point(field_mutable:AuthMessage.errorMessage) return errormessage_; } inline ::ErrorMessage* AuthMessage::release_errormessage() { @@ -18861,6 +20246,7 @@ inline void AuthMessage::set_allocated_errormessage(::ErrorMessage* errormessage } else { clear_has_errormessage(); } + // @@protoc_insertion_point(field_set_allocated:AuthMessage.errorMessage) } // ------------------------------------------------------------------- @@ -18882,12 +20268,14 @@ inline void LobbyMessage::clear_messagetype() { clear_has_messagetype(); } inline ::LobbyMessage_LobbyMessageType LobbyMessage::messagetype() const { + // @@protoc_insertion_point(field_get:LobbyMessage.messageType) return static_cast< ::LobbyMessage_LobbyMessageType >(messagetype_); } inline void LobbyMessage::set_messagetype(::LobbyMessage_LobbyMessageType value) { assert(::LobbyMessage_LobbyMessageType_IsValid(value)); set_has_messagetype(); messagetype_ = value; + // @@protoc_insertion_point(field_set:LobbyMessage.messageType) } // optional .InitDoneMessage initDoneMessage = 2; @@ -18905,6 +20293,7 @@ inline void LobbyMessage::clear_initdonemessage() { clear_has_initdonemessage(); } inline const ::InitDoneMessage& LobbyMessage::initdonemessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.initDoneMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return initdonemessage_ != NULL ? *initdonemessage_ : *default_instance().initdonemessage_; #else @@ -18914,6 +20303,7 @@ inline const ::InitDoneMessage& LobbyMessage::initdonemessage() const { inline ::InitDoneMessage* LobbyMessage::mutable_initdonemessage() { set_has_initdonemessage(); if (initdonemessage_ == NULL) initdonemessage_ = new ::InitDoneMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.initDoneMessage) return initdonemessage_; } inline ::InitDoneMessage* LobbyMessage::release_initdonemessage() { @@ -18930,6 +20320,7 @@ inline void LobbyMessage::set_allocated_initdonemessage(::InitDoneMessage* initd } else { clear_has_initdonemessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.initDoneMessage) } // optional .AvatarRequestMessage avatarRequestMessage = 3; @@ -18947,6 +20338,7 @@ inline void LobbyMessage::clear_avatarrequestmessage() { clear_has_avatarrequestmessage(); } inline const ::AvatarRequestMessage& LobbyMessage::avatarrequestmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.avatarRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return avatarrequestmessage_ != NULL ? *avatarrequestmessage_ : *default_instance().avatarrequestmessage_; #else @@ -18956,6 +20348,7 @@ inline const ::AvatarRequestMessage& LobbyMessage::avatarrequestmessage() const inline ::AvatarRequestMessage* LobbyMessage::mutable_avatarrequestmessage() { set_has_avatarrequestmessage(); if (avatarrequestmessage_ == NULL) avatarrequestmessage_ = new ::AvatarRequestMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.avatarRequestMessage) return avatarrequestmessage_; } inline ::AvatarRequestMessage* LobbyMessage::release_avatarrequestmessage() { @@ -18972,6 +20365,7 @@ inline void LobbyMessage::set_allocated_avatarrequestmessage(::AvatarRequestMess } else { clear_has_avatarrequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.avatarRequestMessage) } // optional .AvatarHeaderMessage avatarHeaderMessage = 4; @@ -18989,6 +20383,7 @@ inline void LobbyMessage::clear_avatarheadermessage() { clear_has_avatarheadermessage(); } inline const ::AvatarHeaderMessage& LobbyMessage::avatarheadermessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.avatarHeaderMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return avatarheadermessage_ != NULL ? *avatarheadermessage_ : *default_instance().avatarheadermessage_; #else @@ -18998,6 +20393,7 @@ inline const ::AvatarHeaderMessage& LobbyMessage::avatarheadermessage() const { inline ::AvatarHeaderMessage* LobbyMessage::mutable_avatarheadermessage() { set_has_avatarheadermessage(); if (avatarheadermessage_ == NULL) avatarheadermessage_ = new ::AvatarHeaderMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.avatarHeaderMessage) return avatarheadermessage_; } inline ::AvatarHeaderMessage* LobbyMessage::release_avatarheadermessage() { @@ -19014,6 +20410,7 @@ inline void LobbyMessage::set_allocated_avatarheadermessage(::AvatarHeaderMessag } else { clear_has_avatarheadermessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.avatarHeaderMessage) } // optional .AvatarDataMessage avatarDataMessage = 5; @@ -19031,6 +20428,7 @@ inline void LobbyMessage::clear_avatardatamessage() { clear_has_avatardatamessage(); } inline const ::AvatarDataMessage& LobbyMessage::avatardatamessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.avatarDataMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return avatardatamessage_ != NULL ? *avatardatamessage_ : *default_instance().avatardatamessage_; #else @@ -19040,6 +20438,7 @@ inline const ::AvatarDataMessage& LobbyMessage::avatardatamessage() const { inline ::AvatarDataMessage* LobbyMessage::mutable_avatardatamessage() { set_has_avatardatamessage(); if (avatardatamessage_ == NULL) avatardatamessage_ = new ::AvatarDataMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.avatarDataMessage) return avatardatamessage_; } inline ::AvatarDataMessage* LobbyMessage::release_avatardatamessage() { @@ -19056,6 +20455,7 @@ inline void LobbyMessage::set_allocated_avatardatamessage(::AvatarDataMessage* a } else { clear_has_avatardatamessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.avatarDataMessage) } // optional .AvatarEndMessage avatarEndMessage = 6; @@ -19073,6 +20473,7 @@ inline void LobbyMessage::clear_avatarendmessage() { clear_has_avatarendmessage(); } inline const ::AvatarEndMessage& LobbyMessage::avatarendmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.avatarEndMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return avatarendmessage_ != NULL ? *avatarendmessage_ : *default_instance().avatarendmessage_; #else @@ -19082,6 +20483,7 @@ inline const ::AvatarEndMessage& LobbyMessage::avatarendmessage() const { inline ::AvatarEndMessage* LobbyMessage::mutable_avatarendmessage() { set_has_avatarendmessage(); if (avatarendmessage_ == NULL) avatarendmessage_ = new ::AvatarEndMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.avatarEndMessage) return avatarendmessage_; } inline ::AvatarEndMessage* LobbyMessage::release_avatarendmessage() { @@ -19098,6 +20500,7 @@ inline void LobbyMessage::set_allocated_avatarendmessage(::AvatarEndMessage* ava } else { clear_has_avatarendmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.avatarEndMessage) } // optional .UnknownAvatarMessage unknownAvatarMessage = 7; @@ -19115,6 +20518,7 @@ inline void LobbyMessage::clear_unknownavatarmessage() { clear_has_unknownavatarmessage(); } inline const ::UnknownAvatarMessage& LobbyMessage::unknownavatarmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.unknownAvatarMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return unknownavatarmessage_ != NULL ? *unknownavatarmessage_ : *default_instance().unknownavatarmessage_; #else @@ -19124,6 +20528,7 @@ inline const ::UnknownAvatarMessage& LobbyMessage::unknownavatarmessage() const inline ::UnknownAvatarMessage* LobbyMessage::mutable_unknownavatarmessage() { set_has_unknownavatarmessage(); if (unknownavatarmessage_ == NULL) unknownavatarmessage_ = new ::UnknownAvatarMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.unknownAvatarMessage) return unknownavatarmessage_; } inline ::UnknownAvatarMessage* LobbyMessage::release_unknownavatarmessage() { @@ -19140,6 +20545,7 @@ inline void LobbyMessage::set_allocated_unknownavatarmessage(::UnknownAvatarMess } else { clear_has_unknownavatarmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.unknownAvatarMessage) } // optional .PlayerListMessage playerListMessage = 8; @@ -19157,6 +20563,7 @@ inline void LobbyMessage::clear_playerlistmessage() { clear_has_playerlistmessage(); } inline const ::PlayerListMessage& LobbyMessage::playerlistmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.playerListMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return playerlistmessage_ != NULL ? *playerlistmessage_ : *default_instance().playerlistmessage_; #else @@ -19166,6 +20573,7 @@ inline const ::PlayerListMessage& LobbyMessage::playerlistmessage() const { inline ::PlayerListMessage* LobbyMessage::mutable_playerlistmessage() { set_has_playerlistmessage(); if (playerlistmessage_ == NULL) playerlistmessage_ = new ::PlayerListMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.playerListMessage) return playerlistmessage_; } inline ::PlayerListMessage* LobbyMessage::release_playerlistmessage() { @@ -19182,6 +20590,7 @@ inline void LobbyMessage::set_allocated_playerlistmessage(::PlayerListMessage* p } else { clear_has_playerlistmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.playerListMessage) } // optional .GameListNewMessage gameListNewMessage = 9; @@ -19199,6 +20608,7 @@ inline void LobbyMessage::clear_gamelistnewmessage() { clear_has_gamelistnewmessage(); } inline const ::GameListNewMessage& LobbyMessage::gamelistnewmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.gameListNewMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamelistnewmessage_ != NULL ? *gamelistnewmessage_ : *default_instance().gamelistnewmessage_; #else @@ -19208,6 +20618,7 @@ inline const ::GameListNewMessage& LobbyMessage::gamelistnewmessage() const { inline ::GameListNewMessage* LobbyMessage::mutable_gamelistnewmessage() { set_has_gamelistnewmessage(); if (gamelistnewmessage_ == NULL) gamelistnewmessage_ = new ::GameListNewMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.gameListNewMessage) return gamelistnewmessage_; } inline ::GameListNewMessage* LobbyMessage::release_gamelistnewmessage() { @@ -19224,6 +20635,7 @@ inline void LobbyMessage::set_allocated_gamelistnewmessage(::GameListNewMessage* } else { clear_has_gamelistnewmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.gameListNewMessage) } // optional .GameListUpdateMessage gameListUpdateMessage = 10; @@ -19241,6 +20653,7 @@ inline void LobbyMessage::clear_gamelistupdatemessage() { clear_has_gamelistupdatemessage(); } inline const ::GameListUpdateMessage& LobbyMessage::gamelistupdatemessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.gameListUpdateMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamelistupdatemessage_ != NULL ? *gamelistupdatemessage_ : *default_instance().gamelistupdatemessage_; #else @@ -19250,6 +20663,7 @@ inline const ::GameListUpdateMessage& LobbyMessage::gamelistupdatemessage() cons inline ::GameListUpdateMessage* LobbyMessage::mutable_gamelistupdatemessage() { set_has_gamelistupdatemessage(); if (gamelistupdatemessage_ == NULL) gamelistupdatemessage_ = new ::GameListUpdateMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.gameListUpdateMessage) return gamelistupdatemessage_; } inline ::GameListUpdateMessage* LobbyMessage::release_gamelistupdatemessage() { @@ -19266,6 +20680,7 @@ inline void LobbyMessage::set_allocated_gamelistupdatemessage(::GameListUpdateMe } else { clear_has_gamelistupdatemessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.gameListUpdateMessage) } // optional .GameListPlayerJoinedMessage gameListPlayerJoinedMessage = 11; @@ -19283,6 +20698,7 @@ inline void LobbyMessage::clear_gamelistplayerjoinedmessage() { clear_has_gamelistplayerjoinedmessage(); } inline const ::GameListPlayerJoinedMessage& LobbyMessage::gamelistplayerjoinedmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.gameListPlayerJoinedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamelistplayerjoinedmessage_ != NULL ? *gamelistplayerjoinedmessage_ : *default_instance().gamelistplayerjoinedmessage_; #else @@ -19292,6 +20708,7 @@ inline const ::GameListPlayerJoinedMessage& LobbyMessage::gamelistplayerjoinedme inline ::GameListPlayerJoinedMessage* LobbyMessage::mutable_gamelistplayerjoinedmessage() { set_has_gamelistplayerjoinedmessage(); if (gamelistplayerjoinedmessage_ == NULL) gamelistplayerjoinedmessage_ = new ::GameListPlayerJoinedMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.gameListPlayerJoinedMessage) return gamelistplayerjoinedmessage_; } inline ::GameListPlayerJoinedMessage* LobbyMessage::release_gamelistplayerjoinedmessage() { @@ -19308,6 +20725,7 @@ inline void LobbyMessage::set_allocated_gamelistplayerjoinedmessage(::GameListPl } else { clear_has_gamelistplayerjoinedmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.gameListPlayerJoinedMessage) } // optional .GameListPlayerLeftMessage gameListPlayerLeftMessage = 12; @@ -19325,6 +20743,7 @@ inline void LobbyMessage::clear_gamelistplayerleftmessage() { clear_has_gamelistplayerleftmessage(); } inline const ::GameListPlayerLeftMessage& LobbyMessage::gamelistplayerleftmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.gameListPlayerLeftMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamelistplayerleftmessage_ != NULL ? *gamelistplayerleftmessage_ : *default_instance().gamelistplayerleftmessage_; #else @@ -19334,6 +20753,7 @@ inline const ::GameListPlayerLeftMessage& LobbyMessage::gamelistplayerleftmessag inline ::GameListPlayerLeftMessage* LobbyMessage::mutable_gamelistplayerleftmessage() { set_has_gamelistplayerleftmessage(); if (gamelistplayerleftmessage_ == NULL) gamelistplayerleftmessage_ = new ::GameListPlayerLeftMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.gameListPlayerLeftMessage) return gamelistplayerleftmessage_; } inline ::GameListPlayerLeftMessage* LobbyMessage::release_gamelistplayerleftmessage() { @@ -19350,6 +20770,7 @@ inline void LobbyMessage::set_allocated_gamelistplayerleftmessage(::GameListPlay } else { clear_has_gamelistplayerleftmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.gameListPlayerLeftMessage) } // optional .GameListSpectatorJoinedMessage gameListSpectatorJoinedMessage = 13; @@ -19367,6 +20788,7 @@ inline void LobbyMessage::clear_gamelistspectatorjoinedmessage() { clear_has_gamelistspectatorjoinedmessage(); } inline const ::GameListSpectatorJoinedMessage& LobbyMessage::gamelistspectatorjoinedmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.gameListSpectatorJoinedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamelistspectatorjoinedmessage_ != NULL ? *gamelistspectatorjoinedmessage_ : *default_instance().gamelistspectatorjoinedmessage_; #else @@ -19376,6 +20798,7 @@ inline const ::GameListSpectatorJoinedMessage& LobbyMessage::gamelistspectatorjo inline ::GameListSpectatorJoinedMessage* LobbyMessage::mutable_gamelistspectatorjoinedmessage() { set_has_gamelistspectatorjoinedmessage(); if (gamelistspectatorjoinedmessage_ == NULL) gamelistspectatorjoinedmessage_ = new ::GameListSpectatorJoinedMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.gameListSpectatorJoinedMessage) return gamelistspectatorjoinedmessage_; } inline ::GameListSpectatorJoinedMessage* LobbyMessage::release_gamelistspectatorjoinedmessage() { @@ -19392,6 +20815,7 @@ inline void LobbyMessage::set_allocated_gamelistspectatorjoinedmessage(::GameLis } else { clear_has_gamelistspectatorjoinedmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.gameListSpectatorJoinedMessage) } // optional .GameListSpectatorLeftMessage gameListSpectatorLeftMessage = 14; @@ -19409,6 +20833,7 @@ inline void LobbyMessage::clear_gamelistspectatorleftmessage() { clear_has_gamelistspectatorleftmessage(); } inline const ::GameListSpectatorLeftMessage& LobbyMessage::gamelistspectatorleftmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.gameListSpectatorLeftMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamelistspectatorleftmessage_ != NULL ? *gamelistspectatorleftmessage_ : *default_instance().gamelistspectatorleftmessage_; #else @@ -19418,6 +20843,7 @@ inline const ::GameListSpectatorLeftMessage& LobbyMessage::gamelistspectatorleft inline ::GameListSpectatorLeftMessage* LobbyMessage::mutable_gamelistspectatorleftmessage() { set_has_gamelistspectatorleftmessage(); if (gamelistspectatorleftmessage_ == NULL) gamelistspectatorleftmessage_ = new ::GameListSpectatorLeftMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.gameListSpectatorLeftMessage) return gamelistspectatorleftmessage_; } inline ::GameListSpectatorLeftMessage* LobbyMessage::release_gamelistspectatorleftmessage() { @@ -19434,6 +20860,7 @@ inline void LobbyMessage::set_allocated_gamelistspectatorleftmessage(::GameListS } else { clear_has_gamelistspectatorleftmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.gameListSpectatorLeftMessage) } // optional .GameListAdminChangedMessage gameListAdminChangedMessage = 15; @@ -19451,6 +20878,7 @@ inline void LobbyMessage::clear_gamelistadminchangedmessage() { clear_has_gamelistadminchangedmessage(); } inline const ::GameListAdminChangedMessage& LobbyMessage::gamelistadminchangedmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.gameListAdminChangedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamelistadminchangedmessage_ != NULL ? *gamelistadminchangedmessage_ : *default_instance().gamelistadminchangedmessage_; #else @@ -19460,6 +20888,7 @@ inline const ::GameListAdminChangedMessage& LobbyMessage::gamelistadminchangedme inline ::GameListAdminChangedMessage* LobbyMessage::mutable_gamelistadminchangedmessage() { set_has_gamelistadminchangedmessage(); if (gamelistadminchangedmessage_ == NULL) gamelistadminchangedmessage_ = new ::GameListAdminChangedMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.gameListAdminChangedMessage) return gamelistadminchangedmessage_; } inline ::GameListAdminChangedMessage* LobbyMessage::release_gamelistadminchangedmessage() { @@ -19476,6 +20905,7 @@ inline void LobbyMessage::set_allocated_gamelistadminchangedmessage(::GameListAd } else { clear_has_gamelistadminchangedmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.gameListAdminChangedMessage) } // optional .PlayerInfoRequestMessage playerInfoRequestMessage = 16; @@ -19493,6 +20923,7 @@ inline void LobbyMessage::clear_playerinforequestmessage() { clear_has_playerinforequestmessage(); } inline const ::PlayerInfoRequestMessage& LobbyMessage::playerinforequestmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.playerInfoRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return playerinforequestmessage_ != NULL ? *playerinforequestmessage_ : *default_instance().playerinforequestmessage_; #else @@ -19502,6 +20933,7 @@ inline const ::PlayerInfoRequestMessage& LobbyMessage::playerinforequestmessage( inline ::PlayerInfoRequestMessage* LobbyMessage::mutable_playerinforequestmessage() { set_has_playerinforequestmessage(); if (playerinforequestmessage_ == NULL) playerinforequestmessage_ = new ::PlayerInfoRequestMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.playerInfoRequestMessage) return playerinforequestmessage_; } inline ::PlayerInfoRequestMessage* LobbyMessage::release_playerinforequestmessage() { @@ -19518,6 +20950,7 @@ inline void LobbyMessage::set_allocated_playerinforequestmessage(::PlayerInfoReq } else { clear_has_playerinforequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.playerInfoRequestMessage) } // optional .PlayerInfoReplyMessage playerInfoReplyMessage = 17; @@ -19535,6 +20968,7 @@ inline void LobbyMessage::clear_playerinforeplymessage() { clear_has_playerinforeplymessage(); } inline const ::PlayerInfoReplyMessage& LobbyMessage::playerinforeplymessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.playerInfoReplyMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return playerinforeplymessage_ != NULL ? *playerinforeplymessage_ : *default_instance().playerinforeplymessage_; #else @@ -19544,6 +20978,7 @@ inline const ::PlayerInfoReplyMessage& LobbyMessage::playerinforeplymessage() co inline ::PlayerInfoReplyMessage* LobbyMessage::mutable_playerinforeplymessage() { set_has_playerinforeplymessage(); if (playerinforeplymessage_ == NULL) playerinforeplymessage_ = new ::PlayerInfoReplyMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.playerInfoReplyMessage) return playerinforeplymessage_; } inline ::PlayerInfoReplyMessage* LobbyMessage::release_playerinforeplymessage() { @@ -19560,6 +20995,7 @@ inline void LobbyMessage::set_allocated_playerinforeplymessage(::PlayerInfoReply } else { clear_has_playerinforeplymessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.playerInfoReplyMessage) } // optional .SubscriptionRequestMessage subscriptionRequestMessage = 18; @@ -19577,6 +21013,7 @@ inline void LobbyMessage::clear_subscriptionrequestmessage() { clear_has_subscriptionrequestmessage(); } inline const ::SubscriptionRequestMessage& LobbyMessage::subscriptionrequestmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.subscriptionRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return subscriptionrequestmessage_ != NULL ? *subscriptionrequestmessage_ : *default_instance().subscriptionrequestmessage_; #else @@ -19586,6 +21023,7 @@ inline const ::SubscriptionRequestMessage& LobbyMessage::subscriptionrequestmess inline ::SubscriptionRequestMessage* LobbyMessage::mutable_subscriptionrequestmessage() { set_has_subscriptionrequestmessage(); if (subscriptionrequestmessage_ == NULL) subscriptionrequestmessage_ = new ::SubscriptionRequestMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.subscriptionRequestMessage) return subscriptionrequestmessage_; } inline ::SubscriptionRequestMessage* LobbyMessage::release_subscriptionrequestmessage() { @@ -19602,6 +21040,7 @@ inline void LobbyMessage::set_allocated_subscriptionrequestmessage(::Subscriptio } else { clear_has_subscriptionrequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.subscriptionRequestMessage) } // optional .SubscriptionReplyMessage subscriptionReplyMessage = 19; @@ -19619,6 +21058,7 @@ inline void LobbyMessage::clear_subscriptionreplymessage() { clear_has_subscriptionreplymessage(); } inline const ::SubscriptionReplyMessage& LobbyMessage::subscriptionreplymessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.subscriptionReplyMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return subscriptionreplymessage_ != NULL ? *subscriptionreplymessage_ : *default_instance().subscriptionreplymessage_; #else @@ -19628,6 +21068,7 @@ inline const ::SubscriptionReplyMessage& LobbyMessage::subscriptionreplymessage( inline ::SubscriptionReplyMessage* LobbyMessage::mutable_subscriptionreplymessage() { set_has_subscriptionreplymessage(); if (subscriptionreplymessage_ == NULL) subscriptionreplymessage_ = new ::SubscriptionReplyMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.subscriptionReplyMessage) return subscriptionreplymessage_; } inline ::SubscriptionReplyMessage* LobbyMessage::release_subscriptionreplymessage() { @@ -19644,6 +21085,7 @@ inline void LobbyMessage::set_allocated_subscriptionreplymessage(::SubscriptionR } else { clear_has_subscriptionreplymessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.subscriptionReplyMessage) } // optional .CreateGameMessage createGameMessage = 20; @@ -19661,6 +21103,7 @@ inline void LobbyMessage::clear_creategamemessage() { clear_has_creategamemessage(); } inline const ::CreateGameMessage& LobbyMessage::creategamemessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.createGameMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return creategamemessage_ != NULL ? *creategamemessage_ : *default_instance().creategamemessage_; #else @@ -19670,6 +21113,7 @@ inline const ::CreateGameMessage& LobbyMessage::creategamemessage() const { inline ::CreateGameMessage* LobbyMessage::mutable_creategamemessage() { set_has_creategamemessage(); if (creategamemessage_ == NULL) creategamemessage_ = new ::CreateGameMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.createGameMessage) return creategamemessage_; } inline ::CreateGameMessage* LobbyMessage::release_creategamemessage() { @@ -19686,6 +21130,7 @@ inline void LobbyMessage::set_allocated_creategamemessage(::CreateGameMessage* c } else { clear_has_creategamemessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.createGameMessage) } // optional .CreateGameFailedMessage createGameFailedMessage = 21; @@ -19703,6 +21148,7 @@ inline void LobbyMessage::clear_creategamefailedmessage() { clear_has_creategamefailedmessage(); } inline const ::CreateGameFailedMessage& LobbyMessage::creategamefailedmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.createGameFailedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return creategamefailedmessage_ != NULL ? *creategamefailedmessage_ : *default_instance().creategamefailedmessage_; #else @@ -19712,6 +21158,7 @@ inline const ::CreateGameFailedMessage& LobbyMessage::creategamefailedmessage() inline ::CreateGameFailedMessage* LobbyMessage::mutable_creategamefailedmessage() { set_has_creategamefailedmessage(); if (creategamefailedmessage_ == NULL) creategamefailedmessage_ = new ::CreateGameFailedMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.createGameFailedMessage) return creategamefailedmessage_; } inline ::CreateGameFailedMessage* LobbyMessage::release_creategamefailedmessage() { @@ -19728,6 +21175,7 @@ inline void LobbyMessage::set_allocated_creategamefailedmessage(::CreateGameFail } else { clear_has_creategamefailedmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.createGameFailedMessage) } // optional .JoinGameMessage joinGameMessage = 22; @@ -19745,6 +21193,7 @@ inline void LobbyMessage::clear_joingamemessage() { clear_has_joingamemessage(); } inline const ::JoinGameMessage& LobbyMessage::joingamemessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.joinGameMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return joingamemessage_ != NULL ? *joingamemessage_ : *default_instance().joingamemessage_; #else @@ -19754,6 +21203,7 @@ inline const ::JoinGameMessage& LobbyMessage::joingamemessage() const { inline ::JoinGameMessage* LobbyMessage::mutable_joingamemessage() { set_has_joingamemessage(); if (joingamemessage_ == NULL) joingamemessage_ = new ::JoinGameMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.joinGameMessage) return joingamemessage_; } inline ::JoinGameMessage* LobbyMessage::release_joingamemessage() { @@ -19770,6 +21220,7 @@ inline void LobbyMessage::set_allocated_joingamemessage(::JoinGameMessage* joing } else { clear_has_joingamemessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.joinGameMessage) } // optional .RejoinGameMessage rejoinGameMessage = 23; @@ -19787,6 +21238,7 @@ inline void LobbyMessage::clear_rejoingamemessage() { clear_has_rejoingamemessage(); } inline const ::RejoinGameMessage& LobbyMessage::rejoingamemessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.rejoinGameMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return rejoingamemessage_ != NULL ? *rejoingamemessage_ : *default_instance().rejoingamemessage_; #else @@ -19796,6 +21248,7 @@ inline const ::RejoinGameMessage& LobbyMessage::rejoingamemessage() const { inline ::RejoinGameMessage* LobbyMessage::mutable_rejoingamemessage() { set_has_rejoingamemessage(); if (rejoingamemessage_ == NULL) rejoingamemessage_ = new ::RejoinGameMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.rejoinGameMessage) return rejoingamemessage_; } inline ::RejoinGameMessage* LobbyMessage::release_rejoingamemessage() { @@ -19812,6 +21265,7 @@ inline void LobbyMessage::set_allocated_rejoingamemessage(::RejoinGameMessage* r } else { clear_has_rejoingamemessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.rejoinGameMessage) } // optional .JoinGameAckMessage joinGameAckMessage = 24; @@ -19829,6 +21283,7 @@ inline void LobbyMessage::clear_joingameackmessage() { clear_has_joingameackmessage(); } inline const ::JoinGameAckMessage& LobbyMessage::joingameackmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.joinGameAckMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return joingameackmessage_ != NULL ? *joingameackmessage_ : *default_instance().joingameackmessage_; #else @@ -19838,6 +21293,7 @@ inline const ::JoinGameAckMessage& LobbyMessage::joingameackmessage() const { inline ::JoinGameAckMessage* LobbyMessage::mutable_joingameackmessage() { set_has_joingameackmessage(); if (joingameackmessage_ == NULL) joingameackmessage_ = new ::JoinGameAckMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.joinGameAckMessage) return joingameackmessage_; } inline ::JoinGameAckMessage* LobbyMessage::release_joingameackmessage() { @@ -19854,6 +21310,7 @@ inline void LobbyMessage::set_allocated_joingameackmessage(::JoinGameAckMessage* } else { clear_has_joingameackmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.joinGameAckMessage) } // optional .JoinGameFailedMessage joinGameFailedMessage = 25; @@ -19871,6 +21328,7 @@ inline void LobbyMessage::clear_joingamefailedmessage() { clear_has_joingamefailedmessage(); } inline const ::JoinGameFailedMessage& LobbyMessage::joingamefailedmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.joinGameFailedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return joingamefailedmessage_ != NULL ? *joingamefailedmessage_ : *default_instance().joingamefailedmessage_; #else @@ -19880,6 +21338,7 @@ inline const ::JoinGameFailedMessage& LobbyMessage::joingamefailedmessage() cons inline ::JoinGameFailedMessage* LobbyMessage::mutable_joingamefailedmessage() { set_has_joingamefailedmessage(); if (joingamefailedmessage_ == NULL) joingamefailedmessage_ = new ::JoinGameFailedMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.joinGameFailedMessage) return joingamefailedmessage_; } inline ::JoinGameFailedMessage* LobbyMessage::release_joingamefailedmessage() { @@ -19896,6 +21355,7 @@ inline void LobbyMessage::set_allocated_joingamefailedmessage(::JoinGameFailedMe } else { clear_has_joingamefailedmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.joinGameFailedMessage) } // optional .InviteNotifyMessage inviteNotifyMessage = 26; @@ -19913,6 +21373,7 @@ inline void LobbyMessage::clear_invitenotifymessage() { clear_has_invitenotifymessage(); } inline const ::InviteNotifyMessage& LobbyMessage::invitenotifymessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.inviteNotifyMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return invitenotifymessage_ != NULL ? *invitenotifymessage_ : *default_instance().invitenotifymessage_; #else @@ -19922,6 +21383,7 @@ inline const ::InviteNotifyMessage& LobbyMessage::invitenotifymessage() const { inline ::InviteNotifyMessage* LobbyMessage::mutable_invitenotifymessage() { set_has_invitenotifymessage(); if (invitenotifymessage_ == NULL) invitenotifymessage_ = new ::InviteNotifyMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.inviteNotifyMessage) return invitenotifymessage_; } inline ::InviteNotifyMessage* LobbyMessage::release_invitenotifymessage() { @@ -19938,6 +21400,7 @@ inline void LobbyMessage::set_allocated_invitenotifymessage(::InviteNotifyMessag } else { clear_has_invitenotifymessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.inviteNotifyMessage) } // optional .RejectGameInvitationMessage rejectGameInvitationMessage = 27; @@ -19955,6 +21418,7 @@ inline void LobbyMessage::clear_rejectgameinvitationmessage() { clear_has_rejectgameinvitationmessage(); } inline const ::RejectGameInvitationMessage& LobbyMessage::rejectgameinvitationmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.rejectGameInvitationMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return rejectgameinvitationmessage_ != NULL ? *rejectgameinvitationmessage_ : *default_instance().rejectgameinvitationmessage_; #else @@ -19964,6 +21428,7 @@ inline const ::RejectGameInvitationMessage& LobbyMessage::rejectgameinvitationme inline ::RejectGameInvitationMessage* LobbyMessage::mutable_rejectgameinvitationmessage() { set_has_rejectgameinvitationmessage(); if (rejectgameinvitationmessage_ == NULL) rejectgameinvitationmessage_ = new ::RejectGameInvitationMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.rejectGameInvitationMessage) return rejectgameinvitationmessage_; } inline ::RejectGameInvitationMessage* LobbyMessage::release_rejectgameinvitationmessage() { @@ -19980,6 +21445,7 @@ inline void LobbyMessage::set_allocated_rejectgameinvitationmessage(::RejectGame } else { clear_has_rejectgameinvitationmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.rejectGameInvitationMessage) } // optional .RejectInvNotifyMessage rejectInvNotifyMessage = 28; @@ -19997,6 +21463,7 @@ inline void LobbyMessage::clear_rejectinvnotifymessage() { clear_has_rejectinvnotifymessage(); } inline const ::RejectInvNotifyMessage& LobbyMessage::rejectinvnotifymessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.rejectInvNotifyMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return rejectinvnotifymessage_ != NULL ? *rejectinvnotifymessage_ : *default_instance().rejectinvnotifymessage_; #else @@ -20006,6 +21473,7 @@ inline const ::RejectInvNotifyMessage& LobbyMessage::rejectinvnotifymessage() co inline ::RejectInvNotifyMessage* LobbyMessage::mutable_rejectinvnotifymessage() { set_has_rejectinvnotifymessage(); if (rejectinvnotifymessage_ == NULL) rejectinvnotifymessage_ = new ::RejectInvNotifyMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.rejectInvNotifyMessage) return rejectinvnotifymessage_; } inline ::RejectInvNotifyMessage* LobbyMessage::release_rejectinvnotifymessage() { @@ -20022,6 +21490,7 @@ inline void LobbyMessage::set_allocated_rejectinvnotifymessage(::RejectInvNotify } else { clear_has_rejectinvnotifymessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.rejectInvNotifyMessage) } // optional .StatisticsMessage statisticsMessage = 29; @@ -20039,6 +21508,7 @@ inline void LobbyMessage::clear_statisticsmessage() { clear_has_statisticsmessage(); } inline const ::StatisticsMessage& LobbyMessage::statisticsmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.statisticsMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return statisticsmessage_ != NULL ? *statisticsmessage_ : *default_instance().statisticsmessage_; #else @@ -20048,6 +21518,7 @@ inline const ::StatisticsMessage& LobbyMessage::statisticsmessage() const { inline ::StatisticsMessage* LobbyMessage::mutable_statisticsmessage() { set_has_statisticsmessage(); if (statisticsmessage_ == NULL) statisticsmessage_ = new ::StatisticsMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.statisticsMessage) return statisticsmessage_; } inline ::StatisticsMessage* LobbyMessage::release_statisticsmessage() { @@ -20064,6 +21535,7 @@ inline void LobbyMessage::set_allocated_statisticsmessage(::StatisticsMessage* s } else { clear_has_statisticsmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.statisticsMessage) } // optional .ChatRequestMessage chatRequestMessage = 30; @@ -20081,6 +21553,7 @@ inline void LobbyMessage::clear_chatrequestmessage() { clear_has_chatrequestmessage(); } inline const ::ChatRequestMessage& LobbyMessage::chatrequestmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.chatRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return chatrequestmessage_ != NULL ? *chatrequestmessage_ : *default_instance().chatrequestmessage_; #else @@ -20090,6 +21563,7 @@ inline const ::ChatRequestMessage& LobbyMessage::chatrequestmessage() const { inline ::ChatRequestMessage* LobbyMessage::mutable_chatrequestmessage() { set_has_chatrequestmessage(); if (chatrequestmessage_ == NULL) chatrequestmessage_ = new ::ChatRequestMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.chatRequestMessage) return chatrequestmessage_; } inline ::ChatRequestMessage* LobbyMessage::release_chatrequestmessage() { @@ -20106,6 +21580,7 @@ inline void LobbyMessage::set_allocated_chatrequestmessage(::ChatRequestMessage* } else { clear_has_chatrequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.chatRequestMessage) } // optional .ChatMessage chatMessage = 31; @@ -20123,6 +21598,7 @@ inline void LobbyMessage::clear_chatmessage() { clear_has_chatmessage(); } inline const ::ChatMessage& LobbyMessage::chatmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.chatMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return chatmessage_ != NULL ? *chatmessage_ : *default_instance().chatmessage_; #else @@ -20132,6 +21608,7 @@ inline const ::ChatMessage& LobbyMessage::chatmessage() const { inline ::ChatMessage* LobbyMessage::mutable_chatmessage() { set_has_chatmessage(); if (chatmessage_ == NULL) chatmessage_ = new ::ChatMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.chatMessage) return chatmessage_; } inline ::ChatMessage* LobbyMessage::release_chatmessage() { @@ -20148,6 +21625,7 @@ inline void LobbyMessage::set_allocated_chatmessage(::ChatMessage* chatmessage) } else { clear_has_chatmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.chatMessage) } // optional .ChatRejectMessage chatRejectMessage = 32; @@ -20165,6 +21643,7 @@ inline void LobbyMessage::clear_chatrejectmessage() { clear_has_chatrejectmessage(); } inline const ::ChatRejectMessage& LobbyMessage::chatrejectmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.chatRejectMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return chatrejectmessage_ != NULL ? *chatrejectmessage_ : *default_instance().chatrejectmessage_; #else @@ -20174,6 +21653,7 @@ inline const ::ChatRejectMessage& LobbyMessage::chatrejectmessage() const { inline ::ChatRejectMessage* LobbyMessage::mutable_chatrejectmessage() { set_has_chatrejectmessage(); if (chatrejectmessage_ == NULL) chatrejectmessage_ = new ::ChatRejectMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.chatRejectMessage) return chatrejectmessage_; } inline ::ChatRejectMessage* LobbyMessage::release_chatrejectmessage() { @@ -20190,6 +21670,7 @@ inline void LobbyMessage::set_allocated_chatrejectmessage(::ChatRejectMessage* c } else { clear_has_chatrejectmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.chatRejectMessage) } // optional .DialogMessage dialogMessage = 33; @@ -20207,6 +21688,7 @@ inline void LobbyMessage::clear_dialogmessage() { clear_has_dialogmessage(); } inline const ::DialogMessage& LobbyMessage::dialogmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.dialogMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return dialogmessage_ != NULL ? *dialogmessage_ : *default_instance().dialogmessage_; #else @@ -20216,6 +21698,7 @@ inline const ::DialogMessage& LobbyMessage::dialogmessage() const { inline ::DialogMessage* LobbyMessage::mutable_dialogmessage() { set_has_dialogmessage(); if (dialogmessage_ == NULL) dialogmessage_ = new ::DialogMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.dialogMessage) return dialogmessage_; } inline ::DialogMessage* LobbyMessage::release_dialogmessage() { @@ -20232,6 +21715,7 @@ inline void LobbyMessage::set_allocated_dialogmessage(::DialogMessage* dialogmes } else { clear_has_dialogmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.dialogMessage) } // optional .TimeoutWarningMessage timeoutWarningMessage = 34; @@ -20249,6 +21733,7 @@ inline void LobbyMessage::clear_timeoutwarningmessage() { clear_has_timeoutwarningmessage(); } inline const ::TimeoutWarningMessage& LobbyMessage::timeoutwarningmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.timeoutWarningMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return timeoutwarningmessage_ != NULL ? *timeoutwarningmessage_ : *default_instance().timeoutwarningmessage_; #else @@ -20258,6 +21743,7 @@ inline const ::TimeoutWarningMessage& LobbyMessage::timeoutwarningmessage() cons inline ::TimeoutWarningMessage* LobbyMessage::mutable_timeoutwarningmessage() { set_has_timeoutwarningmessage(); if (timeoutwarningmessage_ == NULL) timeoutwarningmessage_ = new ::TimeoutWarningMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.timeoutWarningMessage) return timeoutwarningmessage_; } inline ::TimeoutWarningMessage* LobbyMessage::release_timeoutwarningmessage() { @@ -20274,6 +21760,7 @@ inline void LobbyMessage::set_allocated_timeoutwarningmessage(::TimeoutWarningMe } else { clear_has_timeoutwarningmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.timeoutWarningMessage) } // optional .ResetTimeoutMessage resetTimeoutMessage = 35; @@ -20291,6 +21778,7 @@ inline void LobbyMessage::clear_resettimeoutmessage() { clear_has_resettimeoutmessage(); } inline const ::ResetTimeoutMessage& LobbyMessage::resettimeoutmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.resetTimeoutMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return resettimeoutmessage_ != NULL ? *resettimeoutmessage_ : *default_instance().resettimeoutmessage_; #else @@ -20300,6 +21788,7 @@ inline const ::ResetTimeoutMessage& LobbyMessage::resettimeoutmessage() const { inline ::ResetTimeoutMessage* LobbyMessage::mutable_resettimeoutmessage() { set_has_resettimeoutmessage(); if (resettimeoutmessage_ == NULL) resettimeoutmessage_ = new ::ResetTimeoutMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.resetTimeoutMessage) return resettimeoutmessage_; } inline ::ResetTimeoutMessage* LobbyMessage::release_resettimeoutmessage() { @@ -20316,6 +21805,7 @@ inline void LobbyMessage::set_allocated_resettimeoutmessage(::ResetTimeoutMessag } else { clear_has_resettimeoutmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.resetTimeoutMessage) } // optional .ReportAvatarMessage reportAvatarMessage = 36; @@ -20333,6 +21823,7 @@ inline void LobbyMessage::clear_reportavatarmessage() { clear_has_reportavatarmessage(); } inline const ::ReportAvatarMessage& LobbyMessage::reportavatarmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.reportAvatarMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return reportavatarmessage_ != NULL ? *reportavatarmessage_ : *default_instance().reportavatarmessage_; #else @@ -20342,6 +21833,7 @@ inline const ::ReportAvatarMessage& LobbyMessage::reportavatarmessage() const { inline ::ReportAvatarMessage* LobbyMessage::mutable_reportavatarmessage() { set_has_reportavatarmessage(); if (reportavatarmessage_ == NULL) reportavatarmessage_ = new ::ReportAvatarMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.reportAvatarMessage) return reportavatarmessage_; } inline ::ReportAvatarMessage* LobbyMessage::release_reportavatarmessage() { @@ -20358,6 +21850,7 @@ inline void LobbyMessage::set_allocated_reportavatarmessage(::ReportAvatarMessag } else { clear_has_reportavatarmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.reportAvatarMessage) } // optional .ReportAvatarAckMessage reportAvatarAckMessage = 37; @@ -20375,6 +21868,7 @@ inline void LobbyMessage::clear_reportavatarackmessage() { clear_has_reportavatarackmessage(); } inline const ::ReportAvatarAckMessage& LobbyMessage::reportavatarackmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.reportAvatarAckMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return reportavatarackmessage_ != NULL ? *reportavatarackmessage_ : *default_instance().reportavatarackmessage_; #else @@ -20384,6 +21878,7 @@ inline const ::ReportAvatarAckMessage& LobbyMessage::reportavatarackmessage() co inline ::ReportAvatarAckMessage* LobbyMessage::mutable_reportavatarackmessage() { set_has_reportavatarackmessage(); if (reportavatarackmessage_ == NULL) reportavatarackmessage_ = new ::ReportAvatarAckMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.reportAvatarAckMessage) return reportavatarackmessage_; } inline ::ReportAvatarAckMessage* LobbyMessage::release_reportavatarackmessage() { @@ -20400,6 +21895,7 @@ inline void LobbyMessage::set_allocated_reportavatarackmessage(::ReportAvatarAck } else { clear_has_reportavatarackmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.reportAvatarAckMessage) } // optional .ReportGameMessage reportGameMessage = 38; @@ -20417,6 +21913,7 @@ inline void LobbyMessage::clear_reportgamemessage() { clear_has_reportgamemessage(); } inline const ::ReportGameMessage& LobbyMessage::reportgamemessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.reportGameMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return reportgamemessage_ != NULL ? *reportgamemessage_ : *default_instance().reportgamemessage_; #else @@ -20426,6 +21923,7 @@ inline const ::ReportGameMessage& LobbyMessage::reportgamemessage() const { inline ::ReportGameMessage* LobbyMessage::mutable_reportgamemessage() { set_has_reportgamemessage(); if (reportgamemessage_ == NULL) reportgamemessage_ = new ::ReportGameMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.reportGameMessage) return reportgamemessage_; } inline ::ReportGameMessage* LobbyMessage::release_reportgamemessage() { @@ -20442,6 +21940,7 @@ inline void LobbyMessage::set_allocated_reportgamemessage(::ReportGameMessage* r } else { clear_has_reportgamemessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.reportGameMessage) } // optional .ReportGameAckMessage reportGameAckMessage = 39; @@ -20459,6 +21958,7 @@ inline void LobbyMessage::clear_reportgameackmessage() { clear_has_reportgameackmessage(); } inline const ::ReportGameAckMessage& LobbyMessage::reportgameackmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.reportGameAckMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return reportgameackmessage_ != NULL ? *reportgameackmessage_ : *default_instance().reportgameackmessage_; #else @@ -20468,6 +21968,7 @@ inline const ::ReportGameAckMessage& LobbyMessage::reportgameackmessage() const inline ::ReportGameAckMessage* LobbyMessage::mutable_reportgameackmessage() { set_has_reportgameackmessage(); if (reportgameackmessage_ == NULL) reportgameackmessage_ = new ::ReportGameAckMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.reportGameAckMessage) return reportgameackmessage_; } inline ::ReportGameAckMessage* LobbyMessage::release_reportgameackmessage() { @@ -20484,6 +21985,7 @@ inline void LobbyMessage::set_allocated_reportgameackmessage(::ReportGameAckMess } else { clear_has_reportgameackmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.reportGameAckMessage) } // optional .AdminRemoveGameMessage adminRemoveGameMessage = 40; @@ -20501,6 +22003,7 @@ inline void LobbyMessage::clear_adminremovegamemessage() { clear_has_adminremovegamemessage(); } inline const ::AdminRemoveGameMessage& LobbyMessage::adminremovegamemessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.adminRemoveGameMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return adminremovegamemessage_ != NULL ? *adminremovegamemessage_ : *default_instance().adminremovegamemessage_; #else @@ -20510,6 +22013,7 @@ inline const ::AdminRemoveGameMessage& LobbyMessage::adminremovegamemessage() co inline ::AdminRemoveGameMessage* LobbyMessage::mutable_adminremovegamemessage() { set_has_adminremovegamemessage(); if (adminremovegamemessage_ == NULL) adminremovegamemessage_ = new ::AdminRemoveGameMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.adminRemoveGameMessage) return adminremovegamemessage_; } inline ::AdminRemoveGameMessage* LobbyMessage::release_adminremovegamemessage() { @@ -20526,6 +22030,7 @@ inline void LobbyMessage::set_allocated_adminremovegamemessage(::AdminRemoveGame } else { clear_has_adminremovegamemessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.adminRemoveGameMessage) } // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 41; @@ -20543,6 +22048,7 @@ inline void LobbyMessage::clear_adminremovegameackmessage() { clear_has_adminremovegameackmessage(); } inline const ::AdminRemoveGameAckMessage& LobbyMessage::adminremovegameackmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.adminRemoveGameAckMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return adminremovegameackmessage_ != NULL ? *adminremovegameackmessage_ : *default_instance().adminremovegameackmessage_; #else @@ -20552,6 +22058,7 @@ inline const ::AdminRemoveGameAckMessage& LobbyMessage::adminremovegameackmessag inline ::AdminRemoveGameAckMessage* LobbyMessage::mutable_adminremovegameackmessage() { set_has_adminremovegameackmessage(); if (adminremovegameackmessage_ == NULL) adminremovegameackmessage_ = new ::AdminRemoveGameAckMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.adminRemoveGameAckMessage) return adminremovegameackmessage_; } inline ::AdminRemoveGameAckMessage* LobbyMessage::release_adminremovegameackmessage() { @@ -20568,6 +22075,7 @@ inline void LobbyMessage::set_allocated_adminremovegameackmessage(::AdminRemoveG } else { clear_has_adminremovegameackmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.adminRemoveGameAckMessage) } // optional .AdminBanPlayerMessage adminBanPlayerMessage = 42; @@ -20585,6 +22093,7 @@ inline void LobbyMessage::clear_adminbanplayermessage() { clear_has_adminbanplayermessage(); } inline const ::AdminBanPlayerMessage& LobbyMessage::adminbanplayermessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.adminBanPlayerMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return adminbanplayermessage_ != NULL ? *adminbanplayermessage_ : *default_instance().adminbanplayermessage_; #else @@ -20594,6 +22103,7 @@ inline const ::AdminBanPlayerMessage& LobbyMessage::adminbanplayermessage() cons inline ::AdminBanPlayerMessage* LobbyMessage::mutable_adminbanplayermessage() { set_has_adminbanplayermessage(); if (adminbanplayermessage_ == NULL) adminbanplayermessage_ = new ::AdminBanPlayerMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.adminBanPlayerMessage) return adminbanplayermessage_; } inline ::AdminBanPlayerMessage* LobbyMessage::release_adminbanplayermessage() { @@ -20610,6 +22120,7 @@ inline void LobbyMessage::set_allocated_adminbanplayermessage(::AdminBanPlayerMe } else { clear_has_adminbanplayermessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.adminBanPlayerMessage) } // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 43; @@ -20627,6 +22138,7 @@ inline void LobbyMessage::clear_adminbanplayerackmessage() { clear_has_adminbanplayerackmessage(); } inline const ::AdminBanPlayerAckMessage& LobbyMessage::adminbanplayerackmessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.adminBanPlayerAckMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return adminbanplayerackmessage_ != NULL ? *adminbanplayerackmessage_ : *default_instance().adminbanplayerackmessage_; #else @@ -20636,6 +22148,7 @@ inline const ::AdminBanPlayerAckMessage& LobbyMessage::adminbanplayerackmessage( inline ::AdminBanPlayerAckMessage* LobbyMessage::mutable_adminbanplayerackmessage() { set_has_adminbanplayerackmessage(); if (adminbanplayerackmessage_ == NULL) adminbanplayerackmessage_ = new ::AdminBanPlayerAckMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.adminBanPlayerAckMessage) return adminbanplayerackmessage_; } inline ::AdminBanPlayerAckMessage* LobbyMessage::release_adminbanplayerackmessage() { @@ -20652,6 +22165,7 @@ inline void LobbyMessage::set_allocated_adminbanplayerackmessage(::AdminBanPlaye } else { clear_has_adminbanplayerackmessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.adminBanPlayerAckMessage) } // optional .ErrorMessage errorMessage = 1025; @@ -20669,6 +22183,7 @@ inline void LobbyMessage::clear_errormessage() { clear_has_errormessage(); } inline const ::ErrorMessage& LobbyMessage::errormessage() const { + // @@protoc_insertion_point(field_get:LobbyMessage.errorMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return errormessage_ != NULL ? *errormessage_ : *default_instance().errormessage_; #else @@ -20678,6 +22193,7 @@ inline const ::ErrorMessage& LobbyMessage::errormessage() const { inline ::ErrorMessage* LobbyMessage::mutable_errormessage() { set_has_errormessage(); if (errormessage_ == NULL) errormessage_ = new ::ErrorMessage; + // @@protoc_insertion_point(field_mutable:LobbyMessage.errorMessage) return errormessage_; } inline ::ErrorMessage* LobbyMessage::release_errormessage() { @@ -20694,6 +22210,7 @@ inline void LobbyMessage::set_allocated_errormessage(::ErrorMessage* errormessag } else { clear_has_errormessage(); } + // @@protoc_insertion_point(field_set_allocated:LobbyMessage.errorMessage) } // ------------------------------------------------------------------- @@ -20715,12 +22232,14 @@ inline void GameManagementMessage::clear_messagetype() { clear_has_messagetype(); } inline ::GameManagementMessage_GameManagementMessageType GameManagementMessage::messagetype() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.messageType) return static_cast< ::GameManagementMessage_GameManagementMessageType >(messagetype_); } inline void GameManagementMessage::set_messagetype(::GameManagementMessage_GameManagementMessageType value) { assert(::GameManagementMessage_GameManagementMessageType_IsValid(value)); set_has_messagetype(); messagetype_ = value; + // @@protoc_insertion_point(field_set:GameManagementMessage.messageType) } // optional .GamePlayerJoinedMessage gamePlayerJoinedMessage = 2; @@ -20738,6 +22257,7 @@ inline void GameManagementMessage::clear_gameplayerjoinedmessage() { clear_has_gameplayerjoinedmessage(); } inline const ::GamePlayerJoinedMessage& GameManagementMessage::gameplayerjoinedmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.gamePlayerJoinedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gameplayerjoinedmessage_ != NULL ? *gameplayerjoinedmessage_ : *default_instance().gameplayerjoinedmessage_; #else @@ -20747,6 +22267,7 @@ inline const ::GamePlayerJoinedMessage& GameManagementMessage::gameplayerjoinedm inline ::GamePlayerJoinedMessage* GameManagementMessage::mutable_gameplayerjoinedmessage() { set_has_gameplayerjoinedmessage(); if (gameplayerjoinedmessage_ == NULL) gameplayerjoinedmessage_ = new ::GamePlayerJoinedMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.gamePlayerJoinedMessage) return gameplayerjoinedmessage_; } inline ::GamePlayerJoinedMessage* GameManagementMessage::release_gameplayerjoinedmessage() { @@ -20763,6 +22284,7 @@ inline void GameManagementMessage::set_allocated_gameplayerjoinedmessage(::GameP } else { clear_has_gameplayerjoinedmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.gamePlayerJoinedMessage) } // optional .GamePlayerLeftMessage gamePlayerLeftMessage = 3; @@ -20780,6 +22302,7 @@ inline void GameManagementMessage::clear_gameplayerleftmessage() { clear_has_gameplayerleftmessage(); } inline const ::GamePlayerLeftMessage& GameManagementMessage::gameplayerleftmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.gamePlayerLeftMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gameplayerleftmessage_ != NULL ? *gameplayerleftmessage_ : *default_instance().gameplayerleftmessage_; #else @@ -20789,6 +22312,7 @@ inline const ::GamePlayerLeftMessage& GameManagementMessage::gameplayerleftmessa inline ::GamePlayerLeftMessage* GameManagementMessage::mutable_gameplayerleftmessage() { set_has_gameplayerleftmessage(); if (gameplayerleftmessage_ == NULL) gameplayerleftmessage_ = new ::GamePlayerLeftMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.gamePlayerLeftMessage) return gameplayerleftmessage_; } inline ::GamePlayerLeftMessage* GameManagementMessage::release_gameplayerleftmessage() { @@ -20805,6 +22329,7 @@ inline void GameManagementMessage::set_allocated_gameplayerleftmessage(::GamePla } else { clear_has_gameplayerleftmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.gamePlayerLeftMessage) } // optional .GameSpectatorJoinedMessage gameSpectatorJoinedMessage = 4; @@ -20822,6 +22347,7 @@ inline void GameManagementMessage::clear_gamespectatorjoinedmessage() { clear_has_gamespectatorjoinedmessage(); } inline const ::GameSpectatorJoinedMessage& GameManagementMessage::gamespectatorjoinedmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.gameSpectatorJoinedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamespectatorjoinedmessage_ != NULL ? *gamespectatorjoinedmessage_ : *default_instance().gamespectatorjoinedmessage_; #else @@ -20831,6 +22357,7 @@ inline const ::GameSpectatorJoinedMessage& GameManagementMessage::gamespectatorj inline ::GameSpectatorJoinedMessage* GameManagementMessage::mutable_gamespectatorjoinedmessage() { set_has_gamespectatorjoinedmessage(); if (gamespectatorjoinedmessage_ == NULL) gamespectatorjoinedmessage_ = new ::GameSpectatorJoinedMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.gameSpectatorJoinedMessage) return gamespectatorjoinedmessage_; } inline ::GameSpectatorJoinedMessage* GameManagementMessage::release_gamespectatorjoinedmessage() { @@ -20847,6 +22374,7 @@ inline void GameManagementMessage::set_allocated_gamespectatorjoinedmessage(::Ga } else { clear_has_gamespectatorjoinedmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.gameSpectatorJoinedMessage) } // optional .GameSpectatorLeftMessage gameSpectatorLeftMessage = 5; @@ -20864,6 +22392,7 @@ inline void GameManagementMessage::clear_gamespectatorleftmessage() { clear_has_gamespectatorleftmessage(); } inline const ::GameSpectatorLeftMessage& GameManagementMessage::gamespectatorleftmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.gameSpectatorLeftMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamespectatorleftmessage_ != NULL ? *gamespectatorleftmessage_ : *default_instance().gamespectatorleftmessage_; #else @@ -20873,6 +22402,7 @@ inline const ::GameSpectatorLeftMessage& GameManagementMessage::gamespectatorlef inline ::GameSpectatorLeftMessage* GameManagementMessage::mutable_gamespectatorleftmessage() { set_has_gamespectatorleftmessage(); if (gamespectatorleftmessage_ == NULL) gamespectatorleftmessage_ = new ::GameSpectatorLeftMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.gameSpectatorLeftMessage) return gamespectatorleftmessage_; } inline ::GameSpectatorLeftMessage* GameManagementMessage::release_gamespectatorleftmessage() { @@ -20889,6 +22419,7 @@ inline void GameManagementMessage::set_allocated_gamespectatorleftmessage(::Game } else { clear_has_gamespectatorleftmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.gameSpectatorLeftMessage) } // optional .GameAdminChangedMessage gameAdminChangedMessage = 6; @@ -20906,6 +22437,7 @@ inline void GameManagementMessage::clear_gameadminchangedmessage() { clear_has_gameadminchangedmessage(); } inline const ::GameAdminChangedMessage& GameManagementMessage::gameadminchangedmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.gameAdminChangedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gameadminchangedmessage_ != NULL ? *gameadminchangedmessage_ : *default_instance().gameadminchangedmessage_; #else @@ -20915,6 +22447,7 @@ inline const ::GameAdminChangedMessage& GameManagementMessage::gameadminchangedm inline ::GameAdminChangedMessage* GameManagementMessage::mutable_gameadminchangedmessage() { set_has_gameadminchangedmessage(); if (gameadminchangedmessage_ == NULL) gameadminchangedmessage_ = new ::GameAdminChangedMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.gameAdminChangedMessage) return gameadminchangedmessage_; } inline ::GameAdminChangedMessage* GameManagementMessage::release_gameadminchangedmessage() { @@ -20931,6 +22464,7 @@ inline void GameManagementMessage::set_allocated_gameadminchangedmessage(::GameA } else { clear_has_gameadminchangedmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.gameAdminChangedMessage) } // optional .RemovedFromGameMessage removedFromGameMessage = 7; @@ -20948,6 +22482,7 @@ inline void GameManagementMessage::clear_removedfromgamemessage() { clear_has_removedfromgamemessage(); } inline const ::RemovedFromGameMessage& GameManagementMessage::removedfromgamemessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.removedFromGameMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return removedfromgamemessage_ != NULL ? *removedfromgamemessage_ : *default_instance().removedfromgamemessage_; #else @@ -20957,6 +22492,7 @@ inline const ::RemovedFromGameMessage& GameManagementMessage::removedfromgamemes inline ::RemovedFromGameMessage* GameManagementMessage::mutable_removedfromgamemessage() { set_has_removedfromgamemessage(); if (removedfromgamemessage_ == NULL) removedfromgamemessage_ = new ::RemovedFromGameMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.removedFromGameMessage) return removedfromgamemessage_; } inline ::RemovedFromGameMessage* GameManagementMessage::release_removedfromgamemessage() { @@ -20973,6 +22509,7 @@ inline void GameManagementMessage::set_allocated_removedfromgamemessage(::Remove } else { clear_has_removedfromgamemessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.removedFromGameMessage) } // optional .KickPlayerRequestMessage kickPlayerRequestMessage = 8; @@ -20990,6 +22527,7 @@ inline void GameManagementMessage::clear_kickplayerrequestmessage() { clear_has_kickplayerrequestmessage(); } inline const ::KickPlayerRequestMessage& GameManagementMessage::kickplayerrequestmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.kickPlayerRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return kickplayerrequestmessage_ != NULL ? *kickplayerrequestmessage_ : *default_instance().kickplayerrequestmessage_; #else @@ -20999,6 +22537,7 @@ inline const ::KickPlayerRequestMessage& GameManagementMessage::kickplayerreques inline ::KickPlayerRequestMessage* GameManagementMessage::mutable_kickplayerrequestmessage() { set_has_kickplayerrequestmessage(); if (kickplayerrequestmessage_ == NULL) kickplayerrequestmessage_ = new ::KickPlayerRequestMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.kickPlayerRequestMessage) return kickplayerrequestmessage_; } inline ::KickPlayerRequestMessage* GameManagementMessage::release_kickplayerrequestmessage() { @@ -21015,6 +22554,7 @@ inline void GameManagementMessage::set_allocated_kickplayerrequestmessage(::Kick } else { clear_has_kickplayerrequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.kickPlayerRequestMessage) } // optional .LeaveGameRequestMessage leaveGameRequestMessage = 9; @@ -21032,6 +22572,7 @@ inline void GameManagementMessage::clear_leavegamerequestmessage() { clear_has_leavegamerequestmessage(); } inline const ::LeaveGameRequestMessage& GameManagementMessage::leavegamerequestmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.leaveGameRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return leavegamerequestmessage_ != NULL ? *leavegamerequestmessage_ : *default_instance().leavegamerequestmessage_; #else @@ -21041,6 +22582,7 @@ inline const ::LeaveGameRequestMessage& GameManagementMessage::leavegamerequestm inline ::LeaveGameRequestMessage* GameManagementMessage::mutable_leavegamerequestmessage() { set_has_leavegamerequestmessage(); if (leavegamerequestmessage_ == NULL) leavegamerequestmessage_ = new ::LeaveGameRequestMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.leaveGameRequestMessage) return leavegamerequestmessage_; } inline ::LeaveGameRequestMessage* GameManagementMessage::release_leavegamerequestmessage() { @@ -21057,6 +22599,7 @@ inline void GameManagementMessage::set_allocated_leavegamerequestmessage(::Leave } else { clear_has_leavegamerequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.leaveGameRequestMessage) } // optional .InvitePlayerToGameMessage invitePlayerToGameMessage = 10; @@ -21074,6 +22617,7 @@ inline void GameManagementMessage::clear_inviteplayertogamemessage() { clear_has_inviteplayertogamemessage(); } inline const ::InvitePlayerToGameMessage& GameManagementMessage::inviteplayertogamemessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.invitePlayerToGameMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return inviteplayertogamemessage_ != NULL ? *inviteplayertogamemessage_ : *default_instance().inviteplayertogamemessage_; #else @@ -21083,6 +22627,7 @@ inline const ::InvitePlayerToGameMessage& GameManagementMessage::inviteplayertog inline ::InvitePlayerToGameMessage* GameManagementMessage::mutable_inviteplayertogamemessage() { set_has_inviteplayertogamemessage(); if (inviteplayertogamemessage_ == NULL) inviteplayertogamemessage_ = new ::InvitePlayerToGameMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.invitePlayerToGameMessage) return inviteplayertogamemessage_; } inline ::InvitePlayerToGameMessage* GameManagementMessage::release_inviteplayertogamemessage() { @@ -21099,6 +22644,7 @@ inline void GameManagementMessage::set_allocated_inviteplayertogamemessage(::Inv } else { clear_has_inviteplayertogamemessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.invitePlayerToGameMessage) } // optional .StartEventMessage startEventMessage = 11; @@ -21116,6 +22662,7 @@ inline void GameManagementMessage::clear_starteventmessage() { clear_has_starteventmessage(); } inline const ::StartEventMessage& GameManagementMessage::starteventmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.startEventMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return starteventmessage_ != NULL ? *starteventmessage_ : *default_instance().starteventmessage_; #else @@ -21125,6 +22672,7 @@ inline const ::StartEventMessage& GameManagementMessage::starteventmessage() con inline ::StartEventMessage* GameManagementMessage::mutable_starteventmessage() { set_has_starteventmessage(); if (starteventmessage_ == NULL) starteventmessage_ = new ::StartEventMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.startEventMessage) return starteventmessage_; } inline ::StartEventMessage* GameManagementMessage::release_starteventmessage() { @@ -21141,6 +22689,7 @@ inline void GameManagementMessage::set_allocated_starteventmessage(::StartEventM } else { clear_has_starteventmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.startEventMessage) } // optional .StartEventAckMessage startEventAckMessage = 12; @@ -21158,6 +22707,7 @@ inline void GameManagementMessage::clear_starteventackmessage() { clear_has_starteventackmessage(); } inline const ::StartEventAckMessage& GameManagementMessage::starteventackmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.startEventAckMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return starteventackmessage_ != NULL ? *starteventackmessage_ : *default_instance().starteventackmessage_; #else @@ -21167,6 +22717,7 @@ inline const ::StartEventAckMessage& GameManagementMessage::starteventackmessage inline ::StartEventAckMessage* GameManagementMessage::mutable_starteventackmessage() { set_has_starteventackmessage(); if (starteventackmessage_ == NULL) starteventackmessage_ = new ::StartEventAckMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.startEventAckMessage) return starteventackmessage_; } inline ::StartEventAckMessage* GameManagementMessage::release_starteventackmessage() { @@ -21183,6 +22734,7 @@ inline void GameManagementMessage::set_allocated_starteventackmessage(::StartEve } else { clear_has_starteventackmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.startEventAckMessage) } // optional .GameStartInitialMessage gameStartInitialMessage = 13; @@ -21200,6 +22752,7 @@ inline void GameManagementMessage::clear_gamestartinitialmessage() { clear_has_gamestartinitialmessage(); } inline const ::GameStartInitialMessage& GameManagementMessage::gamestartinitialmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.gameStartInitialMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamestartinitialmessage_ != NULL ? *gamestartinitialmessage_ : *default_instance().gamestartinitialmessage_; #else @@ -21209,6 +22762,7 @@ inline const ::GameStartInitialMessage& GameManagementMessage::gamestartinitialm inline ::GameStartInitialMessage* GameManagementMessage::mutable_gamestartinitialmessage() { set_has_gamestartinitialmessage(); if (gamestartinitialmessage_ == NULL) gamestartinitialmessage_ = new ::GameStartInitialMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.gameStartInitialMessage) return gamestartinitialmessage_; } inline ::GameStartInitialMessage* GameManagementMessage::release_gamestartinitialmessage() { @@ -21225,6 +22779,7 @@ inline void GameManagementMessage::set_allocated_gamestartinitialmessage(::GameS } else { clear_has_gamestartinitialmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.gameStartInitialMessage) } // optional .GameStartRejoinMessage gameStartRejoinMessage = 14; @@ -21242,6 +22797,7 @@ inline void GameManagementMessage::clear_gamestartrejoinmessage() { clear_has_gamestartrejoinmessage(); } inline const ::GameStartRejoinMessage& GameManagementMessage::gamestartrejoinmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.gameStartRejoinMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamestartrejoinmessage_ != NULL ? *gamestartrejoinmessage_ : *default_instance().gamestartrejoinmessage_; #else @@ -21251,6 +22807,7 @@ inline const ::GameStartRejoinMessage& GameManagementMessage::gamestartrejoinmes inline ::GameStartRejoinMessage* GameManagementMessage::mutable_gamestartrejoinmessage() { set_has_gamestartrejoinmessage(); if (gamestartrejoinmessage_ == NULL) gamestartrejoinmessage_ = new ::GameStartRejoinMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.gameStartRejoinMessage) return gamestartrejoinmessage_; } inline ::GameStartRejoinMessage* GameManagementMessage::release_gamestartrejoinmessage() { @@ -21267,6 +22824,7 @@ inline void GameManagementMessage::set_allocated_gamestartrejoinmessage(::GameSt } else { clear_has_gamestartrejoinmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.gameStartRejoinMessage) } // optional .EndOfGameMessage endOfGameMessage = 15; @@ -21284,6 +22842,7 @@ inline void GameManagementMessage::clear_endofgamemessage() { clear_has_endofgamemessage(); } inline const ::EndOfGameMessage& GameManagementMessage::endofgamemessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.endOfGameMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return endofgamemessage_ != NULL ? *endofgamemessage_ : *default_instance().endofgamemessage_; #else @@ -21293,6 +22852,7 @@ inline const ::EndOfGameMessage& GameManagementMessage::endofgamemessage() const inline ::EndOfGameMessage* GameManagementMessage::mutable_endofgamemessage() { set_has_endofgamemessage(); if (endofgamemessage_ == NULL) endofgamemessage_ = new ::EndOfGameMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.endOfGameMessage) return endofgamemessage_; } inline ::EndOfGameMessage* GameManagementMessage::release_endofgamemessage() { @@ -21309,6 +22869,7 @@ inline void GameManagementMessage::set_allocated_endofgamemessage(::EndOfGameMes } else { clear_has_endofgamemessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.endOfGameMessage) } // optional .PlayerIdChangedMessage playerIdChangedMessage = 16; @@ -21326,6 +22887,7 @@ inline void GameManagementMessage::clear_playeridchangedmessage() { clear_has_playeridchangedmessage(); } inline const ::PlayerIdChangedMessage& GameManagementMessage::playeridchangedmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.playerIdChangedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return playeridchangedmessage_ != NULL ? *playeridchangedmessage_ : *default_instance().playeridchangedmessage_; #else @@ -21335,6 +22897,7 @@ inline const ::PlayerIdChangedMessage& GameManagementMessage::playeridchangedmes inline ::PlayerIdChangedMessage* GameManagementMessage::mutable_playeridchangedmessage() { set_has_playeridchangedmessage(); if (playeridchangedmessage_ == NULL) playeridchangedmessage_ = new ::PlayerIdChangedMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.playerIdChangedMessage) return playeridchangedmessage_; } inline ::PlayerIdChangedMessage* GameManagementMessage::release_playeridchangedmessage() { @@ -21351,6 +22914,7 @@ inline void GameManagementMessage::set_allocated_playeridchangedmessage(::Player } else { clear_has_playeridchangedmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.playerIdChangedMessage) } // optional .AskKickPlayerMessage askKickPlayerMessage = 17; @@ -21368,6 +22932,7 @@ inline void GameManagementMessage::clear_askkickplayermessage() { clear_has_askkickplayermessage(); } inline const ::AskKickPlayerMessage& GameManagementMessage::askkickplayermessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.askKickPlayerMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return askkickplayermessage_ != NULL ? *askkickplayermessage_ : *default_instance().askkickplayermessage_; #else @@ -21377,6 +22942,7 @@ inline const ::AskKickPlayerMessage& GameManagementMessage::askkickplayermessage inline ::AskKickPlayerMessage* GameManagementMessage::mutable_askkickplayermessage() { set_has_askkickplayermessage(); if (askkickplayermessage_ == NULL) askkickplayermessage_ = new ::AskKickPlayerMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.askKickPlayerMessage) return askkickplayermessage_; } inline ::AskKickPlayerMessage* GameManagementMessage::release_askkickplayermessage() { @@ -21393,6 +22959,7 @@ inline void GameManagementMessage::set_allocated_askkickplayermessage(::AskKickP } else { clear_has_askkickplayermessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.askKickPlayerMessage) } // optional .AskKickDeniedMessage askKickDeniedMessage = 18; @@ -21410,6 +22977,7 @@ inline void GameManagementMessage::clear_askkickdeniedmessage() { clear_has_askkickdeniedmessage(); } inline const ::AskKickDeniedMessage& GameManagementMessage::askkickdeniedmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.askKickDeniedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return askkickdeniedmessage_ != NULL ? *askkickdeniedmessage_ : *default_instance().askkickdeniedmessage_; #else @@ -21419,6 +22987,7 @@ inline const ::AskKickDeniedMessage& GameManagementMessage::askkickdeniedmessage inline ::AskKickDeniedMessage* GameManagementMessage::mutable_askkickdeniedmessage() { set_has_askkickdeniedmessage(); if (askkickdeniedmessage_ == NULL) askkickdeniedmessage_ = new ::AskKickDeniedMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.askKickDeniedMessage) return askkickdeniedmessage_; } inline ::AskKickDeniedMessage* GameManagementMessage::release_askkickdeniedmessage() { @@ -21435,6 +23004,7 @@ inline void GameManagementMessage::set_allocated_askkickdeniedmessage(::AskKickD } else { clear_has_askkickdeniedmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.askKickDeniedMessage) } // optional .StartKickPetitionMessage startKickPetitionMessage = 19; @@ -21452,6 +23022,7 @@ inline void GameManagementMessage::clear_startkickpetitionmessage() { clear_has_startkickpetitionmessage(); } inline const ::StartKickPetitionMessage& GameManagementMessage::startkickpetitionmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.startKickPetitionMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return startkickpetitionmessage_ != NULL ? *startkickpetitionmessage_ : *default_instance().startkickpetitionmessage_; #else @@ -21461,6 +23032,7 @@ inline const ::StartKickPetitionMessage& GameManagementMessage::startkickpetitio inline ::StartKickPetitionMessage* GameManagementMessage::mutable_startkickpetitionmessage() { set_has_startkickpetitionmessage(); if (startkickpetitionmessage_ == NULL) startkickpetitionmessage_ = new ::StartKickPetitionMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.startKickPetitionMessage) return startkickpetitionmessage_; } inline ::StartKickPetitionMessage* GameManagementMessage::release_startkickpetitionmessage() { @@ -21477,6 +23049,7 @@ inline void GameManagementMessage::set_allocated_startkickpetitionmessage(::Star } else { clear_has_startkickpetitionmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.startKickPetitionMessage) } // optional .VoteKickRequestMessage voteKickRequestMessage = 20; @@ -21494,6 +23067,7 @@ inline void GameManagementMessage::clear_votekickrequestmessage() { clear_has_votekickrequestmessage(); } inline const ::VoteKickRequestMessage& GameManagementMessage::votekickrequestmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.voteKickRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return votekickrequestmessage_ != NULL ? *votekickrequestmessage_ : *default_instance().votekickrequestmessage_; #else @@ -21503,6 +23077,7 @@ inline const ::VoteKickRequestMessage& GameManagementMessage::votekickrequestmes inline ::VoteKickRequestMessage* GameManagementMessage::mutable_votekickrequestmessage() { set_has_votekickrequestmessage(); if (votekickrequestmessage_ == NULL) votekickrequestmessage_ = new ::VoteKickRequestMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.voteKickRequestMessage) return votekickrequestmessage_; } inline ::VoteKickRequestMessage* GameManagementMessage::release_votekickrequestmessage() { @@ -21519,6 +23094,7 @@ inline void GameManagementMessage::set_allocated_votekickrequestmessage(::VoteKi } else { clear_has_votekickrequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.voteKickRequestMessage) } // optional .VoteKickReplyMessage voteKickReplyMessage = 21; @@ -21536,6 +23112,7 @@ inline void GameManagementMessage::clear_votekickreplymessage() { clear_has_votekickreplymessage(); } inline const ::VoteKickReplyMessage& GameManagementMessage::votekickreplymessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.voteKickReplyMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return votekickreplymessage_ != NULL ? *votekickreplymessage_ : *default_instance().votekickreplymessage_; #else @@ -21545,6 +23122,7 @@ inline const ::VoteKickReplyMessage& GameManagementMessage::votekickreplymessage inline ::VoteKickReplyMessage* GameManagementMessage::mutable_votekickreplymessage() { set_has_votekickreplymessage(); if (votekickreplymessage_ == NULL) votekickreplymessage_ = new ::VoteKickReplyMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.voteKickReplyMessage) return votekickreplymessage_; } inline ::VoteKickReplyMessage* GameManagementMessage::release_votekickreplymessage() { @@ -21561,6 +23139,7 @@ inline void GameManagementMessage::set_allocated_votekickreplymessage(::VoteKick } else { clear_has_votekickreplymessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.voteKickReplyMessage) } // optional .KickPetitionUpdateMessage kickPetitionUpdateMessage = 22; @@ -21578,6 +23157,7 @@ inline void GameManagementMessage::clear_kickpetitionupdatemessage() { clear_has_kickpetitionupdatemessage(); } inline const ::KickPetitionUpdateMessage& GameManagementMessage::kickpetitionupdatemessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.kickPetitionUpdateMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return kickpetitionupdatemessage_ != NULL ? *kickpetitionupdatemessage_ : *default_instance().kickpetitionupdatemessage_; #else @@ -21587,6 +23167,7 @@ inline const ::KickPetitionUpdateMessage& GameManagementMessage::kickpetitionupd inline ::KickPetitionUpdateMessage* GameManagementMessage::mutable_kickpetitionupdatemessage() { set_has_kickpetitionupdatemessage(); if (kickpetitionupdatemessage_ == NULL) kickpetitionupdatemessage_ = new ::KickPetitionUpdateMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.kickPetitionUpdateMessage) return kickpetitionupdatemessage_; } inline ::KickPetitionUpdateMessage* GameManagementMessage::release_kickpetitionupdatemessage() { @@ -21603,6 +23184,7 @@ inline void GameManagementMessage::set_allocated_kickpetitionupdatemessage(::Kic } else { clear_has_kickpetitionupdatemessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.kickPetitionUpdateMessage) } // optional .EndKickPetitionMessage endKickPetitionMessage = 23; @@ -21620,6 +23202,7 @@ inline void GameManagementMessage::clear_endkickpetitionmessage() { clear_has_endkickpetitionmessage(); } inline const ::EndKickPetitionMessage& GameManagementMessage::endkickpetitionmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.endKickPetitionMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return endkickpetitionmessage_ != NULL ? *endkickpetitionmessage_ : *default_instance().endkickpetitionmessage_; #else @@ -21629,6 +23212,7 @@ inline const ::EndKickPetitionMessage& GameManagementMessage::endkickpetitionmes inline ::EndKickPetitionMessage* GameManagementMessage::mutable_endkickpetitionmessage() { set_has_endkickpetitionmessage(); if (endkickpetitionmessage_ == NULL) endkickpetitionmessage_ = new ::EndKickPetitionMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.endKickPetitionMessage) return endkickpetitionmessage_; } inline ::EndKickPetitionMessage* GameManagementMessage::release_endkickpetitionmessage() { @@ -21645,6 +23229,7 @@ inline void GameManagementMessage::set_allocated_endkickpetitionmessage(::EndKic } else { clear_has_endkickpetitionmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.endKickPetitionMessage) } // optional .ChatRequestMessage chatRequestMessage = 24; @@ -21662,6 +23247,7 @@ inline void GameManagementMessage::clear_chatrequestmessage() { clear_has_chatrequestmessage(); } inline const ::ChatRequestMessage& GameManagementMessage::chatrequestmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.chatRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return chatrequestmessage_ != NULL ? *chatrequestmessage_ : *default_instance().chatrequestmessage_; #else @@ -21671,6 +23257,7 @@ inline const ::ChatRequestMessage& GameManagementMessage::chatrequestmessage() c inline ::ChatRequestMessage* GameManagementMessage::mutable_chatrequestmessage() { set_has_chatrequestmessage(); if (chatrequestmessage_ == NULL) chatrequestmessage_ = new ::ChatRequestMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.chatRequestMessage) return chatrequestmessage_; } inline ::ChatRequestMessage* GameManagementMessage::release_chatrequestmessage() { @@ -21687,6 +23274,7 @@ inline void GameManagementMessage::set_allocated_chatrequestmessage(::ChatReques } else { clear_has_chatrequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.chatRequestMessage) } // optional .ChatMessage chatMessage = 25; @@ -21704,6 +23292,7 @@ inline void GameManagementMessage::clear_chatmessage() { clear_has_chatmessage(); } inline const ::ChatMessage& GameManagementMessage::chatmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.chatMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return chatmessage_ != NULL ? *chatmessage_ : *default_instance().chatmessage_; #else @@ -21713,6 +23302,7 @@ inline const ::ChatMessage& GameManagementMessage::chatmessage() const { inline ::ChatMessage* GameManagementMessage::mutable_chatmessage() { set_has_chatmessage(); if (chatmessage_ == NULL) chatmessage_ = new ::ChatMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.chatMessage) return chatmessage_; } inline ::ChatMessage* GameManagementMessage::release_chatmessage() { @@ -21729,6 +23319,7 @@ inline void GameManagementMessage::set_allocated_chatmessage(::ChatMessage* chat } else { clear_has_chatmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.chatMessage) } // optional .ChatRejectMessage chatRejectMessage = 26; @@ -21746,6 +23337,7 @@ inline void GameManagementMessage::clear_chatrejectmessage() { clear_has_chatrejectmessage(); } inline const ::ChatRejectMessage& GameManagementMessage::chatrejectmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.chatRejectMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return chatrejectmessage_ != NULL ? *chatrejectmessage_ : *default_instance().chatrejectmessage_; #else @@ -21755,6 +23347,7 @@ inline const ::ChatRejectMessage& GameManagementMessage::chatrejectmessage() con inline ::ChatRejectMessage* GameManagementMessage::mutable_chatrejectmessage() { set_has_chatrejectmessage(); if (chatrejectmessage_ == NULL) chatrejectmessage_ = new ::ChatRejectMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.chatRejectMessage) return chatrejectmessage_; } inline ::ChatRejectMessage* GameManagementMessage::release_chatrejectmessage() { @@ -21771,6 +23364,7 @@ inline void GameManagementMessage::set_allocated_chatrejectmessage(::ChatRejectM } else { clear_has_chatrejectmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.chatRejectMessage) } // optional .TimeoutWarningMessage timeoutWarningMessage = 27; @@ -21788,6 +23382,7 @@ inline void GameManagementMessage::clear_timeoutwarningmessage() { clear_has_timeoutwarningmessage(); } inline const ::TimeoutWarningMessage& GameManagementMessage::timeoutwarningmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.timeoutWarningMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return timeoutwarningmessage_ != NULL ? *timeoutwarningmessage_ : *default_instance().timeoutwarningmessage_; #else @@ -21797,6 +23392,7 @@ inline const ::TimeoutWarningMessage& GameManagementMessage::timeoutwarningmessa inline ::TimeoutWarningMessage* GameManagementMessage::mutable_timeoutwarningmessage() { set_has_timeoutwarningmessage(); if (timeoutwarningmessage_ == NULL) timeoutwarningmessage_ = new ::TimeoutWarningMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.timeoutWarningMessage) return timeoutwarningmessage_; } inline ::TimeoutWarningMessage* GameManagementMessage::release_timeoutwarningmessage() { @@ -21813,6 +23409,7 @@ inline void GameManagementMessage::set_allocated_timeoutwarningmessage(::Timeout } else { clear_has_timeoutwarningmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.timeoutWarningMessage) } // optional .ResetTimeoutMessage resetTimeoutMessage = 28; @@ -21830,6 +23427,7 @@ inline void GameManagementMessage::clear_resettimeoutmessage() { clear_has_resettimeoutmessage(); } inline const ::ResetTimeoutMessage& GameManagementMessage::resettimeoutmessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.resetTimeoutMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return resettimeoutmessage_ != NULL ? *resettimeoutmessage_ : *default_instance().resettimeoutmessage_; #else @@ -21839,6 +23437,7 @@ inline const ::ResetTimeoutMessage& GameManagementMessage::resettimeoutmessage() inline ::ResetTimeoutMessage* GameManagementMessage::mutable_resettimeoutmessage() { set_has_resettimeoutmessage(); if (resettimeoutmessage_ == NULL) resettimeoutmessage_ = new ::ResetTimeoutMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.resetTimeoutMessage) return resettimeoutmessage_; } inline ::ResetTimeoutMessage* GameManagementMessage::release_resettimeoutmessage() { @@ -21855,6 +23454,7 @@ inline void GameManagementMessage::set_allocated_resettimeoutmessage(::ResetTime } else { clear_has_resettimeoutmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.resetTimeoutMessage) } // optional .ErrorMessage errorMessage = 1025; @@ -21872,6 +23472,7 @@ inline void GameManagementMessage::clear_errormessage() { clear_has_errormessage(); } inline const ::ErrorMessage& GameManagementMessage::errormessage() const { + // @@protoc_insertion_point(field_get:GameManagementMessage.errorMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return errormessage_ != NULL ? *errormessage_ : *default_instance().errormessage_; #else @@ -21881,6 +23482,7 @@ inline const ::ErrorMessage& GameManagementMessage::errormessage() const { inline ::ErrorMessage* GameManagementMessage::mutable_errormessage() { set_has_errormessage(); if (errormessage_ == NULL) errormessage_ = new ::ErrorMessage; + // @@protoc_insertion_point(field_mutable:GameManagementMessage.errorMessage) return errormessage_; } inline ::ErrorMessage* GameManagementMessage::release_errormessage() { @@ -21897,6 +23499,7 @@ inline void GameManagementMessage::set_allocated_errormessage(::ErrorMessage* er } else { clear_has_errormessage(); } + // @@protoc_insertion_point(field_set_allocated:GameManagementMessage.errorMessage) } // ------------------------------------------------------------------- @@ -21918,12 +23521,14 @@ inline void GameEngineMessage::clear_messagetype() { clear_has_messagetype(); } inline ::GameEngineMessage_GameEngineMessageType GameEngineMessage::messagetype() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.messageType) return static_cast< ::GameEngineMessage_GameEngineMessageType >(messagetype_); } inline void GameEngineMessage::set_messagetype(::GameEngineMessage_GameEngineMessageType value) { assert(::GameEngineMessage_GameEngineMessageType_IsValid(value)); set_has_messagetype(); messagetype_ = value; + // @@protoc_insertion_point(field_set:GameEngineMessage.messageType) } // optional .HandStartMessage handStartMessage = 2; @@ -21941,6 +23546,7 @@ inline void GameEngineMessage::clear_handstartmessage() { clear_has_handstartmessage(); } inline const ::HandStartMessage& GameEngineMessage::handstartmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.handStartMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return handstartmessage_ != NULL ? *handstartmessage_ : *default_instance().handstartmessage_; #else @@ -21950,6 +23556,7 @@ inline const ::HandStartMessage& GameEngineMessage::handstartmessage() const { inline ::HandStartMessage* GameEngineMessage::mutable_handstartmessage() { set_has_handstartmessage(); if (handstartmessage_ == NULL) handstartmessage_ = new ::HandStartMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.handStartMessage) return handstartmessage_; } inline ::HandStartMessage* GameEngineMessage::release_handstartmessage() { @@ -21966,6 +23573,7 @@ inline void GameEngineMessage::set_allocated_handstartmessage(::HandStartMessage } else { clear_has_handstartmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.handStartMessage) } // optional .PlayersTurnMessage playersTurnMessage = 3; @@ -21983,6 +23591,7 @@ inline void GameEngineMessage::clear_playersturnmessage() { clear_has_playersturnmessage(); } inline const ::PlayersTurnMessage& GameEngineMessage::playersturnmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.playersTurnMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return playersturnmessage_ != NULL ? *playersturnmessage_ : *default_instance().playersturnmessage_; #else @@ -21992,6 +23601,7 @@ inline const ::PlayersTurnMessage& GameEngineMessage::playersturnmessage() const inline ::PlayersTurnMessage* GameEngineMessage::mutable_playersturnmessage() { set_has_playersturnmessage(); if (playersturnmessage_ == NULL) playersturnmessage_ = new ::PlayersTurnMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.playersTurnMessage) return playersturnmessage_; } inline ::PlayersTurnMessage* GameEngineMessage::release_playersturnmessage() { @@ -22008,6 +23618,7 @@ inline void GameEngineMessage::set_allocated_playersturnmessage(::PlayersTurnMes } else { clear_has_playersturnmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.playersTurnMessage) } // optional .MyActionRequestMessage myActionRequestMessage = 4; @@ -22025,6 +23636,7 @@ inline void GameEngineMessage::clear_myactionrequestmessage() { clear_has_myactionrequestmessage(); } inline const ::MyActionRequestMessage& GameEngineMessage::myactionrequestmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.myActionRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return myactionrequestmessage_ != NULL ? *myactionrequestmessage_ : *default_instance().myactionrequestmessage_; #else @@ -22034,6 +23646,7 @@ inline const ::MyActionRequestMessage& GameEngineMessage::myactionrequestmessage inline ::MyActionRequestMessage* GameEngineMessage::mutable_myactionrequestmessage() { set_has_myactionrequestmessage(); if (myactionrequestmessage_ == NULL) myactionrequestmessage_ = new ::MyActionRequestMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.myActionRequestMessage) return myactionrequestmessage_; } inline ::MyActionRequestMessage* GameEngineMessage::release_myactionrequestmessage() { @@ -22050,6 +23663,7 @@ inline void GameEngineMessage::set_allocated_myactionrequestmessage(::MyActionRe } else { clear_has_myactionrequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.myActionRequestMessage) } // optional .YourActionRejectedMessage yourActionRejectedMessage = 5; @@ -22067,6 +23681,7 @@ inline void GameEngineMessage::clear_youractionrejectedmessage() { clear_has_youractionrejectedmessage(); } inline const ::YourActionRejectedMessage& GameEngineMessage::youractionrejectedmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.yourActionRejectedMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return youractionrejectedmessage_ != NULL ? *youractionrejectedmessage_ : *default_instance().youractionrejectedmessage_; #else @@ -22076,6 +23691,7 @@ inline const ::YourActionRejectedMessage& GameEngineMessage::youractionrejectedm inline ::YourActionRejectedMessage* GameEngineMessage::mutable_youractionrejectedmessage() { set_has_youractionrejectedmessage(); if (youractionrejectedmessage_ == NULL) youractionrejectedmessage_ = new ::YourActionRejectedMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.yourActionRejectedMessage) return youractionrejectedmessage_; } inline ::YourActionRejectedMessage* GameEngineMessage::release_youractionrejectedmessage() { @@ -22092,6 +23708,7 @@ inline void GameEngineMessage::set_allocated_youractionrejectedmessage(::YourAct } else { clear_has_youractionrejectedmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.yourActionRejectedMessage) } // optional .PlayersActionDoneMessage playersActionDoneMessage = 6; @@ -22109,6 +23726,7 @@ inline void GameEngineMessage::clear_playersactiondonemessage() { clear_has_playersactiondonemessage(); } inline const ::PlayersActionDoneMessage& GameEngineMessage::playersactiondonemessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.playersActionDoneMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return playersactiondonemessage_ != NULL ? *playersactiondonemessage_ : *default_instance().playersactiondonemessage_; #else @@ -22118,6 +23736,7 @@ inline const ::PlayersActionDoneMessage& GameEngineMessage::playersactiondonemes inline ::PlayersActionDoneMessage* GameEngineMessage::mutable_playersactiondonemessage() { set_has_playersactiondonemessage(); if (playersactiondonemessage_ == NULL) playersactiondonemessage_ = new ::PlayersActionDoneMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.playersActionDoneMessage) return playersactiondonemessage_; } inline ::PlayersActionDoneMessage* GameEngineMessage::release_playersactiondonemessage() { @@ -22134,6 +23753,7 @@ inline void GameEngineMessage::set_allocated_playersactiondonemessage(::PlayersA } else { clear_has_playersactiondonemessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.playersActionDoneMessage) } // optional .DealFlopCardsMessage dealFlopCardsMessage = 7; @@ -22151,6 +23771,7 @@ inline void GameEngineMessage::clear_dealflopcardsmessage() { clear_has_dealflopcardsmessage(); } inline const ::DealFlopCardsMessage& GameEngineMessage::dealflopcardsmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.dealFlopCardsMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return dealflopcardsmessage_ != NULL ? *dealflopcardsmessage_ : *default_instance().dealflopcardsmessage_; #else @@ -22160,6 +23781,7 @@ inline const ::DealFlopCardsMessage& GameEngineMessage::dealflopcardsmessage() c inline ::DealFlopCardsMessage* GameEngineMessage::mutable_dealflopcardsmessage() { set_has_dealflopcardsmessage(); if (dealflopcardsmessage_ == NULL) dealflopcardsmessage_ = new ::DealFlopCardsMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.dealFlopCardsMessage) return dealflopcardsmessage_; } inline ::DealFlopCardsMessage* GameEngineMessage::release_dealflopcardsmessage() { @@ -22176,6 +23798,7 @@ inline void GameEngineMessage::set_allocated_dealflopcardsmessage(::DealFlopCard } else { clear_has_dealflopcardsmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.dealFlopCardsMessage) } // optional .DealTurnCardMessage dealTurnCardMessage = 8; @@ -22193,6 +23816,7 @@ inline void GameEngineMessage::clear_dealturncardmessage() { clear_has_dealturncardmessage(); } inline const ::DealTurnCardMessage& GameEngineMessage::dealturncardmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.dealTurnCardMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return dealturncardmessage_ != NULL ? *dealturncardmessage_ : *default_instance().dealturncardmessage_; #else @@ -22202,6 +23826,7 @@ inline const ::DealTurnCardMessage& GameEngineMessage::dealturncardmessage() con inline ::DealTurnCardMessage* GameEngineMessage::mutable_dealturncardmessage() { set_has_dealturncardmessage(); if (dealturncardmessage_ == NULL) dealturncardmessage_ = new ::DealTurnCardMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.dealTurnCardMessage) return dealturncardmessage_; } inline ::DealTurnCardMessage* GameEngineMessage::release_dealturncardmessage() { @@ -22218,6 +23843,7 @@ inline void GameEngineMessage::set_allocated_dealturncardmessage(::DealTurnCardM } else { clear_has_dealturncardmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.dealTurnCardMessage) } // optional .DealRiverCardMessage dealRiverCardMessage = 9; @@ -22235,6 +23861,7 @@ inline void GameEngineMessage::clear_dealrivercardmessage() { clear_has_dealrivercardmessage(); } inline const ::DealRiverCardMessage& GameEngineMessage::dealrivercardmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.dealRiverCardMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return dealrivercardmessage_ != NULL ? *dealrivercardmessage_ : *default_instance().dealrivercardmessage_; #else @@ -22244,6 +23871,7 @@ inline const ::DealRiverCardMessage& GameEngineMessage::dealrivercardmessage() c inline ::DealRiverCardMessage* GameEngineMessage::mutable_dealrivercardmessage() { set_has_dealrivercardmessage(); if (dealrivercardmessage_ == NULL) dealrivercardmessage_ = new ::DealRiverCardMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.dealRiverCardMessage) return dealrivercardmessage_; } inline ::DealRiverCardMessage* GameEngineMessage::release_dealrivercardmessage() { @@ -22260,6 +23888,7 @@ inline void GameEngineMessage::set_allocated_dealrivercardmessage(::DealRiverCar } else { clear_has_dealrivercardmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.dealRiverCardMessage) } // optional .AllInShowCardsMessage allInShowCardsMessage = 10; @@ -22277,6 +23906,7 @@ inline void GameEngineMessage::clear_allinshowcardsmessage() { clear_has_allinshowcardsmessage(); } inline const ::AllInShowCardsMessage& GameEngineMessage::allinshowcardsmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.allInShowCardsMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return allinshowcardsmessage_ != NULL ? *allinshowcardsmessage_ : *default_instance().allinshowcardsmessage_; #else @@ -22286,6 +23916,7 @@ inline const ::AllInShowCardsMessage& GameEngineMessage::allinshowcardsmessage() inline ::AllInShowCardsMessage* GameEngineMessage::mutable_allinshowcardsmessage() { set_has_allinshowcardsmessage(); if (allinshowcardsmessage_ == NULL) allinshowcardsmessage_ = new ::AllInShowCardsMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.allInShowCardsMessage) return allinshowcardsmessage_; } inline ::AllInShowCardsMessage* GameEngineMessage::release_allinshowcardsmessage() { @@ -22302,6 +23933,7 @@ inline void GameEngineMessage::set_allocated_allinshowcardsmessage(::AllInShowCa } else { clear_has_allinshowcardsmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.allInShowCardsMessage) } // optional .EndOfHandShowCardsMessage endOfHandShowCardsMessage = 11; @@ -22319,6 +23951,7 @@ inline void GameEngineMessage::clear_endofhandshowcardsmessage() { clear_has_endofhandshowcardsmessage(); } inline const ::EndOfHandShowCardsMessage& GameEngineMessage::endofhandshowcardsmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.endOfHandShowCardsMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return endofhandshowcardsmessage_ != NULL ? *endofhandshowcardsmessage_ : *default_instance().endofhandshowcardsmessage_; #else @@ -22328,6 +23961,7 @@ inline const ::EndOfHandShowCardsMessage& GameEngineMessage::endofhandshowcardsm inline ::EndOfHandShowCardsMessage* GameEngineMessage::mutable_endofhandshowcardsmessage() { set_has_endofhandshowcardsmessage(); if (endofhandshowcardsmessage_ == NULL) endofhandshowcardsmessage_ = new ::EndOfHandShowCardsMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.endOfHandShowCardsMessage) return endofhandshowcardsmessage_; } inline ::EndOfHandShowCardsMessage* GameEngineMessage::release_endofhandshowcardsmessage() { @@ -22344,6 +23978,7 @@ inline void GameEngineMessage::set_allocated_endofhandshowcardsmessage(::EndOfHa } else { clear_has_endofhandshowcardsmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.endOfHandShowCardsMessage) } // optional .EndOfHandHideCardsMessage endOfHandHideCardsMessage = 12; @@ -22361,6 +23996,7 @@ inline void GameEngineMessage::clear_endofhandhidecardsmessage() { clear_has_endofhandhidecardsmessage(); } inline const ::EndOfHandHideCardsMessage& GameEngineMessage::endofhandhidecardsmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.endOfHandHideCardsMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return endofhandhidecardsmessage_ != NULL ? *endofhandhidecardsmessage_ : *default_instance().endofhandhidecardsmessage_; #else @@ -22370,6 +24006,7 @@ inline const ::EndOfHandHideCardsMessage& GameEngineMessage::endofhandhidecardsm inline ::EndOfHandHideCardsMessage* GameEngineMessage::mutable_endofhandhidecardsmessage() { set_has_endofhandhidecardsmessage(); if (endofhandhidecardsmessage_ == NULL) endofhandhidecardsmessage_ = new ::EndOfHandHideCardsMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.endOfHandHideCardsMessage) return endofhandhidecardsmessage_; } inline ::EndOfHandHideCardsMessage* GameEngineMessage::release_endofhandhidecardsmessage() { @@ -22386,6 +24023,7 @@ inline void GameEngineMessage::set_allocated_endofhandhidecardsmessage(::EndOfHa } else { clear_has_endofhandhidecardsmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.endOfHandHideCardsMessage) } // optional .ShowMyCardsRequestMessage showMyCardsRequestMessage = 13; @@ -22403,6 +24041,7 @@ inline void GameEngineMessage::clear_showmycardsrequestmessage() { clear_has_showmycardsrequestmessage(); } inline const ::ShowMyCardsRequestMessage& GameEngineMessage::showmycardsrequestmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.showMyCardsRequestMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return showmycardsrequestmessage_ != NULL ? *showmycardsrequestmessage_ : *default_instance().showmycardsrequestmessage_; #else @@ -22412,6 +24051,7 @@ inline const ::ShowMyCardsRequestMessage& GameEngineMessage::showmycardsrequestm inline ::ShowMyCardsRequestMessage* GameEngineMessage::mutable_showmycardsrequestmessage() { set_has_showmycardsrequestmessage(); if (showmycardsrequestmessage_ == NULL) showmycardsrequestmessage_ = new ::ShowMyCardsRequestMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.showMyCardsRequestMessage) return showmycardsrequestmessage_; } inline ::ShowMyCardsRequestMessage* GameEngineMessage::release_showmycardsrequestmessage() { @@ -22428,6 +24068,7 @@ inline void GameEngineMessage::set_allocated_showmycardsrequestmessage(::ShowMyC } else { clear_has_showmycardsrequestmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.showMyCardsRequestMessage) } // optional .AfterHandShowCardsMessage afterHandShowCardsMessage = 14; @@ -22445,6 +24086,7 @@ inline void GameEngineMessage::clear_afterhandshowcardsmessage() { clear_has_afterhandshowcardsmessage(); } inline const ::AfterHandShowCardsMessage& GameEngineMessage::afterhandshowcardsmessage() const { + // @@protoc_insertion_point(field_get:GameEngineMessage.afterHandShowCardsMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return afterhandshowcardsmessage_ != NULL ? *afterhandshowcardsmessage_ : *default_instance().afterhandshowcardsmessage_; #else @@ -22454,6 +24096,7 @@ inline const ::AfterHandShowCardsMessage& GameEngineMessage::afterhandshowcardsm inline ::AfterHandShowCardsMessage* GameEngineMessage::mutable_afterhandshowcardsmessage() { set_has_afterhandshowcardsmessage(); if (afterhandshowcardsmessage_ == NULL) afterhandshowcardsmessage_ = new ::AfterHandShowCardsMessage; + // @@protoc_insertion_point(field_mutable:GameEngineMessage.afterHandShowCardsMessage) return afterhandshowcardsmessage_; } inline ::AfterHandShowCardsMessage* GameEngineMessage::release_afterhandshowcardsmessage() { @@ -22470,6 +24113,7 @@ inline void GameEngineMessage::set_allocated_afterhandshowcardsmessage(::AfterHa } else { clear_has_afterhandshowcardsmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameEngineMessage.afterHandShowCardsMessage) } // ------------------------------------------------------------------- @@ -22491,12 +24135,14 @@ inline void GameMessage::clear_messagetype() { clear_has_messagetype(); } inline ::GameMessage_GameMessageType GameMessage::messagetype() const { + // @@protoc_insertion_point(field_get:GameMessage.messageType) return static_cast< ::GameMessage_GameMessageType >(messagetype_); } inline void GameMessage::set_messagetype(::GameMessage_GameMessageType value) { assert(::GameMessage_GameMessageType_IsValid(value)); set_has_messagetype(); messagetype_ = value; + // @@protoc_insertion_point(field_set:GameMessage.messageType) } // required uint32 gameId = 2; @@ -22514,11 +24160,13 @@ inline void GameMessage::clear_gameid() { clear_has_gameid(); } inline ::google::protobuf::uint32 GameMessage::gameid() const { + // @@protoc_insertion_point(field_get:GameMessage.gameId) return gameid_; } inline void GameMessage::set_gameid(::google::protobuf::uint32 value) { set_has_gameid(); gameid_ = value; + // @@protoc_insertion_point(field_set:GameMessage.gameId) } // optional .GameManagementMessage gameManagementMessage = 3; @@ -22536,6 +24184,7 @@ inline void GameMessage::clear_gamemanagementmessage() { clear_has_gamemanagementmessage(); } inline const ::GameManagementMessage& GameMessage::gamemanagementmessage() const { + // @@protoc_insertion_point(field_get:GameMessage.gameManagementMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamemanagementmessage_ != NULL ? *gamemanagementmessage_ : *default_instance().gamemanagementmessage_; #else @@ -22545,6 +24194,7 @@ inline const ::GameManagementMessage& GameMessage::gamemanagementmessage() const inline ::GameManagementMessage* GameMessage::mutable_gamemanagementmessage() { set_has_gamemanagementmessage(); if (gamemanagementmessage_ == NULL) gamemanagementmessage_ = new ::GameManagementMessage; + // @@protoc_insertion_point(field_mutable:GameMessage.gameManagementMessage) return gamemanagementmessage_; } inline ::GameManagementMessage* GameMessage::release_gamemanagementmessage() { @@ -22561,6 +24211,7 @@ inline void GameMessage::set_allocated_gamemanagementmessage(::GameManagementMes } else { clear_has_gamemanagementmessage(); } + // @@protoc_insertion_point(field_set_allocated:GameMessage.gameManagementMessage) } // optional .GameEngineMessage gameEngineMessage = 4; @@ -22578,6 +24229,7 @@ inline void GameMessage::clear_gameenginemessage() { clear_has_gameenginemessage(); } inline const ::GameEngineMessage& GameMessage::gameenginemessage() const { + // @@protoc_insertion_point(field_get:GameMessage.gameEngineMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gameenginemessage_ != NULL ? *gameenginemessage_ : *default_instance().gameenginemessage_; #else @@ -22587,6 +24239,7 @@ inline const ::GameEngineMessage& GameMessage::gameenginemessage() const { inline ::GameEngineMessage* GameMessage::mutable_gameenginemessage() { set_has_gameenginemessage(); if (gameenginemessage_ == NULL) gameenginemessage_ = new ::GameEngineMessage; + // @@protoc_insertion_point(field_mutable:GameMessage.gameEngineMessage) return gameenginemessage_; } inline ::GameEngineMessage* GameMessage::release_gameenginemessage() { @@ -22603,6 +24256,7 @@ inline void GameMessage::set_allocated_gameenginemessage(::GameEngineMessage* ga } else { clear_has_gameenginemessage(); } + // @@protoc_insertion_point(field_set_allocated:GameMessage.gameEngineMessage) } // ------------------------------------------------------------------- @@ -22624,12 +24278,14 @@ inline void PokerTHMessage::clear_messagetype() { clear_has_messagetype(); } inline ::PokerTHMessage_PokerTHMessageType PokerTHMessage::messagetype() const { + // @@protoc_insertion_point(field_get:PokerTHMessage.messageType) return static_cast< ::PokerTHMessage_PokerTHMessageType >(messagetype_); } inline void PokerTHMessage::set_messagetype(::PokerTHMessage_PokerTHMessageType value) { assert(::PokerTHMessage_PokerTHMessageType_IsValid(value)); set_has_messagetype(); messagetype_ = value; + // @@protoc_insertion_point(field_set:PokerTHMessage.messageType) } // optional .AnnounceMessage announceMessage = 2; @@ -22647,6 +24303,7 @@ inline void PokerTHMessage::clear_announcemessage() { clear_has_announcemessage(); } inline const ::AnnounceMessage& PokerTHMessage::announcemessage() const { + // @@protoc_insertion_point(field_get:PokerTHMessage.announceMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return announcemessage_ != NULL ? *announcemessage_ : *default_instance().announcemessage_; #else @@ -22656,6 +24313,7 @@ inline const ::AnnounceMessage& PokerTHMessage::announcemessage() const { inline ::AnnounceMessage* PokerTHMessage::mutable_announcemessage() { set_has_announcemessage(); if (announcemessage_ == NULL) announcemessage_ = new ::AnnounceMessage; + // @@protoc_insertion_point(field_mutable:PokerTHMessage.announceMessage) return announcemessage_; } inline ::AnnounceMessage* PokerTHMessage::release_announcemessage() { @@ -22672,6 +24330,7 @@ inline void PokerTHMessage::set_allocated_announcemessage(::AnnounceMessage* ann } else { clear_has_announcemessage(); } + // @@protoc_insertion_point(field_set_allocated:PokerTHMessage.announceMessage) } // optional .AuthMessage authMessage = 3; @@ -22689,6 +24348,7 @@ inline void PokerTHMessage::clear_authmessage() { clear_has_authmessage(); } inline const ::AuthMessage& PokerTHMessage::authmessage() const { + // @@protoc_insertion_point(field_get:PokerTHMessage.authMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return authmessage_ != NULL ? *authmessage_ : *default_instance().authmessage_; #else @@ -22698,6 +24358,7 @@ inline const ::AuthMessage& PokerTHMessage::authmessage() const { inline ::AuthMessage* PokerTHMessage::mutable_authmessage() { set_has_authmessage(); if (authmessage_ == NULL) authmessage_ = new ::AuthMessage; + // @@protoc_insertion_point(field_mutable:PokerTHMessage.authMessage) return authmessage_; } inline ::AuthMessage* PokerTHMessage::release_authmessage() { @@ -22714,6 +24375,7 @@ inline void PokerTHMessage::set_allocated_authmessage(::AuthMessage* authmessage } else { clear_has_authmessage(); } + // @@protoc_insertion_point(field_set_allocated:PokerTHMessage.authMessage) } // optional .LobbyMessage lobbyMessage = 4; @@ -22731,6 +24393,7 @@ inline void PokerTHMessage::clear_lobbymessage() { clear_has_lobbymessage(); } inline const ::LobbyMessage& PokerTHMessage::lobbymessage() const { + // @@protoc_insertion_point(field_get:PokerTHMessage.lobbyMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return lobbymessage_ != NULL ? *lobbymessage_ : *default_instance().lobbymessage_; #else @@ -22740,6 +24403,7 @@ inline const ::LobbyMessage& PokerTHMessage::lobbymessage() const { inline ::LobbyMessage* PokerTHMessage::mutable_lobbymessage() { set_has_lobbymessage(); if (lobbymessage_ == NULL) lobbymessage_ = new ::LobbyMessage; + // @@protoc_insertion_point(field_mutable:PokerTHMessage.lobbyMessage) return lobbymessage_; } inline ::LobbyMessage* PokerTHMessage::release_lobbymessage() { @@ -22756,6 +24420,7 @@ inline void PokerTHMessage::set_allocated_lobbymessage(::LobbyMessage* lobbymess } else { clear_has_lobbymessage(); } + // @@protoc_insertion_point(field_set_allocated:PokerTHMessage.lobbyMessage) } // optional .GameMessage gameMessage = 5; @@ -22773,6 +24438,7 @@ inline void PokerTHMessage::clear_gamemessage() { clear_has_gamemessage(); } inline const ::GameMessage& PokerTHMessage::gamemessage() const { + // @@protoc_insertion_point(field_get:PokerTHMessage.gameMessage) #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER return gamemessage_ != NULL ? *gamemessage_ : *default_instance().gamemessage_; #else @@ -22782,6 +24448,7 @@ inline const ::GameMessage& PokerTHMessage::gamemessage() const { inline ::GameMessage* PokerTHMessage::mutable_gamemessage() { set_has_gamemessage(); if (gamemessage_ == NULL) gamemessage_ = new ::GameMessage; + // @@protoc_insertion_point(field_mutable:PokerTHMessage.gameMessage) return gamemessage_; } inline ::GameMessage* PokerTHMessage::release_gamemessage() { @@ -22798,6 +24465,7 @@ inline void PokerTHMessage::set_allocated_gamemessage(::GameMessage* gamemessage } else { clear_has_gamemessage(); } + // @@protoc_insertion_point(field_set_allocated:PokerTHMessage.gameMessage) }