diff --git a/.gitignore b/.gitignore index 0ae1a5d..7e58b8b 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,6 @@ *.user /Pandemic/obj /Pandemic/bin +/IOModuleSimulator/bin +/IOModuleSimulator/obj +packages diff --git a/IOModule/src/IOModule.proto b/IOModule/src/IOModule.proto index f5f1571..3d5f4be 100644 --- a/IOModule/src/IOModule.proto +++ b/IOModule/src/IOModule.proto @@ -2,7 +2,6 @@ // protoc --nanopb_out=. IOModule.proto syntax = "proto3"; package IOModule; -import "nanopb.proto"; // This message encapsulates all possible messages going from the Raspberry Pi to the IO Module. // The rule here is that the member name is the same as the type name minus the "Msg" postfix. diff --git a/IOModuleSimulator/App.config b/IOModuleSimulator/App.config new file mode 100644 index 0000000..56efbc7 --- /dev/null +++ b/IOModuleSimulator/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/IOModuleSimulator/CompileProtobuf.bat b/IOModuleSimulator/CompileProtobuf.bat new file mode 100644 index 0000000..9bd6e9e --- /dev/null +++ b/IOModuleSimulator/CompileProtobuf.bat @@ -0,0 +1,3 @@ +@ECHO OFF +ECHO Compiling IOModule.proto... +..\packages\Google.Protobuf.Tools.3.21.12\tools\windows_x64\protoc.exe --csharp_out=. --proto_path=..\IOModule\src IOModule.proto diff --git a/IOModuleSimulator/FormMain.Designer.cs b/IOModuleSimulator/FormMain.Designer.cs new file mode 100644 index 0000000..a41327b --- /dev/null +++ b/IOModuleSimulator/FormMain.Designer.cs @@ -0,0 +1,159 @@ +namespace IOModuleSimulator +{ + partial class FormMain + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.buttonsgroup = new System.Windows.Forms.GroupBox(); + this.sensorsgroup = new System.Windows.Forms.GroupBox(); + this.connectiongroup = new System.Windows.Forms.GroupBox(); + this.label1 = new System.Windows.Forms.Label(); + this.connectaddress = new System.Windows.Forms.TextBox(); + this.label2 = new System.Windows.Forms.Label(); + this.connectport = new System.Windows.Forms.TextBox(); + this.connectbutton = new System.Windows.Forms.Button(); + this.connectiongroup.SuspendLayout(); + this.SuspendLayout(); + // + // buttonsgroup + // + this.buttonsgroup.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.buttonsgroup.Enabled = false; + this.buttonsgroup.Location = new System.Drawing.Point(12, 115); + this.buttonsgroup.Name = "buttonsgroup"; + this.buttonsgroup.Size = new System.Drawing.Size(581, 149); + this.buttonsgroup.TabIndex = 0; + this.buttonsgroup.TabStop = false; + this.buttonsgroup.Text = " Buttons "; + // + // sensorsgroup + // + this.sensorsgroup.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.sensorsgroup.Enabled = false; + this.sensorsgroup.Location = new System.Drawing.Point(12, 293); + this.sensorsgroup.Name = "sensorsgroup"; + this.sensorsgroup.Size = new System.Drawing.Size(581, 149); + this.sensorsgroup.TabIndex = 1; + this.sensorsgroup.TabStop = false; + this.sensorsgroup.Text = " Sensors "; + // + // connectiongroup + // + this.connectiongroup.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.connectiongroup.Controls.Add(this.connectbutton); + this.connectiongroup.Controls.Add(this.connectport); + this.connectiongroup.Controls.Add(this.label2); + this.connectiongroup.Controls.Add(this.connectaddress); + this.connectiongroup.Controls.Add(this.label1); + this.connectiongroup.Location = new System.Drawing.Point(12, 12); + this.connectiongroup.Name = "connectiongroup"; + this.connectiongroup.Size = new System.Drawing.Size(581, 85); + this.connectiongroup.TabIndex = 1; + this.connectiongroup.TabStop = false; + this.connectiongroup.Text = " Connection "; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(33, 37); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(73, 15); + this.label1.TabIndex = 0; + this.label1.Text = "TCP address:"; + // + // connectaddress + // + this.connectaddress.Location = new System.Drawing.Point(112, 34); + this.connectaddress.Name = "connectaddress"; + this.connectaddress.Size = new System.Drawing.Size(174, 23); + this.connectaddress.TabIndex = 1; + this.connectaddress.Text = "localhost"; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(301, 37); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(32, 15); + this.label2.TabIndex = 2; + this.label2.Text = "port:"; + // + // connectport + // + this.connectport.Location = new System.Drawing.Point(339, 34); + this.connectport.Name = "connectport"; + this.connectport.Size = new System.Drawing.Size(84, 23); + this.connectport.TabIndex = 3; + this.connectport.Text = "2023"; + // + // connectbutton + // + this.connectbutton.Location = new System.Drawing.Point(457, 31); + this.connectbutton.Name = "connectbutton"; + this.connectbutton.Size = new System.Drawing.Size(92, 28); + this.connectbutton.TabIndex = 4; + this.connectbutton.Text = "Connect"; + this.connectbutton.UseVisualStyleBackColor = true; + this.connectbutton.Click += new System.EventHandler(this.connectbutton_Click); + // + // FormMain + // + this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(605, 473); + this.Controls.Add(this.connectiongroup); + this.Controls.Add(this.sensorsgroup); + this.Controls.Add(this.buttonsgroup); + this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; + this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3); + this.MaximizeBox = false; + this.Name = "FormMain"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Pandemic IOModule Charlatan"; + this.connectiongroup.ResumeLayout(false); + this.connectiongroup.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.GroupBox buttonsgroup; + private System.Windows.Forms.GroupBox sensorsgroup; + private System.Windows.Forms.GroupBox connectiongroup; + private System.Windows.Forms.TextBox connectport; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.TextBox connectaddress; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Button connectbutton; + } +} + diff --git a/IOModuleSimulator/FormMain.cs b/IOModuleSimulator/FormMain.cs new file mode 100644 index 0000000..42766a6 --- /dev/null +++ b/IOModuleSimulator/FormMain.cs @@ -0,0 +1,28 @@ +using IOModule; +using System; +using System.Linq; +using System.Net; +using System.Net.Sockets; +using System.Windows.Forms; + +namespace IOModuleSimulator +{ + public partial class FormMain : Form + { + public FormMain() + { + InitializeComponent(); + } + + private void connectbutton_Click(object sender, EventArgs e) + { + IPHostEntry hostEntry = Dns.GetHostEntry(connectaddress.Text); + if (hostEntry.AddressList.Length > 0) + { + var ip = hostEntry.AddressList.Where(a => a.AddressFamily == AddressFamily.InterNetwork).FirstOrDefault(); + Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); + s.Connect(ip, int.Parse(connectport.Text)); + } + } + } +} diff --git a/IOModuleSimulator/FormMain.resx b/IOModuleSimulator/FormMain.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/IOModuleSimulator/FormMain.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/IOModuleSimulator/IOModule.cs b/IOModuleSimulator/IOModule.cs new file mode 100644 index 0000000..2f97309 --- /dev/null +++ b/IOModuleSimulator/IOModule.cs @@ -0,0 +1,5397 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: IOModule.proto +// +#pragma warning disable 1591, 0612, 3021, 8981 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbr = global::Google.Protobuf.Reflection; +using scg = global::System.Collections.Generic; +namespace IOModule { + + /// Holder for reflection information generated from IOModule.proto + public static partial class IOModuleReflection { + + #region Descriptor + /// File descriptor for IOModule.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static IOModuleReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Cg5JT01vZHVsZS5wcm90bxIISU9Nb2R1bGUiuAMKCVBpTWVzc2FnZRItCgpO", + "b3JtYWxNb2RlGGQgASgLMhcuSU9Nb2R1bGUuTm9ybWFsTW9kZU1zZ0gAEjMK", + "DUNhbGlicmF0ZU1vZGUYZSABKAsyGi5JT01vZHVsZS5DYWxpYnJhdGVNb2Rl", + "TXNnSAASMwoNSW5kaWNhdGVFcnJvchhmIAEoCzIaLklPTW9kdWxlLkluZGlj", + "YXRlRXJyb3JNc2dIABIpCghTZXR0aW5ncxhnIAEoCzIVLklPTW9kdWxlLlNl", + "dHRpbmdzTXNnSAASLQoKUm91bmRSZXNldBhoIAEoCzIXLklPTW9kdWxlLlJv", + "dW5kUmVzZXRNc2dIABI3Cg9TZXRCdXR0b25MaWdodHMYaSABKAsyHC5JT01v", + "ZHVsZS5TZXRCdXR0b25MaWdodHNNc2dIABI3Cg9TZXRCdXR0b25SZXBlYXQY", + "aiABKAsyHC5JT01vZHVsZS5TZXRCdXR0b25SZXBlYXRNc2dIABI7ChFSZXF1", + "ZXN0R2F0ZVN0YXRlcxhrIAEoCzIeLklPTW9kdWxlLlJlcXVlc3RHYXRlU3Rh", + "dGVzTXNnSABCCQoHQ29udGVudCKYBQoJSU9NZXNzYWdlEi0KClN0YXJ0U2xp", + "ZGUYZCABKAsyFy5JT01vZHVsZS5TdGFydFNsaWRlTXNnSAASKwoJR2F0ZVNj", + "b3JlGGUgASgLMhYuSU9Nb2R1bGUuR2F0ZVNjb3JlTXNnSAASLQoKUHVja0lu", + "R2F0ZRhmIAEoCzIXLklPTW9kdWxlLlB1Y2tJbkdhdGVNc2dIABIvCgtTZW5z", + "b3JTdGF0ZRhnIAEoCzIYLklPTW9kdWxlLlNlbnNvclN0YXRlTXNnSAASOwoR", + "TGVmdEJ1dHRvblByZXNzZWQYaCABKAsyHi5JT01vZHVsZS5MZWZ0QnV0dG9u", + "UHJlc3NlZE1zZ0gAEj0KElJpZ2h0QnV0dG9uUHJlc3NlZBhpIAEoCzIfLklP", + "TW9kdWxlLlJpZ2h0QnV0dG9uUHJlc3NlZE1zZ0gAEj8KE0FjY2VwdEJ1dHRv", + "blByZXNzZWQYaiABKAsyIC5JT01vZHVsZS5BY2NlcHRCdXR0b25QcmVzc2Vk", + "TXNnSAASPwoTQ2FuY2VsQnV0dG9uUHJlc3NlZBhrIAEoCzIgLklPTW9kdWxl", + "LkNhbmNlbEJ1dHRvblByZXNzZWRNc2dIABItCgpSZW1vdmVQdWNrGGwgASgL", + "MhcuSU9Nb2R1bGUuUmVtb3ZlUHVja01zZ0gAEjMKDVNlbnNvckJsb2NrZWQY", + "bSABKAsyGi5JT01vZHVsZS5TZW5zb3JCbG9ja2VkTXNnSAASMwoNU2Vuc29y", + "Q2xlYXJlZBhuIAEoCzIaLklPTW9kdWxlLlNlbnNvckNsZWFyZWRNc2dIABIt", + "CgpHYXRlU3RhdGVzGG8gASgLMhcuSU9Nb2R1bGUuR2F0ZVN0YXRlc01zZ0gA", + "QgkKB0NvbnRlbnQiDwoNUm91bmRSZXNldE1zZyJpChJTZXRCdXR0b25MaWdo", + "dHNNc2cSEgoKTGVmdEJ1dHRvbhgBIAEoCBITCgtSaWdodEJ1dHRvbhgCIAEo", + "CBIUCgxBY2NlcHRCdXR0b24YAyABKAgSFAoMQ2FuY2VsQnV0dG9uGAQgASgI", + "IqQBCgtTZXR0aW5nc01zZxIWCg5TbGlkZVRpbWVvdXRNcxgBIAEoDRIQCghI", + "YXJkTW9kZRgCIAEoCBIbChNCdXR0b25SZXBlYXRUaW1lb3V0GAMgASgNEhwK", + "FEJ1dHRvblJlcGVhdEludGVydmFsGAQgASgNEhcKD1B1Y2tMb3N0VGltZW91", + "dBgFIAEoDRIXCg9EZWJvdW5jZVRpbWVvdXQYBiABKA0iDwoNTm9ybWFsTW9k", + "ZU1zZyISChBDYWxpYnJhdGVNb2RlTXNnIhIKEEluZGljYXRlRXJyb3JNc2ci", + "HgoNU3RhcnRTbGlkZU1zZxINCgVTcGVlZBgBIAEoDSIPCg1SZW1vdmVQdWNr", + "TXNnIhIKEFNlbnNvckJsb2NrZWRNc2ciEgoQU2Vuc29yQ2xlYXJlZE1zZyIW", + "ChRMZWZ0QnV0dG9uUHJlc3NlZE1zZyIXChVSaWdodEJ1dHRvblByZXNzZWRN", + "c2ciGAoWQWNjZXB0QnV0dG9uUHJlc3NlZE1zZyIYChZDYW5jZWxCdXR0b25Q", + "cmVzc2VkTXNnIhwKDEdhdGVTY29yZU1zZxIMCgRHYXRlGAEgASgNIh0KDVB1", + "Y2tJbkdhdGVNc2cSDAoER2F0ZRgBIAEoDSIWChRSZXF1ZXN0R2F0ZVN0YXRl", + "c01zZyJnCg1HYXRlU3RhdGVzTXNnEhQKDEdhdGUxQmxvY2tlZBgBIAEoCBIU", + "CgxHYXRlMkJsb2NrZWQYAiABKAgSFAoMR2F0ZTNCbG9ja2VkGAMgASgIEhQK", + "DEdhdGU0QmxvY2tlZBgEIAEoCCJACg5TZW5zb3JTdGF0ZU1zZxIgCgZTZW5z", + "b3IYASABKA4yEC5JT01vZHVsZS5TZW5zb3ISDAoESGlnaBgCIAEoCCIkChJT", + "ZXRCdXR0b25SZXBlYXRNc2cSDgoGRW5hYmxlGAEgASgIKu8BCgZTZW5zb3IS", + "DgoKR2F0ZTFGcm9udBAAEg4KCkdhdGUyRnJvbnQQARIOCgpHYXRlM0Zyb250", + "EAISDgoKR2F0ZTRGcm9udBADEg0KCUdhdGUxQmFjaxAEEg0KCUdhdGUyQmFj", + "axAFEg0KCUdhdGUzQmFjaxAGEg0KCUdhdGU0QmFjaxAHEg4KCkxlZnRCdXR0", + "b24QCBIPCgtSaWdodEJ1dHRvbhAJEhAKDEFjY2VwdEJ1dHRvbhAKEhAKDENh", + "bmNlbEJ1dHRvbhALEhEKDUJyaWRnZTFTZW5zb3IQDBIRCg1CcmlkZ2UyU2Vu", + "c29yEA1iBnByb3RvMw==")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::IOModule.Sensor), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.PiMessage), global::IOModule.PiMessage.Parser, new[]{ "NormalMode", "CalibrateMode", "IndicateError", "Settings", "RoundReset", "SetButtonLights", "SetButtonRepeat", "RequestGateStates" }, new[]{ "Content" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.IOMessage), global::IOModule.IOMessage.Parser, new[]{ "StartSlide", "GateScore", "PuckInGate", "SensorState", "LeftButtonPressed", "RightButtonPressed", "AcceptButtonPressed", "CancelButtonPressed", "RemovePuck", "SensorBlocked", "SensorCleared", "GateStates" }, new[]{ "Content" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.RoundResetMsg), global::IOModule.RoundResetMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.SetButtonLightsMsg), global::IOModule.SetButtonLightsMsg.Parser, new[]{ "LeftButton", "RightButton", "AcceptButton", "CancelButton" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.SettingsMsg), global::IOModule.SettingsMsg.Parser, new[]{ "SlideTimeoutMs", "HardMode", "ButtonRepeatTimeout", "ButtonRepeatInterval", "PuckLostTimeout", "DebounceTimeout" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.NormalModeMsg), global::IOModule.NormalModeMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.CalibrateModeMsg), global::IOModule.CalibrateModeMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.IndicateErrorMsg), global::IOModule.IndicateErrorMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.StartSlideMsg), global::IOModule.StartSlideMsg.Parser, new[]{ "Speed" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.RemovePuckMsg), global::IOModule.RemovePuckMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.SensorBlockedMsg), global::IOModule.SensorBlockedMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.SensorClearedMsg), global::IOModule.SensorClearedMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.LeftButtonPressedMsg), global::IOModule.LeftButtonPressedMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.RightButtonPressedMsg), global::IOModule.RightButtonPressedMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.AcceptButtonPressedMsg), global::IOModule.AcceptButtonPressedMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.CancelButtonPressedMsg), global::IOModule.CancelButtonPressedMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.GateScoreMsg), global::IOModule.GateScoreMsg.Parser, new[]{ "Gate" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.PuckInGateMsg), global::IOModule.PuckInGateMsg.Parser, new[]{ "Gate" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.RequestGateStatesMsg), global::IOModule.RequestGateStatesMsg.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.GateStatesMsg), global::IOModule.GateStatesMsg.Parser, new[]{ "Gate1Blocked", "Gate2Blocked", "Gate3Blocked", "Gate4Blocked" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.SensorStateMsg), global::IOModule.SensorStateMsg.Parser, new[]{ "Sensor", "High" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::IOModule.SetButtonRepeatMsg), global::IOModule.SetButtonRepeatMsg.Parser, new[]{ "Enable" }, null, null, null, null) + })); + } + #endregion + + } + #region Enums + public enum Sensor { + [pbr::OriginalName("Gate1Front")] Gate1Front = 0, + [pbr::OriginalName("Gate2Front")] Gate2Front = 1, + [pbr::OriginalName("Gate3Front")] Gate3Front = 2, + [pbr::OriginalName("Gate4Front")] Gate4Front = 3, + [pbr::OriginalName("Gate1Back")] Gate1Back = 4, + [pbr::OriginalName("Gate2Back")] Gate2Back = 5, + [pbr::OriginalName("Gate3Back")] Gate3Back = 6, + [pbr::OriginalName("Gate4Back")] Gate4Back = 7, + [pbr::OriginalName("LeftButton")] LeftButton = 8, + [pbr::OriginalName("RightButton")] RightButton = 9, + [pbr::OriginalName("AcceptButton")] AcceptButton = 10, + [pbr::OriginalName("CancelButton")] CancelButton = 11, + [pbr::OriginalName("Bridge1Sensor")] Bridge1Sensor = 12, + [pbr::OriginalName("Bridge2Sensor")] Bridge2Sensor = 13, + } + + #endregion + + #region Messages + /// + /// This message encapsulates all possible messages going from the Raspberry Pi to the IO Module. + /// The rule here is that the member name is the same as the type name minus the "Msg" postfix. + /// This way the code can construct a message using reflection and a reference to one of the above. + /// + public sealed partial class PiMessage : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PiMessage()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PiMessage() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PiMessage(PiMessage other) : this() { + switch (other.ContentCase) { + case ContentOneofCase.NormalMode: + NormalMode = other.NormalMode.Clone(); + break; + case ContentOneofCase.CalibrateMode: + CalibrateMode = other.CalibrateMode.Clone(); + break; + case ContentOneofCase.IndicateError: + IndicateError = other.IndicateError.Clone(); + break; + case ContentOneofCase.Settings: + Settings = other.Settings.Clone(); + break; + case ContentOneofCase.RoundReset: + RoundReset = other.RoundReset.Clone(); + break; + case ContentOneofCase.SetButtonLights: + SetButtonLights = other.SetButtonLights.Clone(); + break; + case ContentOneofCase.SetButtonRepeat: + SetButtonRepeat = other.SetButtonRepeat.Clone(); + break; + case ContentOneofCase.RequestGateStates: + RequestGateStates = other.RequestGateStates.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PiMessage Clone() { + return new PiMessage(this); + } + + /// Field number for the "NormalMode" field. + public const int NormalModeFieldNumber = 100; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.NormalModeMsg NormalMode { + get { return contentCase_ == ContentOneofCase.NormalMode ? (global::IOModule.NormalModeMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.NormalMode; + } + } + + /// Field number for the "CalibrateMode" field. + public const int CalibrateModeFieldNumber = 101; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.CalibrateModeMsg CalibrateMode { + get { return contentCase_ == ContentOneofCase.CalibrateMode ? (global::IOModule.CalibrateModeMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.CalibrateMode; + } + } + + /// Field number for the "IndicateError" field. + public const int IndicateErrorFieldNumber = 102; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.IndicateErrorMsg IndicateError { + get { return contentCase_ == ContentOneofCase.IndicateError ? (global::IOModule.IndicateErrorMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.IndicateError; + } + } + + /// Field number for the "Settings" field. + public const int SettingsFieldNumber = 103; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.SettingsMsg Settings { + get { return contentCase_ == ContentOneofCase.Settings ? (global::IOModule.SettingsMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.Settings; + } + } + + /// Field number for the "RoundReset" field. + public const int RoundResetFieldNumber = 104; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.RoundResetMsg RoundReset { + get { return contentCase_ == ContentOneofCase.RoundReset ? (global::IOModule.RoundResetMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.RoundReset; + } + } + + /// Field number for the "SetButtonLights" field. + public const int SetButtonLightsFieldNumber = 105; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.SetButtonLightsMsg SetButtonLights { + get { return contentCase_ == ContentOneofCase.SetButtonLights ? (global::IOModule.SetButtonLightsMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.SetButtonLights; + } + } + + /// Field number for the "SetButtonRepeat" field. + public const int SetButtonRepeatFieldNumber = 106; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.SetButtonRepeatMsg SetButtonRepeat { + get { return contentCase_ == ContentOneofCase.SetButtonRepeat ? (global::IOModule.SetButtonRepeatMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.SetButtonRepeat; + } + } + + /// Field number for the "RequestGateStates" field. + public const int RequestGateStatesFieldNumber = 107; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.RequestGateStatesMsg RequestGateStates { + get { return contentCase_ == ContentOneofCase.RequestGateStates ? (global::IOModule.RequestGateStatesMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.RequestGateStates; + } + } + + private object content_; + /// Enum of possible cases for the "Content" oneof. + public enum ContentOneofCase { + None = 0, + NormalMode = 100, + CalibrateMode = 101, + IndicateError = 102, + Settings = 103, + RoundReset = 104, + SetButtonLights = 105, + SetButtonRepeat = 106, + RequestGateStates = 107, + } + private ContentOneofCase contentCase_ = ContentOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ContentOneofCase ContentCase { + get { return contentCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearContent() { + contentCase_ = ContentOneofCase.None; + content_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as PiMessage); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(PiMessage other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(NormalMode, other.NormalMode)) return false; + if (!object.Equals(CalibrateMode, other.CalibrateMode)) return false; + if (!object.Equals(IndicateError, other.IndicateError)) return false; + if (!object.Equals(Settings, other.Settings)) return false; + if (!object.Equals(RoundReset, other.RoundReset)) return false; + if (!object.Equals(SetButtonLights, other.SetButtonLights)) return false; + if (!object.Equals(SetButtonRepeat, other.SetButtonRepeat)) return false; + if (!object.Equals(RequestGateStates, other.RequestGateStates)) return false; + if (ContentCase != other.ContentCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (contentCase_ == ContentOneofCase.NormalMode) hash ^= NormalMode.GetHashCode(); + if (contentCase_ == ContentOneofCase.CalibrateMode) hash ^= CalibrateMode.GetHashCode(); + if (contentCase_ == ContentOneofCase.IndicateError) hash ^= IndicateError.GetHashCode(); + if (contentCase_ == ContentOneofCase.Settings) hash ^= Settings.GetHashCode(); + if (contentCase_ == ContentOneofCase.RoundReset) hash ^= RoundReset.GetHashCode(); + if (contentCase_ == ContentOneofCase.SetButtonLights) hash ^= SetButtonLights.GetHashCode(); + if (contentCase_ == ContentOneofCase.SetButtonRepeat) hash ^= SetButtonRepeat.GetHashCode(); + if (contentCase_ == ContentOneofCase.RequestGateStates) hash ^= RequestGateStates.GetHashCode(); + hash ^= (int) contentCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (contentCase_ == ContentOneofCase.NormalMode) { + output.WriteRawTag(162, 6); + output.WriteMessage(NormalMode); + } + if (contentCase_ == ContentOneofCase.CalibrateMode) { + output.WriteRawTag(170, 6); + output.WriteMessage(CalibrateMode); + } + if (contentCase_ == ContentOneofCase.IndicateError) { + output.WriteRawTag(178, 6); + output.WriteMessage(IndicateError); + } + if (contentCase_ == ContentOneofCase.Settings) { + output.WriteRawTag(186, 6); + output.WriteMessage(Settings); + } + if (contentCase_ == ContentOneofCase.RoundReset) { + output.WriteRawTag(194, 6); + output.WriteMessage(RoundReset); + } + if (contentCase_ == ContentOneofCase.SetButtonLights) { + output.WriteRawTag(202, 6); + output.WriteMessage(SetButtonLights); + } + if (contentCase_ == ContentOneofCase.SetButtonRepeat) { + output.WriteRawTag(210, 6); + output.WriteMessage(SetButtonRepeat); + } + if (contentCase_ == ContentOneofCase.RequestGateStates) { + output.WriteRawTag(218, 6); + output.WriteMessage(RequestGateStates); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (contentCase_ == ContentOneofCase.NormalMode) { + output.WriteRawTag(162, 6); + output.WriteMessage(NormalMode); + } + if (contentCase_ == ContentOneofCase.CalibrateMode) { + output.WriteRawTag(170, 6); + output.WriteMessage(CalibrateMode); + } + if (contentCase_ == ContentOneofCase.IndicateError) { + output.WriteRawTag(178, 6); + output.WriteMessage(IndicateError); + } + if (contentCase_ == ContentOneofCase.Settings) { + output.WriteRawTag(186, 6); + output.WriteMessage(Settings); + } + if (contentCase_ == ContentOneofCase.RoundReset) { + output.WriteRawTag(194, 6); + output.WriteMessage(RoundReset); + } + if (contentCase_ == ContentOneofCase.SetButtonLights) { + output.WriteRawTag(202, 6); + output.WriteMessage(SetButtonLights); + } + if (contentCase_ == ContentOneofCase.SetButtonRepeat) { + output.WriteRawTag(210, 6); + output.WriteMessage(SetButtonRepeat); + } + if (contentCase_ == ContentOneofCase.RequestGateStates) { + output.WriteRawTag(218, 6); + output.WriteMessage(RequestGateStates); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (contentCase_ == ContentOneofCase.NormalMode) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(NormalMode); + } + if (contentCase_ == ContentOneofCase.CalibrateMode) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(CalibrateMode); + } + if (contentCase_ == ContentOneofCase.IndicateError) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(IndicateError); + } + if (contentCase_ == ContentOneofCase.Settings) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(Settings); + } + if (contentCase_ == ContentOneofCase.RoundReset) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(RoundReset); + } + if (contentCase_ == ContentOneofCase.SetButtonLights) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SetButtonLights); + } + if (contentCase_ == ContentOneofCase.SetButtonRepeat) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SetButtonRepeat); + } + if (contentCase_ == ContentOneofCase.RequestGateStates) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(RequestGateStates); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(PiMessage other) { + if (other == null) { + return; + } + switch (other.ContentCase) { + case ContentOneofCase.NormalMode: + if (NormalMode == null) { + NormalMode = new global::IOModule.NormalModeMsg(); + } + NormalMode.MergeFrom(other.NormalMode); + break; + case ContentOneofCase.CalibrateMode: + if (CalibrateMode == null) { + CalibrateMode = new global::IOModule.CalibrateModeMsg(); + } + CalibrateMode.MergeFrom(other.CalibrateMode); + break; + case ContentOneofCase.IndicateError: + if (IndicateError == null) { + IndicateError = new global::IOModule.IndicateErrorMsg(); + } + IndicateError.MergeFrom(other.IndicateError); + break; + case ContentOneofCase.Settings: + if (Settings == null) { + Settings = new global::IOModule.SettingsMsg(); + } + Settings.MergeFrom(other.Settings); + break; + case ContentOneofCase.RoundReset: + if (RoundReset == null) { + RoundReset = new global::IOModule.RoundResetMsg(); + } + RoundReset.MergeFrom(other.RoundReset); + break; + case ContentOneofCase.SetButtonLights: + if (SetButtonLights == null) { + SetButtonLights = new global::IOModule.SetButtonLightsMsg(); + } + SetButtonLights.MergeFrom(other.SetButtonLights); + break; + case ContentOneofCase.SetButtonRepeat: + if (SetButtonRepeat == null) { + SetButtonRepeat = new global::IOModule.SetButtonRepeatMsg(); + } + SetButtonRepeat.MergeFrom(other.SetButtonRepeat); + break; + case ContentOneofCase.RequestGateStates: + if (RequestGateStates == null) { + RequestGateStates = new global::IOModule.RequestGateStatesMsg(); + } + RequestGateStates.MergeFrom(other.RequestGateStates); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 802: { + global::IOModule.NormalModeMsg subBuilder = new global::IOModule.NormalModeMsg(); + if (contentCase_ == ContentOneofCase.NormalMode) { + subBuilder.MergeFrom(NormalMode); + } + input.ReadMessage(subBuilder); + NormalMode = subBuilder; + break; + } + case 810: { + global::IOModule.CalibrateModeMsg subBuilder = new global::IOModule.CalibrateModeMsg(); + if (contentCase_ == ContentOneofCase.CalibrateMode) { + subBuilder.MergeFrom(CalibrateMode); + } + input.ReadMessage(subBuilder); + CalibrateMode = subBuilder; + break; + } + case 818: { + global::IOModule.IndicateErrorMsg subBuilder = new global::IOModule.IndicateErrorMsg(); + if (contentCase_ == ContentOneofCase.IndicateError) { + subBuilder.MergeFrom(IndicateError); + } + input.ReadMessage(subBuilder); + IndicateError = subBuilder; + break; + } + case 826: { + global::IOModule.SettingsMsg subBuilder = new global::IOModule.SettingsMsg(); + if (contentCase_ == ContentOneofCase.Settings) { + subBuilder.MergeFrom(Settings); + } + input.ReadMessage(subBuilder); + Settings = subBuilder; + break; + } + case 834: { + global::IOModule.RoundResetMsg subBuilder = new global::IOModule.RoundResetMsg(); + if (contentCase_ == ContentOneofCase.RoundReset) { + subBuilder.MergeFrom(RoundReset); + } + input.ReadMessage(subBuilder); + RoundReset = subBuilder; + break; + } + case 842: { + global::IOModule.SetButtonLightsMsg subBuilder = new global::IOModule.SetButtonLightsMsg(); + if (contentCase_ == ContentOneofCase.SetButtonLights) { + subBuilder.MergeFrom(SetButtonLights); + } + input.ReadMessage(subBuilder); + SetButtonLights = subBuilder; + break; + } + case 850: { + global::IOModule.SetButtonRepeatMsg subBuilder = new global::IOModule.SetButtonRepeatMsg(); + if (contentCase_ == ContentOneofCase.SetButtonRepeat) { + subBuilder.MergeFrom(SetButtonRepeat); + } + input.ReadMessage(subBuilder); + SetButtonRepeat = subBuilder; + break; + } + case 858: { + global::IOModule.RequestGateStatesMsg subBuilder = new global::IOModule.RequestGateStatesMsg(); + if (contentCase_ == ContentOneofCase.RequestGateStates) { + subBuilder.MergeFrom(RequestGateStates); + } + input.ReadMessage(subBuilder); + RequestGateStates = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 802: { + global::IOModule.NormalModeMsg subBuilder = new global::IOModule.NormalModeMsg(); + if (contentCase_ == ContentOneofCase.NormalMode) { + subBuilder.MergeFrom(NormalMode); + } + input.ReadMessage(subBuilder); + NormalMode = subBuilder; + break; + } + case 810: { + global::IOModule.CalibrateModeMsg subBuilder = new global::IOModule.CalibrateModeMsg(); + if (contentCase_ == ContentOneofCase.CalibrateMode) { + subBuilder.MergeFrom(CalibrateMode); + } + input.ReadMessage(subBuilder); + CalibrateMode = subBuilder; + break; + } + case 818: { + global::IOModule.IndicateErrorMsg subBuilder = new global::IOModule.IndicateErrorMsg(); + if (contentCase_ == ContentOneofCase.IndicateError) { + subBuilder.MergeFrom(IndicateError); + } + input.ReadMessage(subBuilder); + IndicateError = subBuilder; + break; + } + case 826: { + global::IOModule.SettingsMsg subBuilder = new global::IOModule.SettingsMsg(); + if (contentCase_ == ContentOneofCase.Settings) { + subBuilder.MergeFrom(Settings); + } + input.ReadMessage(subBuilder); + Settings = subBuilder; + break; + } + case 834: { + global::IOModule.RoundResetMsg subBuilder = new global::IOModule.RoundResetMsg(); + if (contentCase_ == ContentOneofCase.RoundReset) { + subBuilder.MergeFrom(RoundReset); + } + input.ReadMessage(subBuilder); + RoundReset = subBuilder; + break; + } + case 842: { + global::IOModule.SetButtonLightsMsg subBuilder = new global::IOModule.SetButtonLightsMsg(); + if (contentCase_ == ContentOneofCase.SetButtonLights) { + subBuilder.MergeFrom(SetButtonLights); + } + input.ReadMessage(subBuilder); + SetButtonLights = subBuilder; + break; + } + case 850: { + global::IOModule.SetButtonRepeatMsg subBuilder = new global::IOModule.SetButtonRepeatMsg(); + if (contentCase_ == ContentOneofCase.SetButtonRepeat) { + subBuilder.MergeFrom(SetButtonRepeat); + } + input.ReadMessage(subBuilder); + SetButtonRepeat = subBuilder; + break; + } + case 858: { + global::IOModule.RequestGateStatesMsg subBuilder = new global::IOModule.RequestGateStatesMsg(); + if (contentCase_ == ContentOneofCase.RequestGateStates) { + subBuilder.MergeFrom(RequestGateStates); + } + input.ReadMessage(subBuilder); + RequestGateStates = subBuilder; + break; + } + } + } + } + #endif + + } + + /// + /// This message encapsulates all possible messages going from the IO Module to the Raspberry Pi. + /// The rule here is that the member name is the same as the type name minus the "Msg" postfix. + /// This way the code can construct a message using reflection and a reference to one of the above. + /// + public sealed partial class IOMessage : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new IOMessage()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public IOMessage() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public IOMessage(IOMessage other) : this() { + switch (other.ContentCase) { + case ContentOneofCase.StartSlide: + StartSlide = other.StartSlide.Clone(); + break; + case ContentOneofCase.GateScore: + GateScore = other.GateScore.Clone(); + break; + case ContentOneofCase.PuckInGate: + PuckInGate = other.PuckInGate.Clone(); + break; + case ContentOneofCase.SensorState: + SensorState = other.SensorState.Clone(); + break; + case ContentOneofCase.LeftButtonPressed: + LeftButtonPressed = other.LeftButtonPressed.Clone(); + break; + case ContentOneofCase.RightButtonPressed: + RightButtonPressed = other.RightButtonPressed.Clone(); + break; + case ContentOneofCase.AcceptButtonPressed: + AcceptButtonPressed = other.AcceptButtonPressed.Clone(); + break; + case ContentOneofCase.CancelButtonPressed: + CancelButtonPressed = other.CancelButtonPressed.Clone(); + break; + case ContentOneofCase.RemovePuck: + RemovePuck = other.RemovePuck.Clone(); + break; + case ContentOneofCase.SensorBlocked: + SensorBlocked = other.SensorBlocked.Clone(); + break; + case ContentOneofCase.SensorCleared: + SensorCleared = other.SensorCleared.Clone(); + break; + case ContentOneofCase.GateStates: + GateStates = other.GateStates.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public IOMessage Clone() { + return new IOMessage(this); + } + + /// Field number for the "StartSlide" field. + public const int StartSlideFieldNumber = 100; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.StartSlideMsg StartSlide { + get { return contentCase_ == ContentOneofCase.StartSlide ? (global::IOModule.StartSlideMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.StartSlide; + } + } + + /// Field number for the "GateScore" field. + public const int GateScoreFieldNumber = 101; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.GateScoreMsg GateScore { + get { return contentCase_ == ContentOneofCase.GateScore ? (global::IOModule.GateScoreMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.GateScore; + } + } + + /// Field number for the "PuckInGate" field. + public const int PuckInGateFieldNumber = 102; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.PuckInGateMsg PuckInGate { + get { return contentCase_ == ContentOneofCase.PuckInGate ? (global::IOModule.PuckInGateMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.PuckInGate; + } + } + + /// Field number for the "SensorState" field. + public const int SensorStateFieldNumber = 103; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.SensorStateMsg SensorState { + get { return contentCase_ == ContentOneofCase.SensorState ? (global::IOModule.SensorStateMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.SensorState; + } + } + + /// Field number for the "LeftButtonPressed" field. + public const int LeftButtonPressedFieldNumber = 104; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.LeftButtonPressedMsg LeftButtonPressed { + get { return contentCase_ == ContentOneofCase.LeftButtonPressed ? (global::IOModule.LeftButtonPressedMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.LeftButtonPressed; + } + } + + /// Field number for the "RightButtonPressed" field. + public const int RightButtonPressedFieldNumber = 105; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.RightButtonPressedMsg RightButtonPressed { + get { return contentCase_ == ContentOneofCase.RightButtonPressed ? (global::IOModule.RightButtonPressedMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.RightButtonPressed; + } + } + + /// Field number for the "AcceptButtonPressed" field. + public const int AcceptButtonPressedFieldNumber = 106; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.AcceptButtonPressedMsg AcceptButtonPressed { + get { return contentCase_ == ContentOneofCase.AcceptButtonPressed ? (global::IOModule.AcceptButtonPressedMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.AcceptButtonPressed; + } + } + + /// Field number for the "CancelButtonPressed" field. + public const int CancelButtonPressedFieldNumber = 107; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.CancelButtonPressedMsg CancelButtonPressed { + get { return contentCase_ == ContentOneofCase.CancelButtonPressed ? (global::IOModule.CancelButtonPressedMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.CancelButtonPressed; + } + } + + /// Field number for the "RemovePuck" field. + public const int RemovePuckFieldNumber = 108; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.RemovePuckMsg RemovePuck { + get { return contentCase_ == ContentOneofCase.RemovePuck ? (global::IOModule.RemovePuckMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.RemovePuck; + } + } + + /// Field number for the "SensorBlocked" field. + public const int SensorBlockedFieldNumber = 109; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.SensorBlockedMsg SensorBlocked { + get { return contentCase_ == ContentOneofCase.SensorBlocked ? (global::IOModule.SensorBlockedMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.SensorBlocked; + } + } + + /// Field number for the "SensorCleared" field. + public const int SensorClearedFieldNumber = 110; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.SensorClearedMsg SensorCleared { + get { return contentCase_ == ContentOneofCase.SensorCleared ? (global::IOModule.SensorClearedMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.SensorCleared; + } + } + + /// Field number for the "GateStates" field. + public const int GateStatesFieldNumber = 111; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.GateStatesMsg GateStates { + get { return contentCase_ == ContentOneofCase.GateStates ? (global::IOModule.GateStatesMsg) content_ : null; } + set { + content_ = value; + contentCase_ = value == null ? ContentOneofCase.None : ContentOneofCase.GateStates; + } + } + + private object content_; + /// Enum of possible cases for the "Content" oneof. + public enum ContentOneofCase { + None = 0, + StartSlide = 100, + GateScore = 101, + PuckInGate = 102, + SensorState = 103, + LeftButtonPressed = 104, + RightButtonPressed = 105, + AcceptButtonPressed = 106, + CancelButtonPressed = 107, + RemovePuck = 108, + SensorBlocked = 109, + SensorCleared = 110, + GateStates = 111, + } + private ContentOneofCase contentCase_ = ContentOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ContentOneofCase ContentCase { + get { return contentCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearContent() { + contentCase_ = ContentOneofCase.None; + content_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as IOMessage); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(IOMessage other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(StartSlide, other.StartSlide)) return false; + if (!object.Equals(GateScore, other.GateScore)) return false; + if (!object.Equals(PuckInGate, other.PuckInGate)) return false; + if (!object.Equals(SensorState, other.SensorState)) return false; + if (!object.Equals(LeftButtonPressed, other.LeftButtonPressed)) return false; + if (!object.Equals(RightButtonPressed, other.RightButtonPressed)) return false; + if (!object.Equals(AcceptButtonPressed, other.AcceptButtonPressed)) return false; + if (!object.Equals(CancelButtonPressed, other.CancelButtonPressed)) return false; + if (!object.Equals(RemovePuck, other.RemovePuck)) return false; + if (!object.Equals(SensorBlocked, other.SensorBlocked)) return false; + if (!object.Equals(SensorCleared, other.SensorCleared)) return false; + if (!object.Equals(GateStates, other.GateStates)) return false; + if (ContentCase != other.ContentCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (contentCase_ == ContentOneofCase.StartSlide) hash ^= StartSlide.GetHashCode(); + if (contentCase_ == ContentOneofCase.GateScore) hash ^= GateScore.GetHashCode(); + if (contentCase_ == ContentOneofCase.PuckInGate) hash ^= PuckInGate.GetHashCode(); + if (contentCase_ == ContentOneofCase.SensorState) hash ^= SensorState.GetHashCode(); + if (contentCase_ == ContentOneofCase.LeftButtonPressed) hash ^= LeftButtonPressed.GetHashCode(); + if (contentCase_ == ContentOneofCase.RightButtonPressed) hash ^= RightButtonPressed.GetHashCode(); + if (contentCase_ == ContentOneofCase.AcceptButtonPressed) hash ^= AcceptButtonPressed.GetHashCode(); + if (contentCase_ == ContentOneofCase.CancelButtonPressed) hash ^= CancelButtonPressed.GetHashCode(); + if (contentCase_ == ContentOneofCase.RemovePuck) hash ^= RemovePuck.GetHashCode(); + if (contentCase_ == ContentOneofCase.SensorBlocked) hash ^= SensorBlocked.GetHashCode(); + if (contentCase_ == ContentOneofCase.SensorCleared) hash ^= SensorCleared.GetHashCode(); + if (contentCase_ == ContentOneofCase.GateStates) hash ^= GateStates.GetHashCode(); + hash ^= (int) contentCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (contentCase_ == ContentOneofCase.StartSlide) { + output.WriteRawTag(162, 6); + output.WriteMessage(StartSlide); + } + if (contentCase_ == ContentOneofCase.GateScore) { + output.WriteRawTag(170, 6); + output.WriteMessage(GateScore); + } + if (contentCase_ == ContentOneofCase.PuckInGate) { + output.WriteRawTag(178, 6); + output.WriteMessage(PuckInGate); + } + if (contentCase_ == ContentOneofCase.SensorState) { + output.WriteRawTag(186, 6); + output.WriteMessage(SensorState); + } + if (contentCase_ == ContentOneofCase.LeftButtonPressed) { + output.WriteRawTag(194, 6); + output.WriteMessage(LeftButtonPressed); + } + if (contentCase_ == ContentOneofCase.RightButtonPressed) { + output.WriteRawTag(202, 6); + output.WriteMessage(RightButtonPressed); + } + if (contentCase_ == ContentOneofCase.AcceptButtonPressed) { + output.WriteRawTag(210, 6); + output.WriteMessage(AcceptButtonPressed); + } + if (contentCase_ == ContentOneofCase.CancelButtonPressed) { + output.WriteRawTag(218, 6); + output.WriteMessage(CancelButtonPressed); + } + if (contentCase_ == ContentOneofCase.RemovePuck) { + output.WriteRawTag(226, 6); + output.WriteMessage(RemovePuck); + } + if (contentCase_ == ContentOneofCase.SensorBlocked) { + output.WriteRawTag(234, 6); + output.WriteMessage(SensorBlocked); + } + if (contentCase_ == ContentOneofCase.SensorCleared) { + output.WriteRawTag(242, 6); + output.WriteMessage(SensorCleared); + } + if (contentCase_ == ContentOneofCase.GateStates) { + output.WriteRawTag(250, 6); + output.WriteMessage(GateStates); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (contentCase_ == ContentOneofCase.StartSlide) { + output.WriteRawTag(162, 6); + output.WriteMessage(StartSlide); + } + if (contentCase_ == ContentOneofCase.GateScore) { + output.WriteRawTag(170, 6); + output.WriteMessage(GateScore); + } + if (contentCase_ == ContentOneofCase.PuckInGate) { + output.WriteRawTag(178, 6); + output.WriteMessage(PuckInGate); + } + if (contentCase_ == ContentOneofCase.SensorState) { + output.WriteRawTag(186, 6); + output.WriteMessage(SensorState); + } + if (contentCase_ == ContentOneofCase.LeftButtonPressed) { + output.WriteRawTag(194, 6); + output.WriteMessage(LeftButtonPressed); + } + if (contentCase_ == ContentOneofCase.RightButtonPressed) { + output.WriteRawTag(202, 6); + output.WriteMessage(RightButtonPressed); + } + if (contentCase_ == ContentOneofCase.AcceptButtonPressed) { + output.WriteRawTag(210, 6); + output.WriteMessage(AcceptButtonPressed); + } + if (contentCase_ == ContentOneofCase.CancelButtonPressed) { + output.WriteRawTag(218, 6); + output.WriteMessage(CancelButtonPressed); + } + if (contentCase_ == ContentOneofCase.RemovePuck) { + output.WriteRawTag(226, 6); + output.WriteMessage(RemovePuck); + } + if (contentCase_ == ContentOneofCase.SensorBlocked) { + output.WriteRawTag(234, 6); + output.WriteMessage(SensorBlocked); + } + if (contentCase_ == ContentOneofCase.SensorCleared) { + output.WriteRawTag(242, 6); + output.WriteMessage(SensorCleared); + } + if (contentCase_ == ContentOneofCase.GateStates) { + output.WriteRawTag(250, 6); + output.WriteMessage(GateStates); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (contentCase_ == ContentOneofCase.StartSlide) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(StartSlide); + } + if (contentCase_ == ContentOneofCase.GateScore) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(GateScore); + } + if (contentCase_ == ContentOneofCase.PuckInGate) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(PuckInGate); + } + if (contentCase_ == ContentOneofCase.SensorState) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SensorState); + } + if (contentCase_ == ContentOneofCase.LeftButtonPressed) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(LeftButtonPressed); + } + if (contentCase_ == ContentOneofCase.RightButtonPressed) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(RightButtonPressed); + } + if (contentCase_ == ContentOneofCase.AcceptButtonPressed) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(AcceptButtonPressed); + } + if (contentCase_ == ContentOneofCase.CancelButtonPressed) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(CancelButtonPressed); + } + if (contentCase_ == ContentOneofCase.RemovePuck) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(RemovePuck); + } + if (contentCase_ == ContentOneofCase.SensorBlocked) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SensorBlocked); + } + if (contentCase_ == ContentOneofCase.SensorCleared) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SensorCleared); + } + if (contentCase_ == ContentOneofCase.GateStates) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(GateStates); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(IOMessage other) { + if (other == null) { + return; + } + switch (other.ContentCase) { + case ContentOneofCase.StartSlide: + if (StartSlide == null) { + StartSlide = new global::IOModule.StartSlideMsg(); + } + StartSlide.MergeFrom(other.StartSlide); + break; + case ContentOneofCase.GateScore: + if (GateScore == null) { + GateScore = new global::IOModule.GateScoreMsg(); + } + GateScore.MergeFrom(other.GateScore); + break; + case ContentOneofCase.PuckInGate: + if (PuckInGate == null) { + PuckInGate = new global::IOModule.PuckInGateMsg(); + } + PuckInGate.MergeFrom(other.PuckInGate); + break; + case ContentOneofCase.SensorState: + if (SensorState == null) { + SensorState = new global::IOModule.SensorStateMsg(); + } + SensorState.MergeFrom(other.SensorState); + break; + case ContentOneofCase.LeftButtonPressed: + if (LeftButtonPressed == null) { + LeftButtonPressed = new global::IOModule.LeftButtonPressedMsg(); + } + LeftButtonPressed.MergeFrom(other.LeftButtonPressed); + break; + case ContentOneofCase.RightButtonPressed: + if (RightButtonPressed == null) { + RightButtonPressed = new global::IOModule.RightButtonPressedMsg(); + } + RightButtonPressed.MergeFrom(other.RightButtonPressed); + break; + case ContentOneofCase.AcceptButtonPressed: + if (AcceptButtonPressed == null) { + AcceptButtonPressed = new global::IOModule.AcceptButtonPressedMsg(); + } + AcceptButtonPressed.MergeFrom(other.AcceptButtonPressed); + break; + case ContentOneofCase.CancelButtonPressed: + if (CancelButtonPressed == null) { + CancelButtonPressed = new global::IOModule.CancelButtonPressedMsg(); + } + CancelButtonPressed.MergeFrom(other.CancelButtonPressed); + break; + case ContentOneofCase.RemovePuck: + if (RemovePuck == null) { + RemovePuck = new global::IOModule.RemovePuckMsg(); + } + RemovePuck.MergeFrom(other.RemovePuck); + break; + case ContentOneofCase.SensorBlocked: + if (SensorBlocked == null) { + SensorBlocked = new global::IOModule.SensorBlockedMsg(); + } + SensorBlocked.MergeFrom(other.SensorBlocked); + break; + case ContentOneofCase.SensorCleared: + if (SensorCleared == null) { + SensorCleared = new global::IOModule.SensorClearedMsg(); + } + SensorCleared.MergeFrom(other.SensorCleared); + break; + case ContentOneofCase.GateStates: + if (GateStates == null) { + GateStates = new global::IOModule.GateStatesMsg(); + } + GateStates.MergeFrom(other.GateStates); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 802: { + global::IOModule.StartSlideMsg subBuilder = new global::IOModule.StartSlideMsg(); + if (contentCase_ == ContentOneofCase.StartSlide) { + subBuilder.MergeFrom(StartSlide); + } + input.ReadMessage(subBuilder); + StartSlide = subBuilder; + break; + } + case 810: { + global::IOModule.GateScoreMsg subBuilder = new global::IOModule.GateScoreMsg(); + if (contentCase_ == ContentOneofCase.GateScore) { + subBuilder.MergeFrom(GateScore); + } + input.ReadMessage(subBuilder); + GateScore = subBuilder; + break; + } + case 818: { + global::IOModule.PuckInGateMsg subBuilder = new global::IOModule.PuckInGateMsg(); + if (contentCase_ == ContentOneofCase.PuckInGate) { + subBuilder.MergeFrom(PuckInGate); + } + input.ReadMessage(subBuilder); + PuckInGate = subBuilder; + break; + } + case 826: { + global::IOModule.SensorStateMsg subBuilder = new global::IOModule.SensorStateMsg(); + if (contentCase_ == ContentOneofCase.SensorState) { + subBuilder.MergeFrom(SensorState); + } + input.ReadMessage(subBuilder); + SensorState = subBuilder; + break; + } + case 834: { + global::IOModule.LeftButtonPressedMsg subBuilder = new global::IOModule.LeftButtonPressedMsg(); + if (contentCase_ == ContentOneofCase.LeftButtonPressed) { + subBuilder.MergeFrom(LeftButtonPressed); + } + input.ReadMessage(subBuilder); + LeftButtonPressed = subBuilder; + break; + } + case 842: { + global::IOModule.RightButtonPressedMsg subBuilder = new global::IOModule.RightButtonPressedMsg(); + if (contentCase_ == ContentOneofCase.RightButtonPressed) { + subBuilder.MergeFrom(RightButtonPressed); + } + input.ReadMessage(subBuilder); + RightButtonPressed = subBuilder; + break; + } + case 850: { + global::IOModule.AcceptButtonPressedMsg subBuilder = new global::IOModule.AcceptButtonPressedMsg(); + if (contentCase_ == ContentOneofCase.AcceptButtonPressed) { + subBuilder.MergeFrom(AcceptButtonPressed); + } + input.ReadMessage(subBuilder); + AcceptButtonPressed = subBuilder; + break; + } + case 858: { + global::IOModule.CancelButtonPressedMsg subBuilder = new global::IOModule.CancelButtonPressedMsg(); + if (contentCase_ == ContentOneofCase.CancelButtonPressed) { + subBuilder.MergeFrom(CancelButtonPressed); + } + input.ReadMessage(subBuilder); + CancelButtonPressed = subBuilder; + break; + } + case 866: { + global::IOModule.RemovePuckMsg subBuilder = new global::IOModule.RemovePuckMsg(); + if (contentCase_ == ContentOneofCase.RemovePuck) { + subBuilder.MergeFrom(RemovePuck); + } + input.ReadMessage(subBuilder); + RemovePuck = subBuilder; + break; + } + case 874: { + global::IOModule.SensorBlockedMsg subBuilder = new global::IOModule.SensorBlockedMsg(); + if (contentCase_ == ContentOneofCase.SensorBlocked) { + subBuilder.MergeFrom(SensorBlocked); + } + input.ReadMessage(subBuilder); + SensorBlocked = subBuilder; + break; + } + case 882: { + global::IOModule.SensorClearedMsg subBuilder = new global::IOModule.SensorClearedMsg(); + if (contentCase_ == ContentOneofCase.SensorCleared) { + subBuilder.MergeFrom(SensorCleared); + } + input.ReadMessage(subBuilder); + SensorCleared = subBuilder; + break; + } + case 890: { + global::IOModule.GateStatesMsg subBuilder = new global::IOModule.GateStatesMsg(); + if (contentCase_ == ContentOneofCase.GateStates) { + subBuilder.MergeFrom(GateStates); + } + input.ReadMessage(subBuilder); + GateStates = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 802: { + global::IOModule.StartSlideMsg subBuilder = new global::IOModule.StartSlideMsg(); + if (contentCase_ == ContentOneofCase.StartSlide) { + subBuilder.MergeFrom(StartSlide); + } + input.ReadMessage(subBuilder); + StartSlide = subBuilder; + break; + } + case 810: { + global::IOModule.GateScoreMsg subBuilder = new global::IOModule.GateScoreMsg(); + if (contentCase_ == ContentOneofCase.GateScore) { + subBuilder.MergeFrom(GateScore); + } + input.ReadMessage(subBuilder); + GateScore = subBuilder; + break; + } + case 818: { + global::IOModule.PuckInGateMsg subBuilder = new global::IOModule.PuckInGateMsg(); + if (contentCase_ == ContentOneofCase.PuckInGate) { + subBuilder.MergeFrom(PuckInGate); + } + input.ReadMessage(subBuilder); + PuckInGate = subBuilder; + break; + } + case 826: { + global::IOModule.SensorStateMsg subBuilder = new global::IOModule.SensorStateMsg(); + if (contentCase_ == ContentOneofCase.SensorState) { + subBuilder.MergeFrom(SensorState); + } + input.ReadMessage(subBuilder); + SensorState = subBuilder; + break; + } + case 834: { + global::IOModule.LeftButtonPressedMsg subBuilder = new global::IOModule.LeftButtonPressedMsg(); + if (contentCase_ == ContentOneofCase.LeftButtonPressed) { + subBuilder.MergeFrom(LeftButtonPressed); + } + input.ReadMessage(subBuilder); + LeftButtonPressed = subBuilder; + break; + } + case 842: { + global::IOModule.RightButtonPressedMsg subBuilder = new global::IOModule.RightButtonPressedMsg(); + if (contentCase_ == ContentOneofCase.RightButtonPressed) { + subBuilder.MergeFrom(RightButtonPressed); + } + input.ReadMessage(subBuilder); + RightButtonPressed = subBuilder; + break; + } + case 850: { + global::IOModule.AcceptButtonPressedMsg subBuilder = new global::IOModule.AcceptButtonPressedMsg(); + if (contentCase_ == ContentOneofCase.AcceptButtonPressed) { + subBuilder.MergeFrom(AcceptButtonPressed); + } + input.ReadMessage(subBuilder); + AcceptButtonPressed = subBuilder; + break; + } + case 858: { + global::IOModule.CancelButtonPressedMsg subBuilder = new global::IOModule.CancelButtonPressedMsg(); + if (contentCase_ == ContentOneofCase.CancelButtonPressed) { + subBuilder.MergeFrom(CancelButtonPressed); + } + input.ReadMessage(subBuilder); + CancelButtonPressed = subBuilder; + break; + } + case 866: { + global::IOModule.RemovePuckMsg subBuilder = new global::IOModule.RemovePuckMsg(); + if (contentCase_ == ContentOneofCase.RemovePuck) { + subBuilder.MergeFrom(RemovePuck); + } + input.ReadMessage(subBuilder); + RemovePuck = subBuilder; + break; + } + case 874: { + global::IOModule.SensorBlockedMsg subBuilder = new global::IOModule.SensorBlockedMsg(); + if (contentCase_ == ContentOneofCase.SensorBlocked) { + subBuilder.MergeFrom(SensorBlocked); + } + input.ReadMessage(subBuilder); + SensorBlocked = subBuilder; + break; + } + case 882: { + global::IOModule.SensorClearedMsg subBuilder = new global::IOModule.SensorClearedMsg(); + if (contentCase_ == ContentOneofCase.SensorCleared) { + subBuilder.MergeFrom(SensorCleared); + } + input.ReadMessage(subBuilder); + SensorCleared = subBuilder; + break; + } + case 890: { + global::IOModule.GateStatesMsg subBuilder = new global::IOModule.GateStatesMsg(); + if (contentCase_ == ContentOneofCase.GateStates) { + subBuilder.MergeFrom(GateStates); + } + input.ReadMessage(subBuilder); + GateStates = subBuilder; + break; + } + } + } + } + #endif + + } + + /// + /// Resets all states for a new round + /// + public sealed partial class RoundResetMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RoundResetMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RoundResetMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RoundResetMsg(RoundResetMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RoundResetMsg Clone() { + return new RoundResetMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RoundResetMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RoundResetMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RoundResetMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Turns button LEDs on/off + /// + public sealed partial class SetButtonLightsMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SetButtonLightsMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetButtonLightsMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetButtonLightsMsg(SetButtonLightsMsg other) : this() { + leftButton_ = other.leftButton_; + rightButton_ = other.rightButton_; + acceptButton_ = other.acceptButton_; + cancelButton_ = other.cancelButton_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetButtonLightsMsg Clone() { + return new SetButtonLightsMsg(this); + } + + /// Field number for the "LeftButton" field. + public const int LeftButtonFieldNumber = 1; + private bool leftButton_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool LeftButton { + get { return leftButton_; } + set { + leftButton_ = value; + } + } + + /// Field number for the "RightButton" field. + public const int RightButtonFieldNumber = 2; + private bool rightButton_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool RightButton { + get { return rightButton_; } + set { + rightButton_ = value; + } + } + + /// Field number for the "AcceptButton" field. + public const int AcceptButtonFieldNumber = 3; + private bool acceptButton_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool AcceptButton { + get { return acceptButton_; } + set { + acceptButton_ = value; + } + } + + /// Field number for the "CancelButton" field. + public const int CancelButtonFieldNumber = 4; + private bool cancelButton_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool CancelButton { + get { return cancelButton_; } + set { + cancelButton_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SetButtonLightsMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SetButtonLightsMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LeftButton != other.LeftButton) return false; + if (RightButton != other.RightButton) return false; + if (AcceptButton != other.AcceptButton) return false; + if (CancelButton != other.CancelButton) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (LeftButton != false) hash ^= LeftButton.GetHashCode(); + if (RightButton != false) hash ^= RightButton.GetHashCode(); + if (AcceptButton != false) hash ^= AcceptButton.GetHashCode(); + if (CancelButton != false) hash ^= CancelButton.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (LeftButton != false) { + output.WriteRawTag(8); + output.WriteBool(LeftButton); + } + if (RightButton != false) { + output.WriteRawTag(16); + output.WriteBool(RightButton); + } + if (AcceptButton != false) { + output.WriteRawTag(24); + output.WriteBool(AcceptButton); + } + if (CancelButton != false) { + output.WriteRawTag(32); + output.WriteBool(CancelButton); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (LeftButton != false) { + output.WriteRawTag(8); + output.WriteBool(LeftButton); + } + if (RightButton != false) { + output.WriteRawTag(16); + output.WriteBool(RightButton); + } + if (AcceptButton != false) { + output.WriteRawTag(24); + output.WriteBool(AcceptButton); + } + if (CancelButton != false) { + output.WriteRawTag(32); + output.WriteBool(CancelButton); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (LeftButton != false) { + size += 1 + 1; + } + if (RightButton != false) { + size += 1 + 1; + } + if (AcceptButton != false) { + size += 1 + 1; + } + if (CancelButton != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SetButtonLightsMsg other) { + if (other == null) { + return; + } + if (other.LeftButton != false) { + LeftButton = other.LeftButton; + } + if (other.RightButton != false) { + RightButton = other.RightButton; + } + if (other.AcceptButton != false) { + AcceptButton = other.AcceptButton; + } + if (other.CancelButton != false) { + CancelButton = other.CancelButton; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LeftButton = input.ReadBool(); + break; + } + case 16: { + RightButton = input.ReadBool(); + break; + } + case 24: { + AcceptButton = input.ReadBool(); + break; + } + case 32: { + CancelButton = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LeftButton = input.ReadBool(); + break; + } + case 16: { + RightButton = input.ReadBool(); + break; + } + case 24: { + AcceptButton = input.ReadBool(); + break; + } + case 32: { + CancelButton = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + /// + /// General settings for the behavior of the firmware + /// + public sealed partial class SettingsMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SettingsMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SettingsMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SettingsMsg(SettingsMsg other) : this() { + slideTimeoutMs_ = other.slideTimeoutMs_; + hardMode_ = other.hardMode_; + buttonRepeatTimeout_ = other.buttonRepeatTimeout_; + buttonRepeatInterval_ = other.buttonRepeatInterval_; + puckLostTimeout_ = other.puckLostTimeout_; + debounceTimeout_ = other.debounceTimeout_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SettingsMsg Clone() { + return new SettingsMsg(this); + } + + /// Field number for the "SlideTimeoutMs" field. + public const int SlideTimeoutMsFieldNumber = 1; + private uint slideTimeoutMs_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint SlideTimeoutMs { + get { return slideTimeoutMs_; } + set { + slideTimeoutMs_ = value; + } + } + + /// Field number for the "HardMode" field. + public const int HardModeFieldNumber = 2; + private bool hardMode_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HardMode { + get { return hardMode_; } + set { + hardMode_ = value; + } + } + + /// Field number for the "ButtonRepeatTimeout" field. + public const int ButtonRepeatTimeoutFieldNumber = 3; + private uint buttonRepeatTimeout_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint ButtonRepeatTimeout { + get { return buttonRepeatTimeout_; } + set { + buttonRepeatTimeout_ = value; + } + } + + /// Field number for the "ButtonRepeatInterval" field. + public const int ButtonRepeatIntervalFieldNumber = 4; + private uint buttonRepeatInterval_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint ButtonRepeatInterval { + get { return buttonRepeatInterval_; } + set { + buttonRepeatInterval_ = value; + } + } + + /// Field number for the "PuckLostTimeout" field. + public const int PuckLostTimeoutFieldNumber = 5; + private uint puckLostTimeout_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint PuckLostTimeout { + get { return puckLostTimeout_; } + set { + puckLostTimeout_ = value; + } + } + + /// Field number for the "DebounceTimeout" field. + public const int DebounceTimeoutFieldNumber = 6; + private uint debounceTimeout_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint DebounceTimeout { + get { return debounceTimeout_; } + set { + debounceTimeout_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SettingsMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SettingsMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (SlideTimeoutMs != other.SlideTimeoutMs) return false; + if (HardMode != other.HardMode) return false; + if (ButtonRepeatTimeout != other.ButtonRepeatTimeout) return false; + if (ButtonRepeatInterval != other.ButtonRepeatInterval) return false; + if (PuckLostTimeout != other.PuckLostTimeout) return false; + if (DebounceTimeout != other.DebounceTimeout) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (SlideTimeoutMs != 0) hash ^= SlideTimeoutMs.GetHashCode(); + if (HardMode != false) hash ^= HardMode.GetHashCode(); + if (ButtonRepeatTimeout != 0) hash ^= ButtonRepeatTimeout.GetHashCode(); + if (ButtonRepeatInterval != 0) hash ^= ButtonRepeatInterval.GetHashCode(); + if (PuckLostTimeout != 0) hash ^= PuckLostTimeout.GetHashCode(); + if (DebounceTimeout != 0) hash ^= DebounceTimeout.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (SlideTimeoutMs != 0) { + output.WriteRawTag(8); + output.WriteUInt32(SlideTimeoutMs); + } + if (HardMode != false) { + output.WriteRawTag(16); + output.WriteBool(HardMode); + } + if (ButtonRepeatTimeout != 0) { + output.WriteRawTag(24); + output.WriteUInt32(ButtonRepeatTimeout); + } + if (ButtonRepeatInterval != 0) { + output.WriteRawTag(32); + output.WriteUInt32(ButtonRepeatInterval); + } + if (PuckLostTimeout != 0) { + output.WriteRawTag(40); + output.WriteUInt32(PuckLostTimeout); + } + if (DebounceTimeout != 0) { + output.WriteRawTag(48); + output.WriteUInt32(DebounceTimeout); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (SlideTimeoutMs != 0) { + output.WriteRawTag(8); + output.WriteUInt32(SlideTimeoutMs); + } + if (HardMode != false) { + output.WriteRawTag(16); + output.WriteBool(HardMode); + } + if (ButtonRepeatTimeout != 0) { + output.WriteRawTag(24); + output.WriteUInt32(ButtonRepeatTimeout); + } + if (ButtonRepeatInterval != 0) { + output.WriteRawTag(32); + output.WriteUInt32(ButtonRepeatInterval); + } + if (PuckLostTimeout != 0) { + output.WriteRawTag(40); + output.WriteUInt32(PuckLostTimeout); + } + if (DebounceTimeout != 0) { + output.WriteRawTag(48); + output.WriteUInt32(DebounceTimeout); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (SlideTimeoutMs != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(SlideTimeoutMs); + } + if (HardMode != false) { + size += 1 + 1; + } + if (ButtonRepeatTimeout != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ButtonRepeatTimeout); + } + if (ButtonRepeatInterval != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ButtonRepeatInterval); + } + if (PuckLostTimeout != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(PuckLostTimeout); + } + if (DebounceTimeout != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DebounceTimeout); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SettingsMsg other) { + if (other == null) { + return; + } + if (other.SlideTimeoutMs != 0) { + SlideTimeoutMs = other.SlideTimeoutMs; + } + if (other.HardMode != false) { + HardMode = other.HardMode; + } + if (other.ButtonRepeatTimeout != 0) { + ButtonRepeatTimeout = other.ButtonRepeatTimeout; + } + if (other.ButtonRepeatInterval != 0) { + ButtonRepeatInterval = other.ButtonRepeatInterval; + } + if (other.PuckLostTimeout != 0) { + PuckLostTimeout = other.PuckLostTimeout; + } + if (other.DebounceTimeout != 0) { + DebounceTimeout = other.DebounceTimeout; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + SlideTimeoutMs = input.ReadUInt32(); + break; + } + case 16: { + HardMode = input.ReadBool(); + break; + } + case 24: { + ButtonRepeatTimeout = input.ReadUInt32(); + break; + } + case 32: { + ButtonRepeatInterval = input.ReadUInt32(); + break; + } + case 40: { + PuckLostTimeout = input.ReadUInt32(); + break; + } + case 48: { + DebounceTimeout = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + SlideTimeoutMs = input.ReadUInt32(); + break; + } + case 16: { + HardMode = input.ReadBool(); + break; + } + case 24: { + ButtonRepeatTimeout = input.ReadUInt32(); + break; + } + case 32: { + ButtonRepeatInterval = input.ReadUInt32(); + break; + } + case 40: { + PuckLostTimeout = input.ReadUInt32(); + break; + } + case 48: { + DebounceTimeout = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + /// + /// Commands the IO module to go into normal operating mode + /// + public sealed partial class NormalModeMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NormalModeMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NormalModeMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NormalModeMsg(NormalModeMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NormalModeMsg Clone() { + return new NormalModeMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NormalModeMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NormalModeMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NormalModeMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Commands the IO module to go into calibration (testing) mode + /// + public sealed partial class CalibrateModeMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CalibrateModeMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CalibrateModeMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CalibrateModeMsg(CalibrateModeMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CalibrateModeMsg Clone() { + return new CalibrateModeMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CalibrateModeMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CalibrateModeMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CalibrateModeMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Commands the IO module to turn on the Red LED (only in idle mode) + /// + public sealed partial class IndicateErrorMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new IndicateErrorMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public IndicateErrorMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public IndicateErrorMsg(IndicateErrorMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public IndicateErrorMsg Clone() { + return new IndicateErrorMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as IndicateErrorMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(IndicateErrorMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(IndicateErrorMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// A puck is detected under the bridge and sliding towards the gates + /// + public sealed partial class StartSlideMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StartSlideMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StartSlideMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StartSlideMsg(StartSlideMsg other) : this() { + speed_ = other.speed_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StartSlideMsg Clone() { + return new StartSlideMsg(this); + } + + /// Field number for the "Speed" field. + public const int SpeedFieldNumber = 1; + private uint speed_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Speed { + get { return speed_; } + set { + speed_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StartSlideMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StartSlideMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Speed != other.Speed) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Speed != 0) hash ^= Speed.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Speed != 0) { + output.WriteRawTag(8); + output.WriteUInt32(Speed); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Speed != 0) { + output.WriteRawTag(8); + output.WriteUInt32(Speed); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Speed != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Speed); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StartSlideMsg other) { + if (other == null) { + return; + } + if (other.Speed != 0) { + Speed = other.Speed; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Speed = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Speed = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + /// + /// A puck has landed near the bridge (at or before the second sensor) and must be removed + /// + public sealed partial class RemovePuckMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RemovePuckMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemovePuckMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemovePuckMsg(RemovePuckMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemovePuckMsg Clone() { + return new RemovePuckMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RemovePuckMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RemovePuckMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RemovePuckMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// A puck is blocking the bridge sensor(s) + /// + public sealed partial class SensorBlockedMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SensorBlockedMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[10]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SensorBlockedMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SensorBlockedMsg(SensorBlockedMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SensorBlockedMsg Clone() { + return new SensorBlockedMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SensorBlockedMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SensorBlockedMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SensorBlockedMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Bridge sensors are fine + /// + public sealed partial class SensorClearedMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SensorClearedMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[11]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SensorClearedMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SensorClearedMsg(SensorClearedMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SensorClearedMsg Clone() { + return new SensorClearedMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SensorClearedMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SensorClearedMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SensorClearedMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// The Left button on the front panel is pressed + /// + public sealed partial class LeftButtonPressedMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LeftButtonPressedMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LeftButtonPressedMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LeftButtonPressedMsg(LeftButtonPressedMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LeftButtonPressedMsg Clone() { + return new LeftButtonPressedMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LeftButtonPressedMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LeftButtonPressedMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LeftButtonPressedMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// The Right button on the front panel is pressed + /// + public sealed partial class RightButtonPressedMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RightButtonPressedMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[13]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RightButtonPressedMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RightButtonPressedMsg(RightButtonPressedMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RightButtonPressedMsg Clone() { + return new RightButtonPressedMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RightButtonPressedMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RightButtonPressedMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RightButtonPressedMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// The Accept button on the front panel is pressed + /// + public sealed partial class AcceptButtonPressedMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AcceptButtonPressedMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[14]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AcceptButtonPressedMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AcceptButtonPressedMsg(AcceptButtonPressedMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AcceptButtonPressedMsg Clone() { + return new AcceptButtonPressedMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AcceptButtonPressedMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AcceptButtonPressedMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AcceptButtonPressedMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// The Cancel button on the front panel is pressed + /// + public sealed partial class CancelButtonPressedMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CancelButtonPressedMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[15]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CancelButtonPressedMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CancelButtonPressedMsg(CancelButtonPressedMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CancelButtonPressedMsg Clone() { + return new CancelButtonPressedMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CancelButtonPressedMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CancelButtonPressedMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CancelButtonPressedMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// A puck went into a gate + /// + public sealed partial class GateScoreMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GateScoreMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[16]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GateScoreMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GateScoreMsg(GateScoreMsg other) : this() { + gate_ = other.gate_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GateScoreMsg Clone() { + return new GateScoreMsg(this); + } + + /// Field number for the "Gate" field. + public const int GateFieldNumber = 1; + private uint gate_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Gate { + get { return gate_; } + set { + gate_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as GateScoreMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(GateScoreMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Gate != other.Gate) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Gate != 0) hash ^= Gate.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Gate != 0) { + output.WriteRawTag(8); + output.WriteUInt32(Gate); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Gate != 0) { + output.WriteRawTag(8); + output.WriteUInt32(Gate); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Gate != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Gate); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(GateScoreMsg other) { + if (other == null) { + return; + } + if (other.Gate != 0) { + Gate = other.Gate; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Gate = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Gate = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + /// + /// A puck went almost into a gate, but not enough to score + /// + public sealed partial class PuckInGateMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PuckInGateMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[17]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PuckInGateMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PuckInGateMsg(PuckInGateMsg other) : this() { + gate_ = other.gate_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PuckInGateMsg Clone() { + return new PuckInGateMsg(this); + } + + /// Field number for the "Gate" field. + public const int GateFieldNumber = 1; + private uint gate_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Gate { + get { return gate_; } + set { + gate_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as PuckInGateMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(PuckInGateMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Gate != other.Gate) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Gate != 0) hash ^= Gate.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Gate != 0) { + output.WriteRawTag(8); + output.WriteUInt32(Gate); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Gate != 0) { + output.WriteRawTag(8); + output.WriteUInt32(Gate); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Gate != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Gate); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(PuckInGateMsg other) { + if (other == null) { + return; + } + if (other.Gate != 0) { + Gate = other.Gate; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Gate = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Gate = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + /// + /// Checks if any gates are blocked by a puck (in normal mode) + /// + public sealed partial class RequestGateStatesMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RequestGateStatesMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[18]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RequestGateStatesMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RequestGateStatesMsg(RequestGateStatesMsg other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RequestGateStatesMsg Clone() { + return new RequestGateStatesMsg(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RequestGateStatesMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RequestGateStatesMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RequestGateStatesMsg other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Response to RequestGateStatesMsg + /// + public sealed partial class GateStatesMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GateStatesMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[19]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GateStatesMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GateStatesMsg(GateStatesMsg other) : this() { + gate1Blocked_ = other.gate1Blocked_; + gate2Blocked_ = other.gate2Blocked_; + gate3Blocked_ = other.gate3Blocked_; + gate4Blocked_ = other.gate4Blocked_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GateStatesMsg Clone() { + return new GateStatesMsg(this); + } + + /// Field number for the "Gate1Blocked" field. + public const int Gate1BlockedFieldNumber = 1; + private bool gate1Blocked_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Gate1Blocked { + get { return gate1Blocked_; } + set { + gate1Blocked_ = value; + } + } + + /// Field number for the "Gate2Blocked" field. + public const int Gate2BlockedFieldNumber = 2; + private bool gate2Blocked_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Gate2Blocked { + get { return gate2Blocked_; } + set { + gate2Blocked_ = value; + } + } + + /// Field number for the "Gate3Blocked" field. + public const int Gate3BlockedFieldNumber = 3; + private bool gate3Blocked_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Gate3Blocked { + get { return gate3Blocked_; } + set { + gate3Blocked_ = value; + } + } + + /// Field number for the "Gate4Blocked" field. + public const int Gate4BlockedFieldNumber = 4; + private bool gate4Blocked_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Gate4Blocked { + get { return gate4Blocked_; } + set { + gate4Blocked_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as GateStatesMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(GateStatesMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Gate1Blocked != other.Gate1Blocked) return false; + if (Gate2Blocked != other.Gate2Blocked) return false; + if (Gate3Blocked != other.Gate3Blocked) return false; + if (Gate4Blocked != other.Gate4Blocked) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Gate1Blocked != false) hash ^= Gate1Blocked.GetHashCode(); + if (Gate2Blocked != false) hash ^= Gate2Blocked.GetHashCode(); + if (Gate3Blocked != false) hash ^= Gate3Blocked.GetHashCode(); + if (Gate4Blocked != false) hash ^= Gate4Blocked.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Gate1Blocked != false) { + output.WriteRawTag(8); + output.WriteBool(Gate1Blocked); + } + if (Gate2Blocked != false) { + output.WriteRawTag(16); + output.WriteBool(Gate2Blocked); + } + if (Gate3Blocked != false) { + output.WriteRawTag(24); + output.WriteBool(Gate3Blocked); + } + if (Gate4Blocked != false) { + output.WriteRawTag(32); + output.WriteBool(Gate4Blocked); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Gate1Blocked != false) { + output.WriteRawTag(8); + output.WriteBool(Gate1Blocked); + } + if (Gate2Blocked != false) { + output.WriteRawTag(16); + output.WriteBool(Gate2Blocked); + } + if (Gate3Blocked != false) { + output.WriteRawTag(24); + output.WriteBool(Gate3Blocked); + } + if (Gate4Blocked != false) { + output.WriteRawTag(32); + output.WriteBool(Gate4Blocked); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Gate1Blocked != false) { + size += 1 + 1; + } + if (Gate2Blocked != false) { + size += 1 + 1; + } + if (Gate3Blocked != false) { + size += 1 + 1; + } + if (Gate4Blocked != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(GateStatesMsg other) { + if (other == null) { + return; + } + if (other.Gate1Blocked != false) { + Gate1Blocked = other.Gate1Blocked; + } + if (other.Gate2Blocked != false) { + Gate2Blocked = other.Gate2Blocked; + } + if (other.Gate3Blocked != false) { + Gate3Blocked = other.Gate3Blocked; + } + if (other.Gate4Blocked != false) { + Gate4Blocked = other.Gate4Blocked; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Gate1Blocked = input.ReadBool(); + break; + } + case 16: { + Gate2Blocked = input.ReadBool(); + break; + } + case 24: { + Gate3Blocked = input.ReadBool(); + break; + } + case 32: { + Gate4Blocked = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Gate1Blocked = input.ReadBool(); + break; + } + case 16: { + Gate2Blocked = input.ReadBool(); + break; + } + case 24: { + Gate3Blocked = input.ReadBool(); + break; + } + case 32: { + Gate4Blocked = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + /// + /// Sensor state change in calibration mode + /// + public sealed partial class SensorStateMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SensorStateMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[20]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SensorStateMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SensorStateMsg(SensorStateMsg other) : this() { + sensor_ = other.sensor_; + high_ = other.high_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SensorStateMsg Clone() { + return new SensorStateMsg(this); + } + + /// Field number for the "Sensor" field. + public const int SensorFieldNumber = 1; + private global::IOModule.Sensor sensor_ = global::IOModule.Sensor.Gate1Front; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::IOModule.Sensor Sensor { + get { return sensor_; } + set { + sensor_ = value; + } + } + + /// Field number for the "High" field. + public const int HighFieldNumber = 2; + private bool high_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool High { + get { return high_; } + set { + high_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SensorStateMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SensorStateMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Sensor != other.Sensor) return false; + if (High != other.High) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Sensor != global::IOModule.Sensor.Gate1Front) hash ^= Sensor.GetHashCode(); + if (High != false) hash ^= High.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Sensor != global::IOModule.Sensor.Gate1Front) { + output.WriteRawTag(8); + output.WriteEnum((int) Sensor); + } + if (High != false) { + output.WriteRawTag(16); + output.WriteBool(High); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Sensor != global::IOModule.Sensor.Gate1Front) { + output.WriteRawTag(8); + output.WriteEnum((int) Sensor); + } + if (High != false) { + output.WriteRawTag(16); + output.WriteBool(High); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Sensor != global::IOModule.Sensor.Gate1Front) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Sensor); + } + if (High != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SensorStateMsg other) { + if (other == null) { + return; + } + if (other.Sensor != global::IOModule.Sensor.Gate1Front) { + Sensor = other.Sensor; + } + if (other.High != false) { + High = other.High; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Sensor = (global::IOModule.Sensor) input.ReadEnum(); + break; + } + case 16: { + High = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Sensor = (global::IOModule.Sensor) input.ReadEnum(); + break; + } + case 16: { + High = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + public sealed partial class SetButtonRepeatMsg : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SetButtonRepeatMsg()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::IOModule.IOModuleReflection.Descriptor.MessageTypes[21]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetButtonRepeatMsg() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetButtonRepeatMsg(SetButtonRepeatMsg other) : this() { + enable_ = other.enable_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetButtonRepeatMsg Clone() { + return new SetButtonRepeatMsg(this); + } + + /// Field number for the "Enable" field. + public const int EnableFieldNumber = 1; + private bool enable_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Enable { + get { return enable_; } + set { + enable_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SetButtonRepeatMsg); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SetButtonRepeatMsg other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Enable != other.Enable) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Enable != false) hash ^= Enable.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Enable != false) { + output.WriteRawTag(8); + output.WriteBool(Enable); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Enable != false) { + output.WriteRawTag(8); + output.WriteBool(Enable); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Enable != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SetButtonRepeatMsg other) { + if (other == null) { + return; + } + if (other.Enable != false) { + Enable = other.Enable; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Enable = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Enable = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/IOModuleSimulator/IOModuleSimulator.csproj b/IOModuleSimulator/IOModuleSimulator.csproj new file mode 100644 index 0000000..6a08111 --- /dev/null +++ b/IOModuleSimulator/IOModuleSimulator.csproj @@ -0,0 +1,94 @@ + + + + + Debug + AnyCPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE} + WinExe + IOModuleSimulator + IOModuleSimulator + v4.7.2 + 512 + true + true + + + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + Form + + + FormMain.cs + + + + + + FormMain.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + \ No newline at end of file diff --git a/IOModuleSimulator/Program.cs b/IOModuleSimulator/Program.cs new file mode 100644 index 0000000..d1433e6 --- /dev/null +++ b/IOModuleSimulator/Program.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace IOModuleSimulator +{ + internal static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new FormMain()); + } + } +} diff --git a/IOModuleSimulator/Properties/AssemblyInfo.cs b/IOModuleSimulator/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..90645a4 --- /dev/null +++ b/IOModuleSimulator/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("IOModuleSimulator")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("IOModuleSimulator")] +[assembly: AssemblyCopyright("Copyright © 2023")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("39f7f282-047a-4136-a0ad-0c2ff2f5f9ae")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/IOModuleSimulator/Properties/Resources.Designer.cs b/IOModuleSimulator/Properties/Resources.Designer.cs new file mode 100644 index 0000000..195c670 --- /dev/null +++ b/IOModuleSimulator/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace IOModuleSimulator.Properties +{ + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources + { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("IOModuleSimulator.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/IOModuleSimulator/Properties/Resources.resx b/IOModuleSimulator/Properties/Resources.resx new file mode 100644 index 0000000..af7dbeb --- /dev/null +++ b/IOModuleSimulator/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/IOModuleSimulator/Properties/Settings.Designer.cs b/IOModuleSimulator/Properties/Settings.Designer.cs new file mode 100644 index 0000000..9f5239e --- /dev/null +++ b/IOModuleSimulator/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace IOModuleSimulator.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/IOModuleSimulator/Properties/Settings.settings b/IOModuleSimulator/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/IOModuleSimulator/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/IOModuleSimulator/packages.config b/IOModuleSimulator/packages.config new file mode 100644 index 0000000..a06bc95 --- /dev/null +++ b/IOModuleSimulator/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/Pandemic.sln b/Pandemic.sln index 42f1d2e..f8903b3 100644 --- a/Pandemic.sln +++ b/Pandemic.sln @@ -7,16 +7,23 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Pandemic", "Pandemic\Pandem EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "IOModule", "IOModule\IOModule.vcxproj", "{C5F80730-F44F-4478-BDAE-6634EFC2CA88}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IOModuleSimulator", "IOModuleSimulator\IOModuleSimulator.csproj", "{39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU Debug|ARM = Debug|ARM Debug|x64 = Debug|x64 Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU Release|ARM = Release|ARM Release|x64 = Release|x64 Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution + {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Debug|Any CPU.ActiveCfg = Debug|x64 + {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Debug|Any CPU.Build.0 = Debug|x64 + {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Debug|Any CPU.Deploy.0 = Debug|x64 {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Debug|ARM.ActiveCfg = Debug|ARM {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Debug|ARM.Build.0 = Debug|ARM {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Debug|ARM.Deploy.0 = Debug|ARM @@ -26,6 +33,9 @@ Global {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Debug|x86.ActiveCfg = Debug|x86 {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Debug|x86.Build.0 = Debug|x86 {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Debug|x86.Deploy.0 = Debug|x86 + {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Release|Any CPU.ActiveCfg = Release|x64 + {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Release|Any CPU.Build.0 = Release|x64 + {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Release|Any CPU.Deploy.0 = Release|x64 {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Release|ARM.ActiveCfg = Release|ARM {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Release|ARM.Build.0 = Release|ARM {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Release|ARM.Deploy.0 = Release|ARM @@ -35,12 +45,32 @@ Global {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Release|x86.ActiveCfg = Release|x86 {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Release|x86.Build.0 = Release|x86 {ACFFB6EC-BDEB-41C3-BB89-E9C646766398}.Release|x86.Deploy.0 = Release|x86 + {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Debug|Any CPU.ActiveCfg = Debug|Win32 + {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Debug|Any CPU.Build.0 = Debug|Win32 {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Debug|ARM.ActiveCfg = Release|Win32 {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Debug|x64.ActiveCfg = Release|Win32 {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Debug|x86.ActiveCfg = Release|Win32 + {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Release|Any CPU.ActiveCfg = Release|Win32 + {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Release|Any CPU.Build.0 = Release|Win32 {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Release|ARM.ActiveCfg = Release|Win32 {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Release|x64.ActiveCfg = Release|Win32 {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Release|x86.ActiveCfg = Release|Win32 + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Debug|Any CPU.Build.0 = Debug|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Debug|ARM.ActiveCfg = Debug|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Debug|ARM.Build.0 = Debug|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Debug|x64.ActiveCfg = Debug|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Debug|x64.Build.0 = Debug|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Debug|x86.ActiveCfg = Debug|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Debug|x86.Build.0 = Debug|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Release|Any CPU.ActiveCfg = Release|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Release|Any CPU.Build.0 = Release|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Release|ARM.ActiveCfg = Release|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Release|ARM.Build.0 = Release|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Release|x64.ActiveCfg = Release|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Release|x64.Build.0 = Release|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Release|x86.ActiveCfg = Release|Any CPU + {39F7F282-047A-4136-A0AD-0C2FF2F5F9AE}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE