scisharp
/
TensorFlow.NET
Not watched
1
0
Fork 0
Code
Releases 21 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 4f29e1000a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4f29e1000a'
${ noResults }
TensorFlow.NET/src/TensorFlowNET.Core/Protobuf/Event.cs

2423 lines
90 kB
Raw Blame History 

  1. // <auto-generated>

  2. //     Generated by the protocol buffer compiler.  DO NOT EDIT!

  3. //     source: tensorflow/core/util/event.proto

  4. // </auto-generated>

  5. #pragma warning disable 1591, 0612, 3021, 8981

  6. #region Designer generated code

  7. 

  8. using pb = global::Google.Protobuf;

  9. using pbc = global::Google.Protobuf.Collections;

  10. using pbr = global::Google.Protobuf.Reflection;

  11. using scg = global::System.Collections.Generic;

  12. namespace Tensorflow {

  13. 

  14.   /// <summary>Holder for reflection information generated from tensorflow/core/util/event.proto</summary>

  15.   public static partial class EventReflection {

  16. 

  17.     #region Descriptor

  18.     /// <summary>File descriptor for tensorflow/core/util/event.proto</summary>

  19.     public static pbr::FileDescriptor Descriptor {

  20.       get { return descriptor; }

  21.     }

  22.     private static pbr::FileDescriptor descriptor;

  23. 

  24.     static EventReflection() {

  25.       byte[] descriptorData = global::System.Convert.FromBase64String(

  26.           string.Concat(

  27.             "CiB0ZW5zb3JmbG93L2NvcmUvdXRpbC9ldmVudC5wcm90bxIKdGVuc29yZmxv",

  28.             "dxondGVuc29yZmxvdy9jb3JlL2ZyYW1ld29yay9zdW1tYXJ5LnByb3RvIr8C",

  29.             "CgVFdmVudBIRCgl3YWxsX3RpbWUYASABKAESDAoEc3RlcBgCIAEoAxIWCgxm",

  30.             "aWxlX3ZlcnNpb24YAyABKAlIABITCglncmFwaF9kZWYYBCABKAxIABImCgdz",

  31.             "dW1tYXJ5GAUgASgLMhMudGVuc29yZmxvdy5TdW1tYXJ5SAASMQoLbG9nX21l",

  32.             "c3NhZ2UYBiABKAsyFi50ZW5zb3JmbG93LkxvZ01lc3NhZ2VCAhgBSAASLQoL",

  33.             "c2Vzc2lvbl9sb2cYByABKAsyFi50ZW5zb3JmbG93LlNlc3Npb25Mb2dIABI8",

  34.             "ChN0YWdnZWRfcnVuX21ldGFkYXRhGAggASgLMh0udGVuc29yZmxvdy5UYWdn",

  35.             "ZWRSdW5NZXRhZGF0YUgAEhgKDm1ldGFfZ3JhcGhfZGVmGAkgASgMSABCBgoE",

  36.             "d2hhdCKhAQoKTG9nTWVzc2FnZRIrCgVsZXZlbBgBIAEoDjIcLnRlbnNvcmZs",

  37.             "b3cuTG9nTWVzc2FnZS5MZXZlbBIPCgdtZXNzYWdlGAIgASgJIlEKBUxldmVs",

  38.             "EgsKB1VOS05PV04QABINCglERUJVR0dJTkcQChIICgRJTkZPEBQSCAoEV0FS",

  39.             "ThAeEgkKBUVSUk9SECgSCQoFRkFUQUwQMhoCGAE6AhgBIrYBCgpTZXNzaW9u",

  40.             "TG9nEjQKBnN0YXR1cxgBIAEoDjIkLnRlbnNvcmZsb3cuU2Vzc2lvbkxvZy5T",

  41.             "ZXNzaW9uU3RhdHVzEhcKD2NoZWNrcG9pbnRfcGF0aBgCIAEoCRILCgNtc2cY",

  42.             "AyABKAkiTAoNU2Vzc2lvblN0YXR1cxIWChJTVEFUVVNfVU5TUEVDSUZJRUQQ",

  43.             "ABIJCgVTVEFSVBABEggKBFNUT1AQAhIOCgpDSEVDS1BPSU5UEAMiNgoRVGFn",

  44.             "Z2VkUnVuTWV0YWRhdGESCwoDdGFnGAEgASgJEhQKDHJ1bl9tZXRhZGF0YRgC",

  45.             "IAEoDCIkCg5XYXRjaGRvZ0NvbmZpZxISCgp0aW1lb3V0X21zGAEgASgDIiYK",

  46.             "EVJlcXVlc3RlZEV4aXRDb2RlEhEKCWV4aXRfY29kZRgBIAEoBSK2AQoWV29y",

  47.             "a2VySGVhcnRiZWF0UmVxdWVzdBI1Cg1zaHV0ZG93bl9tb2RlGAEgASgOMh4u",

  48.             "dGVuc29yZmxvdy5Xb3JrZXJTaHV0ZG93bk1vZGUSMwoPd2F0Y2hkb2dfY29u",

  49.             "ZmlnGAIgASgLMhoudGVuc29yZmxvdy5XYXRjaGRvZ0NvbmZpZxIwCglleGl0",

  50.             "X2NvZGUYAyABKAsyHS50ZW5zb3JmbG93LlJlcXVlc3RlZEV4aXRDb2RlIoMB",

  51.             "ChdXb3JrZXJIZWFydGJlYXRSZXNwb25zZRIvCg1oZWFsdGhfc3RhdHVzGAEg",

  52.             "ASgOMhgudGVuc29yZmxvdy5Xb3JrZXJIZWFsdGgSJQoKd29ya2VyX2xvZxgC",

  53.             "IAMoCzIRLnRlbnNvcmZsb3cuRXZlbnQSEAoIaG9zdG5hbWUYAyABKAkqWwoM",

  54.             "V29ya2VySGVhbHRoEgYKAk9LEAASHAoYUkVDRUlWRURfU0hVVERPV05fU0lH",

  55.             "TkFMEAESEgoOSU5URVJOQUxfRVJST1IQAhIRCg1TSFVUVElOR19ET1dOEAMq",

  56.             "awoSV29ya2VyU2h1dGRvd25Nb2RlEgsKB0RFRkFVTFQQABISCg5OT1RfQ09O",

  57.             "RklHVVJFRBABEhgKFFdBSVRfRk9SX0NPT1JESU5BVE9SEAISGgoWU0hVVERP",

  58.             "V05fQUZURVJfVElNRU9VVBADQnAKE29yZy50ZW5zb3JmbG93LnV0aWxCC0V2",

  59.             "ZW50UHJvdG9zUAFaR2dpdGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3JmbG93",

  60.             "L3RlbnNvcmZsb3cvZ28vY29yZS91dGlsL2V2ZW50X2dvX3Byb3Rv+AEBYgZw",

  61.             "cm90bzM="));

  62.       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,

  63.           new pbr::FileDescriptor[] { global::Tensorflow.SummaryReflection.Descriptor, },

  64.           new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Tensorflow.WorkerHealth), typeof(global::Tensorflow.WorkerShutdownMode), }, null, new pbr::GeneratedClrTypeInfo[] {

  65.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.Event), global::Tensorflow.Event.Parser, new[]{ "WallTime", "Step", "FileVersion", "GraphDef", "Summary", "LogMessage", "SessionLog", "TaggedRunMetadata", "MetaGraphDef" }, new[]{ "What" }, null, null, null),

  66.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.LogMessage), global::Tensorflow.LogMessage.Parser, new[]{ "Level", "Message" }, null, new[]{ typeof(global::Tensorflow.LogMessage.Types.Level) }, null, null),

  67.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SessionLog), global::Tensorflow.SessionLog.Parser, new[]{ "Status", "CheckpointPath", "Msg" }, null, new[]{ typeof(global::Tensorflow.SessionLog.Types.SessionStatus) }, null, null),

  68.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.TaggedRunMetadata), global::Tensorflow.TaggedRunMetadata.Parser, new[]{ "Tag", "RunMetadata" }, null, null, null, null),

  69.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.WatchdogConfig), global::Tensorflow.WatchdogConfig.Parser, new[]{ "TimeoutMs" }, null, null, null, null),

  70.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.RequestedExitCode), global::Tensorflow.RequestedExitCode.Parser, new[]{ "ExitCode" }, null, null, null, null),

  71.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.WorkerHeartbeatRequest), global::Tensorflow.WorkerHeartbeatRequest.Parser, new[]{ "ShutdownMode", "WatchdogConfig", "ExitCode" }, null, null, null, null),

  72.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.WorkerHeartbeatResponse), global::Tensorflow.WorkerHeartbeatResponse.Parser, new[]{ "HealthStatus", "WorkerLog", "Hostname" }, null, null, null, null)

  73.           }));

  74.     }

  75.     #endregion

  76. 

  77.   }

  78.   #region Enums

  79.   /// <summary>

  80.   /// Current health status of a worker.

  81.   /// </summary>

  82.   public enum WorkerHealth {

  83.     /// <summary>

  84.     /// By default a worker is healthy.

  85.     /// </summary>

  86.     [pbr::OriginalName("OK")] Ok = 0,

  87.     [pbr::OriginalName("RECEIVED_SHUTDOWN_SIGNAL")] ReceivedShutdownSignal = 1,

  88.     [pbr::OriginalName("INTERNAL_ERROR")] InternalError = 2,

  89.     /// <summary>

  90.     /// Worker has been instructed to shutdown after a timeout.

  91.     /// </summary>

  92.     [pbr::OriginalName("SHUTTING_DOWN")] ShuttingDown = 3,

  93.   }

  94. 

  95.   /// <summary>

  96.   /// Indicates the behavior of the worker when an internal error or shutdown

  97.   /// signal is received.

  98.   /// </summary>

  99.   public enum WorkerShutdownMode {

  100.     [pbr::OriginalName("DEFAULT")] Default = 0,

  101.     [pbr::OriginalName("NOT_CONFIGURED")] NotConfigured = 1,

  102.     [pbr::OriginalName("WAIT_FOR_COORDINATOR")] WaitForCoordinator = 2,

  103.     [pbr::OriginalName("SHUTDOWN_AFTER_TIMEOUT")] ShutdownAfterTimeout = 3,

  104.   }

  105. 

  106.   #endregion

  107. 

  108.   #region Messages

  109.   /// <summary>

  110.   /// Protocol buffer representing an event that happened during

  111.   /// the execution of a Brain model.

  112.   /// </summary>

  113.   public sealed partial class Event : pb::IMessage<Event>

  114.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  115.       , pb::IBufferMessage

  116.   #endif

  117.   {

  118.     private static readonly pb::MessageParser<Event> _parser = new pb::MessageParser<Event>(() => new Event());

  119.     private pb::UnknownFieldSet _unknownFields;

  120.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  121.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  122.     public static pb::MessageParser<Event> Parser { get { return _parser; } }

  123. 

  124.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  125.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  126.     public static pbr::MessageDescriptor Descriptor {

  127.       get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[0]; }

  128.     }

  129. 

  130.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  131.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  132.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  133.       get { return Descriptor; }

  134.     }

  135. 

  136.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  137.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  138.     public Event() {

  139.       OnConstruction();

  140.     }

  141. 

  142.     partial void OnConstruction();

  143. 

  144.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  145.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  146.     public Event(Event other) : this() {

  147.       wallTime_ = other.wallTime_;

  148.       step_ = other.step_;

  149.       switch (other.WhatCase) {

  150.         case WhatOneofCase.FileVersion:

  151.           FileVersion = other.FileVersion;

  152.           break;

  153.         case WhatOneofCase.GraphDef:

  154.           GraphDef = other.GraphDef;

  155.           break;

  156.         case WhatOneofCase.Summary:

  157.           Summary = other.Summary.Clone();

  158.           break;

  159.         case WhatOneofCase.LogMessage:

  160.           LogMessage = other.LogMessage.Clone();

  161.           break;

  162.         case WhatOneofCase.SessionLog:

  163.           SessionLog = other.SessionLog.Clone();

  164.           break;

  165.         case WhatOneofCase.TaggedRunMetadata:

  166.           TaggedRunMetadata = other.TaggedRunMetadata.Clone();

  167.           break;

  168.         case WhatOneofCase.MetaGraphDef:

  169.           MetaGraphDef = other.MetaGraphDef;

  170.           break;

  171.       }

  172. 

  173.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  174.     }

  175. 

  176.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  177.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  178.     public Event Clone() {

  179.       return new Event(this);

  180.     }

  181. 

  182.     /// <summary>Field number for the "wall_time" field.</summary>

  183.     public const int WallTimeFieldNumber = 1;

  184.     private double wallTime_;

  185.     /// <summary>

  186.     /// Timestamp of the event.

  187.     /// </summary>

  188.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  189.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  190.     public double WallTime {

  191.       get { return wallTime_; }

  192.       set {

  193.         wallTime_ = value;

  194.       }

  195.     }

  196. 

  197.     /// <summary>Field number for the "step" field.</summary>

  198.     public const int StepFieldNumber = 2;

  199.     private long step_;

  200.     /// <summary>

  201.     /// Global step of the event.

  202.     /// </summary>

  203.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  204.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  205.     public long Step {

  206.       get { return step_; }

  207.       set {

  208.         step_ = value;

  209.       }

  210.     }

  211. 

  212.     /// <summary>Field number for the "file_version" field.</summary>

  213.     public const int FileVersionFieldNumber = 3;

  214.     /// <summary>

  215.     /// An event file was started, with the specified version.

  216.     /// This is use to identify the contents of the record IO files

  217.     /// easily.  Current version is "brain.Event:2".  All versions

  218.     /// start with "brain.Event:".

  219.     /// </summary>

  220.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  221.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  222.     public string FileVersion {

  223.       get { return whatCase_ == WhatOneofCase.FileVersion ? (string) what_ : ""; }

  224.       set {

  225.         what_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  226.         whatCase_ = WhatOneofCase.FileVersion;

  227.       }

  228.     }

  229. 

  230.     /// <summary>Field number for the "graph_def" field.</summary>

  231.     public const int GraphDefFieldNumber = 4;

  232.     /// <summary>

  233.     /// An encoded version of a GraphDef.

  234.     /// </summary>

  235.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  236.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  237.     public pb::ByteString GraphDef {

  238.       get { return whatCase_ == WhatOneofCase.GraphDef ? (pb::ByteString) what_ : pb::ByteString.Empty; }

  239.       set {

  240.         what_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  241.         whatCase_ = WhatOneofCase.GraphDef;

  242.       }

  243.     }

  244. 

  245.     /// <summary>Field number for the "summary" field.</summary>

  246.     public const int SummaryFieldNumber = 5;

  247.     /// <summary>

  248.     /// A summary was generated.

  249.     /// </summary>

  250.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  251.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  252.     public global::Tensorflow.Summary Summary {

  253.       get { return whatCase_ == WhatOneofCase.Summary ? (global::Tensorflow.Summary) what_ : null; }

  254.       set {

  255.         what_ = value;

  256.         whatCase_ = value == null ? WhatOneofCase.None : WhatOneofCase.Summary;

  257.       }

  258.     }

  259. 

  260.     /// <summary>Field number for the "log_message" field.</summary>

  261.     public const int LogMessageFieldNumber = 6;

  262.     /// <summary>

  263.     /// The user output a log message. This was theoretically used by the defunct

  264.     /// tensorboard_logging module, which has since been removed; this field is

  265.     /// now deprecated and should not be used.

  266.     /// </summary>

  267.     [global::System.ObsoleteAttribute]

  268.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  269.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  270.     public global::Tensorflow.LogMessage LogMessage {

  271.       get { return whatCase_ == WhatOneofCase.LogMessage ? (global::Tensorflow.LogMessage) what_ : null; }

  272.       set {

  273.         what_ = value;

  274.         whatCase_ = value == null ? WhatOneofCase.None : WhatOneofCase.LogMessage;

  275.       }

  276.     }

  277. 

  278.     /// <summary>Field number for the "session_log" field.</summary>

  279.     public const int SessionLogFieldNumber = 7;

  280.     /// <summary>

  281.     /// The state of the session which can be used for restarting after crashes.

  282.     /// </summary>

  283.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  284.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  285.     public global::Tensorflow.SessionLog SessionLog {

  286.       get { return whatCase_ == WhatOneofCase.SessionLog ? (global::Tensorflow.SessionLog) what_ : null; }

  287.       set {

  288.         what_ = value;

  289.         whatCase_ = value == null ? WhatOneofCase.None : WhatOneofCase.SessionLog;

  290.       }

  291.     }

  292. 

  293.     /// <summary>Field number for the "tagged_run_metadata" field.</summary>

  294.     public const int TaggedRunMetadataFieldNumber = 8;

  295.     /// <summary>

  296.     /// The metadata returned by running a session.run() call.

  297.     /// </summary>

  298.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  299.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  300.     public global::Tensorflow.TaggedRunMetadata TaggedRunMetadata {

  301.       get { return whatCase_ == WhatOneofCase.TaggedRunMetadata ? (global::Tensorflow.TaggedRunMetadata) what_ : null; }

  302.       set {

  303.         what_ = value;

  304.         whatCase_ = value == null ? WhatOneofCase.None : WhatOneofCase.TaggedRunMetadata;

  305.       }

  306.     }

  307. 

  308.     /// <summary>Field number for the "meta_graph_def" field.</summary>

  309.     public const int MetaGraphDefFieldNumber = 9;

  310.     /// <summary>

  311.     /// An encoded version of a MetaGraphDef.

  312.     /// </summary>

  313.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  314.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  315.     public pb::ByteString MetaGraphDef {

  316.       get { return whatCase_ == WhatOneofCase.MetaGraphDef ? (pb::ByteString) what_ : pb::ByteString.Empty; }

  317.       set {

  318.         what_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  319.         whatCase_ = WhatOneofCase.MetaGraphDef;

  320.       }

  321.     }

  322. 

  323.     private object what_;

  324.     /// <summary>Enum of possible cases for the "what" oneof.</summary>

  325.     public enum WhatOneofCase {

  326.       None = 0,

  327.       FileVersion = 3,

  328.       GraphDef = 4,

  329.       Summary = 5,

  330.       LogMessage = 6,

  331.       SessionLog = 7,

  332.       TaggedRunMetadata = 8,

  333.       MetaGraphDef = 9,

  334.     }

  335.     private WhatOneofCase whatCase_ = WhatOneofCase.None;

  336.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  337.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  338.     public WhatOneofCase WhatCase {

  339.       get { return whatCase_; }

  340.     }

  341. 

  342.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  343.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  344.     public void ClearWhat() {

  345.       whatCase_ = WhatOneofCase.None;

  346.       what_ = null;

  347.     }

  348. 

  349.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  350.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  351.     public override bool Equals(object other) {

  352.       return Equals(other as Event);

  353.     }

  354. 

  355.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  356.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  357.     public bool Equals(Event other) {

  358.       if (ReferenceEquals(other, null)) {

  359.         return false;

  360.       }

  361.       if (ReferenceEquals(other, this)) {

  362.         return true;

  363.       }

  364.       if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(WallTime, other.WallTime)) return false;

  365.       if (Step != other.Step) return false;

  366.       if (FileVersion != other.FileVersion) return false;

  367.       if (GraphDef != other.GraphDef) return false;

  368.       if (!object.Equals(Summary, other.Summary)) return false;

  369.       if (!object.Equals(LogMessage, other.LogMessage)) return false;

  370.       if (!object.Equals(SessionLog, other.SessionLog)) return false;

  371.       if (!object.Equals(TaggedRunMetadata, other.TaggedRunMetadata)) return false;

  372.       if (MetaGraphDef != other.MetaGraphDef) return false;

  373.       if (WhatCase != other.WhatCase) return false;

  374.       return Equals(_unknownFields, other._unknownFields);

  375.     }

  376. 

  377.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  378.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  379.     public override int GetHashCode() {

  380.       int hash = 1;

  381.       if (WallTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(WallTime);

  382.       if (Step != 0L) hash ^= Step.GetHashCode();

  383.       if (whatCase_ == WhatOneofCase.FileVersion) hash ^= FileVersion.GetHashCode();

  384.       if (whatCase_ == WhatOneofCase.GraphDef) hash ^= GraphDef.GetHashCode();

  385.       if (whatCase_ == WhatOneofCase.Summary) hash ^= Summary.GetHashCode();

  386.       if (whatCase_ == WhatOneofCase.LogMessage) hash ^= LogMessage.GetHashCode();

  387.       if (whatCase_ == WhatOneofCase.SessionLog) hash ^= SessionLog.GetHashCode();

  388.       if (whatCase_ == WhatOneofCase.TaggedRunMetadata) hash ^= TaggedRunMetadata.GetHashCode();

  389.       if (whatCase_ == WhatOneofCase.MetaGraphDef) hash ^= MetaGraphDef.GetHashCode();

  390.       hash ^= (int) whatCase_;

  391.       if (_unknownFields != null) {

  392.         hash ^= _unknownFields.GetHashCode();

  393.       }

  394.       return hash;

  395.     }

  396. 

  397.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  398.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  399.     public override string ToString() {

  400.       return pb::JsonFormatter.ToDiagnosticString(this);

  401.     }

  402. 

  403.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  404.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  405.     public void WriteTo(pb::CodedOutputStream output) {

  406.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  407.       output.WriteRawMessage(this);

  408.     #else

  409.       if (WallTime != 0D) {

  410.         output.WriteRawTag(9);

  411.         output.WriteDouble(WallTime);

  412.       }

  413.       if (Step != 0L) {

  414.         output.WriteRawTag(16);

  415.         output.WriteInt64(Step);

  416.       }

  417.       if (whatCase_ == WhatOneofCase.FileVersion) {

  418.         output.WriteRawTag(26);

  419.         output.WriteString(FileVersion);

  420.       }

  421.       if (whatCase_ == WhatOneofCase.GraphDef) {

  422.         output.WriteRawTag(34);

  423.         output.WriteBytes(GraphDef);

  424.       }

  425.       if (whatCase_ == WhatOneofCase.Summary) {

  426.         output.WriteRawTag(42);

  427.         output.WriteMessage(Summary);

  428.       }

  429.       if (whatCase_ == WhatOneofCase.LogMessage) {

  430.         output.WriteRawTag(50);

  431.         output.WriteMessage(LogMessage);

  432.       }

  433.       if (whatCase_ == WhatOneofCase.SessionLog) {

  434.         output.WriteRawTag(58);

  435.         output.WriteMessage(SessionLog);

  436.       }

  437.       if (whatCase_ == WhatOneofCase.TaggedRunMetadata) {

  438.         output.WriteRawTag(66);

  439.         output.WriteMessage(TaggedRunMetadata);

  440.       }

  441.       if (whatCase_ == WhatOneofCase.MetaGraphDef) {

  442.         output.WriteRawTag(74);

  443.         output.WriteBytes(MetaGraphDef);

  444.       }

  445.       if (_unknownFields != null) {

  446.         _unknownFields.WriteTo(output);

  447.       }

  448.     #endif

  449.     }

  450. 

  451.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  452.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  453.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  454.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  455.       if (WallTime != 0D) {

  456.         output.WriteRawTag(9);

  457.         output.WriteDouble(WallTime);

  458.       }

  459.       if (Step != 0L) {

  460.         output.WriteRawTag(16);

  461.         output.WriteInt64(Step);

  462.       }

  463.       if (whatCase_ == WhatOneofCase.FileVersion) {

  464.         output.WriteRawTag(26);

  465.         output.WriteString(FileVersion);

  466.       }

  467.       if (whatCase_ == WhatOneofCase.GraphDef) {

  468.         output.WriteRawTag(34);

  469.         output.WriteBytes(GraphDef);

  470.       }

  471.       if (whatCase_ == WhatOneofCase.Summary) {

  472.         output.WriteRawTag(42);

  473.         output.WriteMessage(Summary);

  474.       }

  475.       if (whatCase_ == WhatOneofCase.LogMessage) {

  476.         output.WriteRawTag(50);

  477.         output.WriteMessage(LogMessage);

  478.       }

  479.       if (whatCase_ == WhatOneofCase.SessionLog) {

  480.         output.WriteRawTag(58);

  481.         output.WriteMessage(SessionLog);

  482.       }

  483.       if (whatCase_ == WhatOneofCase.TaggedRunMetadata) {

  484.         output.WriteRawTag(66);

  485.         output.WriteMessage(TaggedRunMetadata);

  486.       }

  487.       if (whatCase_ == WhatOneofCase.MetaGraphDef) {

  488.         output.WriteRawTag(74);

  489.         output.WriteBytes(MetaGraphDef);

  490.       }

  491.       if (_unknownFields != null) {

  492.         _unknownFields.WriteTo(ref output);

  493.       }

  494.     }

  495.     #endif

  496. 

  497.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  498.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  499.     public int CalculateSize() {

  500.       int size = 0;

  501.       if (WallTime != 0D) {

  502.         size += 1 + 8;

  503.       }

  504.       if (Step != 0L) {

  505.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(Step);

  506.       }

  507.       if (whatCase_ == WhatOneofCase.FileVersion) {

  508.         size += 1 + pb::CodedOutputStream.ComputeStringSize(FileVersion);

  509.       }

  510.       if (whatCase_ == WhatOneofCase.GraphDef) {

  511.         size += 1 + pb::CodedOutputStream.ComputeBytesSize(GraphDef);

  512.       }

  513.       if (whatCase_ == WhatOneofCase.Summary) {

  514.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Summary);

  515.       }

  516.       if (whatCase_ == WhatOneofCase.LogMessage) {

  517.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(LogMessage);

  518.       }

  519.       if (whatCase_ == WhatOneofCase.SessionLog) {

  520.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(SessionLog);

  521.       }

  522.       if (whatCase_ == WhatOneofCase.TaggedRunMetadata) {

  523.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(TaggedRunMetadata);

  524.       }

  525.       if (whatCase_ == WhatOneofCase.MetaGraphDef) {

  526.         size += 1 + pb::CodedOutputStream.ComputeBytesSize(MetaGraphDef);

  527.       }

  528.       if (_unknownFields != null) {

  529.         size += _unknownFields.CalculateSize();

  530.       }

  531.       return size;

  532.     }

  533. 

  534.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  535.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  536.     public void MergeFrom(Event other) {

  537.       if (other == null) {

  538.         return;

  539.       }

  540.       if (other.WallTime != 0D) {

  541.         WallTime = other.WallTime;

  542.       }

  543.       if (other.Step != 0L) {

  544.         Step = other.Step;

  545.       }

  546.       switch (other.WhatCase) {

  547.         case WhatOneofCase.FileVersion:

  548.           FileVersion = other.FileVersion;

  549.           break;

  550.         case WhatOneofCase.GraphDef:

  551.           GraphDef = other.GraphDef;

  552.           break;

  553.         case WhatOneofCase.Summary:

  554.           if (Summary == null) {

  555.             Summary = new global::Tensorflow.Summary();

  556.           }

  557.           Summary.MergeFrom(other.Summary);

  558.           break;

  559.         case WhatOneofCase.LogMessage:

  560.           if (LogMessage == null) {

  561.             LogMessage = new global::Tensorflow.LogMessage();

  562.           }

  563.           LogMessage.MergeFrom(other.LogMessage);

  564.           break;

  565.         case WhatOneofCase.SessionLog:

  566.           if (SessionLog == null) {

  567.             SessionLog = new global::Tensorflow.SessionLog();

  568.           }

  569.           SessionLog.MergeFrom(other.SessionLog);

  570.           break;

  571.         case WhatOneofCase.TaggedRunMetadata:

  572.           if (TaggedRunMetadata == null) {

  573.             TaggedRunMetadata = new global::Tensorflow.TaggedRunMetadata();

  574.           }

  575.           TaggedRunMetadata.MergeFrom(other.TaggedRunMetadata);

  576.           break;

  577.         case WhatOneofCase.MetaGraphDef:

  578.           MetaGraphDef = other.MetaGraphDef;

  579.           break;

  580.       }

  581. 

  582.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  583.     }

  584. 

  585.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  586.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  587.     public void MergeFrom(pb::CodedInputStream input) {

  588.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  589.       input.ReadRawMessage(this);

  590.     #else

  591.       uint tag;

  592.       while ((tag = input.ReadTag()) != 0) {

  593.         switch(tag) {

  594.           default:

  595.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  596.             break;

  597.           case 9: {

  598.             WallTime = input.ReadDouble();

  599.             break;

  600.           }

  601.           case 16: {

  602.             Step = input.ReadInt64();

  603.             break;

  604.           }

  605.           case 26: {

  606.             FileVersion = input.ReadString();

  607.             break;

  608.           }

  609.           case 34: {

  610.             GraphDef = input.ReadBytes();

  611.             break;

  612.           }

  613.           case 42: {

  614.             global::Tensorflow.Summary subBuilder = new global::Tensorflow.Summary();

  615.             if (whatCase_ == WhatOneofCase.Summary) {

  616.               subBuilder.MergeFrom(Summary);

  617.             }

  618.             input.ReadMessage(subBuilder);

  619.             Summary = subBuilder;

  620.             break;

  621.           }

  622.           case 50: {

  623.             global::Tensorflow.LogMessage subBuilder = new global::Tensorflow.LogMessage();

  624.             if (whatCase_ == WhatOneofCase.LogMessage) {

  625.               subBuilder.MergeFrom(LogMessage);

  626.             }

  627.             input.ReadMessage(subBuilder);

  628.             LogMessage = subBuilder;

  629.             break;

  630.           }

  631.           case 58: {

  632.             global::Tensorflow.SessionLog subBuilder = new global::Tensorflow.SessionLog();

  633.             if (whatCase_ == WhatOneofCase.SessionLog) {

  634.               subBuilder.MergeFrom(SessionLog);

  635.             }

  636.             input.ReadMessage(subBuilder);

  637.             SessionLog = subBuilder;

  638.             break;

  639.           }

  640.           case 66: {

  641.             global::Tensorflow.TaggedRunMetadata subBuilder = new global::Tensorflow.TaggedRunMetadata();

  642.             if (whatCase_ == WhatOneofCase.TaggedRunMetadata) {

  643.               subBuilder.MergeFrom(TaggedRunMetadata);

  644.             }

  645.             input.ReadMessage(subBuilder);

  646.             TaggedRunMetadata = subBuilder;

  647.             break;

  648.           }

  649.           case 74: {

  650.             MetaGraphDef = input.ReadBytes();

  651.             break;

  652.           }

  653.         }

  654.       }

  655.     #endif

  656.     }

  657. 

  658.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  659.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  660.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  661.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  662.       uint tag;

  663.       while ((tag = input.ReadTag()) != 0) {

  664.         switch(tag) {

  665.           default:

  666.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  667.             break;

  668.           case 9: {

  669.             WallTime = input.ReadDouble();

  670.             break;

  671.           }

  672.           case 16: {

  673.             Step = input.ReadInt64();

  674.             break;

  675.           }

  676.           case 26: {

  677.             FileVersion = input.ReadString();

  678.             break;

  679.           }

  680.           case 34: {

  681.             GraphDef = input.ReadBytes();

  682.             break;

  683.           }

  684.           case 42: {

  685.             global::Tensorflow.Summary subBuilder = new global::Tensorflow.Summary();

  686.             if (whatCase_ == WhatOneofCase.Summary) {

  687.               subBuilder.MergeFrom(Summary);

  688.             }

  689.             input.ReadMessage(subBuilder);

  690.             Summary = subBuilder;

  691.             break;

  692.           }

  693.           case 50: {

  694.             global::Tensorflow.LogMessage subBuilder = new global::Tensorflow.LogMessage();

  695.             if (whatCase_ == WhatOneofCase.LogMessage) {

  696.               subBuilder.MergeFrom(LogMessage);

  697.             }

  698.             input.ReadMessage(subBuilder);

  699.             LogMessage = subBuilder;

  700.             break;

  701.           }

  702.           case 58: {

  703.             global::Tensorflow.SessionLog subBuilder = new global::Tensorflow.SessionLog();

  704.             if (whatCase_ == WhatOneofCase.SessionLog) {

  705.               subBuilder.MergeFrom(SessionLog);

  706.             }

  707.             input.ReadMessage(subBuilder);

  708.             SessionLog = subBuilder;

  709.             break;

  710.           }

  711.           case 66: {

  712.             global::Tensorflow.TaggedRunMetadata subBuilder = new global::Tensorflow.TaggedRunMetadata();

  713.             if (whatCase_ == WhatOneofCase.TaggedRunMetadata) {

  714.               subBuilder.MergeFrom(TaggedRunMetadata);

  715.             }

  716.             input.ReadMessage(subBuilder);

  717.             TaggedRunMetadata = subBuilder;

  718.             break;

  719.           }

  720.           case 74: {

  721.             MetaGraphDef = input.ReadBytes();

  722.             break;

  723.           }

  724.         }

  725.       }

  726.     }

  727.     #endif

  728. 

  729.   }

  730. 

  731.   /// <summary>

  732.   /// Protocol buffer used for logging messages to the events file.

  733.   ///

  734.   /// This was theoretically used by the defunct tensorboard_logging module, which

  735.   /// has been removed; this message is now deprecated and should not be used.

  736.   /// </summary>

  737.   [global::System.ObsoleteAttribute]

  738.   public sealed partial class LogMessage : pb::IMessage<LogMessage>

  739.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  740.       , pb::IBufferMessage

  741.   #endif

  742.   {

  743.     private static readonly pb::MessageParser<LogMessage> _parser = new pb::MessageParser<LogMessage>(() => new LogMessage());

  744.     private pb::UnknownFieldSet _unknownFields;

  745.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  746.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  747.     public static pb::MessageParser<LogMessage> Parser { get { return _parser; } }

  748. 

  749.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  750.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  751.     public static pbr::MessageDescriptor Descriptor {

  752.       get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[1]; }

  753.     }

  754. 

  755.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  756.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  757.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  758.       get { return Descriptor; }

  759.     }

  760. 

  761.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  762.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  763.     public LogMessage() {

  764.       OnConstruction();

  765.     }

  766. 

  767.     partial void OnConstruction();

  768. 

  769.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  770.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  771.     public LogMessage(LogMessage other) : this() {

  772.       level_ = other.level_;

  773.       message_ = other.message_;

  774.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  775.     }

  776. 

  777.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  778.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  779.     public LogMessage Clone() {

  780.       return new LogMessage(this);

  781.     }

  782. 

  783.     /// <summary>Field number for the "level" field.</summary>

  784.     public const int LevelFieldNumber = 1;

  785.     private global::Tensorflow.LogMessage.Types.Level level_ = global::Tensorflow.LogMessage.Types.Level.Unknown;

  786.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  787.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  788.     public global::Tensorflow.LogMessage.Types.Level Level {

  789.       get { return level_; }

  790.       set {

  791.         level_ = value;

  792.       }

  793.     }

  794. 

  795.     /// <summary>Field number for the "message" field.</summary>

  796.     public const int MessageFieldNumber = 2;

  797.     private string message_ = "";

  798.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  799.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  800.     public string Message {

  801.       get { return message_; }

  802.       set {

  803.         message_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  804.       }

  805.     }

  806. 

  807.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  808.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  809.     public override bool Equals(object other) {

  810.       return Equals(other as LogMessage);

  811.     }

  812. 

  813.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  814.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  815.     public bool Equals(LogMessage other) {

  816.       if (ReferenceEquals(other, null)) {

  817.         return false;

  818.       }

  819.       if (ReferenceEquals(other, this)) {

  820.         return true;

  821.       }

  822.       if (Level != other.Level) return false;

  823.       if (Message != other.Message) return false;

  824.       return Equals(_unknownFields, other._unknownFields);

  825.     }

  826. 

  827.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  828.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  829.     public override int GetHashCode() {

  830.       int hash = 1;

  831.       if (Level != global::Tensorflow.LogMessage.Types.Level.Unknown) hash ^= Level.GetHashCode();

  832.       if (Message.Length != 0) hash ^= Message.GetHashCode();

  833.       if (_unknownFields != null) {

  834.         hash ^= _unknownFields.GetHashCode();

  835.       }

  836.       return hash;

  837.     }

  838. 

  839.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  840.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  841.     public override string ToString() {

  842.       return pb::JsonFormatter.ToDiagnosticString(this);

  843.     }

  844. 

  845.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  846.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  847.     public void WriteTo(pb::CodedOutputStream output) {

  848.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  849.       output.WriteRawMessage(this);

  850.     #else

  851.       if (Level != global::Tensorflow.LogMessage.Types.Level.Unknown) {

  852.         output.WriteRawTag(8);

  853.         output.WriteEnum((int) Level);

  854.       }

  855.       if (Message.Length != 0) {

  856.         output.WriteRawTag(18);

  857.         output.WriteString(Message);

  858.       }

  859.       if (_unknownFields != null) {

  860.         _unknownFields.WriteTo(output);

  861.       }

  862.     #endif

  863.     }

  864. 

  865.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  866.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  867.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  868.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  869.       if (Level != global::Tensorflow.LogMessage.Types.Level.Unknown) {

  870.         output.WriteRawTag(8);

  871.         output.WriteEnum((int) Level);

  872.       }

  873.       if (Message.Length != 0) {

  874.         output.WriteRawTag(18);

  875.         output.WriteString(Message);

  876.       }

  877.       if (_unknownFields != null) {

  878.         _unknownFields.WriteTo(ref output);

  879.       }

  880.     }

  881.     #endif

  882. 

  883.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  884.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  885.     public int CalculateSize() {

  886.       int size = 0;

  887.       if (Level != global::Tensorflow.LogMessage.Types.Level.Unknown) {

  888.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Level);

  889.       }

  890.       if (Message.Length != 0) {

  891.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Message);

  892.       }

  893.       if (_unknownFields != null) {

  894.         size += _unknownFields.CalculateSize();

  895.       }

  896.       return size;

  897.     }

  898. 

  899.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  900.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  901.     public void MergeFrom(LogMessage other) {

  902.       if (other == null) {

  903.         return;

  904.       }

  905.       if (other.Level != global::Tensorflow.LogMessage.Types.Level.Unknown) {

  906.         Level = other.Level;

  907.       }

  908.       if (other.Message.Length != 0) {

  909.         Message = other.Message;

  910.       }

  911.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  912.     }

  913. 

  914.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  915.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  916.     public void MergeFrom(pb::CodedInputStream input) {

  917.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  918.       input.ReadRawMessage(this);

  919.     #else

  920.       uint tag;

  921.       while ((tag = input.ReadTag()) != 0) {

  922.         switch(tag) {

  923.           default:

  924.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  925.             break;

  926.           case 8: {

  927.             Level = (global::Tensorflow.LogMessage.Types.Level) input.ReadEnum();

  928.             break;

  929.           }

  930.           case 18: {

  931.             Message = input.ReadString();

  932.             break;

  933.           }

  934.         }

  935.       }

  936.     #endif

  937.     }

  938. 

  939.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  940.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  941.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  942.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  943.       uint tag;

  944.       while ((tag = input.ReadTag()) != 0) {

  945.         switch(tag) {

  946.           default:

  947.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  948.             break;

  949.           case 8: {

  950.             Level = (global::Tensorflow.LogMessage.Types.Level) input.ReadEnum();

  951.             break;

  952.           }

  953.           case 18: {

  954.             Message = input.ReadString();

  955.             break;

  956.           }

  957.         }

  958.       }

  959.     }

  960.     #endif

  961. 

  962.     #region Nested types

  963.     /// <summary>Container for nested types declared in the LogMessage message type.</summary>

  964.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  965.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  966.     public static partial class Types {

  967.       public enum Level {

  968.         [pbr::OriginalName("UNKNOWN")] Unknown = 0,

  969.         /// <summary>

  970.         /// Note: The logging level 10 cannot be named DEBUG. Some software

  971.         /// projects compile their C/C++ code with -DDEBUG in debug builds. So the

  972.         /// C++ code generated from this file should not have an identifier named

  973.         /// DEBUG.

  974.         /// </summary>

  975.         [pbr::OriginalName("DEBUGGING")] Debugging = 10,

  976.         [pbr::OriginalName("INFO")] Info = 20,

  977.         [pbr::OriginalName("WARN")] Warn = 30,

  978.         [pbr::OriginalName("ERROR")] Error = 40,

  979.         [pbr::OriginalName("FATAL")] Fatal = 50,

  980.       }

  981. 

  982.     }

  983.     #endregion

  984. 

  985.   }

  986. 

  987.   /// <summary>

  988.   /// Protocol buffer used for logging session state.

  989.   /// </summary>

  990.   public sealed partial class SessionLog : pb::IMessage<SessionLog>

  991.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  992.       , pb::IBufferMessage

  993.   #endif

  994.   {

  995.     private static readonly pb::MessageParser<SessionLog> _parser = new pb::MessageParser<SessionLog>(() => new SessionLog());

  996.     private pb::UnknownFieldSet _unknownFields;

  997.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  998.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  999.     public static pb::MessageParser<SessionLog> Parser { get { return _parser; } }

  1000. 

  1001.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1002.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1003.     public static pbr::MessageDescriptor Descriptor {

  1004.       get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[2]; }

  1005.     }

  1006. 

  1007.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1008.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1009.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1010.       get { return Descriptor; }

  1011.     }

  1012. 

  1013.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1014.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1015.     public SessionLog() {

  1016.       OnConstruction();

  1017.     }

  1018. 

  1019.     partial void OnConstruction();

  1020. 

  1021.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1022.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1023.     public SessionLog(SessionLog other) : this() {

  1024.       status_ = other.status_;

  1025.       checkpointPath_ = other.checkpointPath_;

  1026.       msg_ = other.msg_;

  1027.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  1028.     }

  1029. 

  1030.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1031.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1032.     public SessionLog Clone() {

  1033.       return new SessionLog(this);

  1034.     }

  1035. 

  1036.     /// <summary>Field number for the "status" field.</summary>

  1037.     public const int StatusFieldNumber = 1;

  1038.     private global::Tensorflow.SessionLog.Types.SessionStatus status_ = global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified;

  1039.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1040.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1041.     public global::Tensorflow.SessionLog.Types.SessionStatus Status {

  1042.       get { return status_; }

  1043.       set {

  1044.         status_ = value;

  1045.       }

  1046.     }

  1047. 

  1048.     /// <summary>Field number for the "checkpoint_path" field.</summary>

  1049.     public const int CheckpointPathFieldNumber = 2;

  1050.     private string checkpointPath_ = "";

  1051.     /// <summary>

  1052.     /// This checkpoint_path contains both the path and filename.

  1053.     /// </summary>

  1054.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1055.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1056.     public string CheckpointPath {

  1057.       get { return checkpointPath_; }

  1058.       set {

  1059.         checkpointPath_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  1060.       }

  1061.     }

  1062. 

  1063.     /// <summary>Field number for the "msg" field.</summary>

  1064.     public const int MsgFieldNumber = 3;

  1065.     private string msg_ = "";

  1066.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1067.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1068.     public string Msg {

  1069.       get { return msg_; }

  1070.       set {

  1071.         msg_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  1072.       }

  1073.     }

  1074. 

  1075.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1076.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1077.     public override bool Equals(object other) {

  1078.       return Equals(other as SessionLog);

  1079.     }

  1080. 

  1081.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1082.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1083.     public bool Equals(SessionLog other) {

  1084.       if (ReferenceEquals(other, null)) {

  1085.         return false;

  1086.       }

  1087.       if (ReferenceEquals(other, this)) {

  1088.         return true;

  1089.       }

  1090.       if (Status != other.Status) return false;

  1091.       if (CheckpointPath != other.CheckpointPath) return false;

  1092.       if (Msg != other.Msg) return false;

  1093.       return Equals(_unknownFields, other._unknownFields);

  1094.     }

  1095. 

  1096.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1097.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1098.     public override int GetHashCode() {

  1099.       int hash = 1;

  1100.       if (Status != global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified) hash ^= Status.GetHashCode();

  1101.       if (CheckpointPath.Length != 0) hash ^= CheckpointPath.GetHashCode();

  1102.       if (Msg.Length != 0) hash ^= Msg.GetHashCode();

  1103.       if (_unknownFields != null) {

  1104.         hash ^= _unknownFields.GetHashCode();

  1105.       }

  1106.       return hash;

  1107.     }

  1108. 

  1109.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1110.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1111.     public override string ToString() {

  1112.       return pb::JsonFormatter.ToDiagnosticString(this);

  1113.     }

  1114. 

  1115.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1116.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1117.     public void WriteTo(pb::CodedOutputStream output) {

  1118.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1119.       output.WriteRawMessage(this);

  1120.     #else

  1121.       if (Status != global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified) {

  1122.         output.WriteRawTag(8);

  1123.         output.WriteEnum((int) Status);

  1124.       }

  1125.       if (CheckpointPath.Length != 0) {

  1126.         output.WriteRawTag(18);

  1127.         output.WriteString(CheckpointPath);

  1128.       }

  1129.       if (Msg.Length != 0) {

  1130.         output.WriteRawTag(26);

  1131.         output.WriteString(Msg);

  1132.       }

  1133.       if (_unknownFields != null) {

  1134.         _unknownFields.WriteTo(output);

  1135.       }

  1136.     #endif

  1137.     }

  1138. 

  1139.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1140.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1141.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1142.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  1143.       if (Status != global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified) {

  1144.         output.WriteRawTag(8);

  1145.         output.WriteEnum((int) Status);

  1146.       }

  1147.       if (CheckpointPath.Length != 0) {

  1148.         output.WriteRawTag(18);

  1149.         output.WriteString(CheckpointPath);

  1150.       }

  1151.       if (Msg.Length != 0) {

  1152.         output.WriteRawTag(26);

  1153.         output.WriteString(Msg);

  1154.       }

  1155.       if (_unknownFields != null) {

  1156.         _unknownFields.WriteTo(ref output);

  1157.       }

  1158.     }

  1159.     #endif

  1160. 

  1161.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1162.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1163.     public int CalculateSize() {

  1164.       int size = 0;

  1165.       if (Status != global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified) {

  1166.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Status);

  1167.       }

  1168.       if (CheckpointPath.Length != 0) {

  1169.         size += 1 + pb::CodedOutputStream.ComputeStringSize(CheckpointPath);

  1170.       }

  1171.       if (Msg.Length != 0) {

  1172.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Msg);

  1173.       }

  1174.       if (_unknownFields != null) {

  1175.         size += _unknownFields.CalculateSize();

  1176.       }

  1177.       return size;

  1178.     }

  1179. 

  1180.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1181.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1182.     public void MergeFrom(SessionLog other) {

  1183.       if (other == null) {

  1184.         return;

  1185.       }

  1186.       if (other.Status != global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified) {

  1187.         Status = other.Status;

  1188.       }

  1189.       if (other.CheckpointPath.Length != 0) {

  1190.         CheckpointPath = other.CheckpointPath;

  1191.       }

  1192.       if (other.Msg.Length != 0) {

  1193.         Msg = other.Msg;

  1194.       }

  1195.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  1196.     }

  1197. 

  1198.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1199.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1200.     public void MergeFrom(pb::CodedInputStream input) {

  1201.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1202.       input.ReadRawMessage(this);

  1203.     #else

  1204.       uint tag;

  1205.       while ((tag = input.ReadTag()) != 0) {

  1206.         switch(tag) {

  1207.           default:

  1208.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1209.             break;

  1210.           case 8: {

  1211.             Status = (global::Tensorflow.SessionLog.Types.SessionStatus) input.ReadEnum();

  1212.             break;

  1213.           }

  1214.           case 18: {

  1215.             CheckpointPath = input.ReadString();

  1216.             break;

  1217.           }

  1218.           case 26: {

  1219.             Msg = input.ReadString();

  1220.             break;

  1221.           }

  1222.         }

  1223.       }

  1224.     #endif

  1225.     }

  1226. 

  1227.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1228.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1229.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1230.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  1231.       uint tag;

  1232.       while ((tag = input.ReadTag()) != 0) {

  1233.         switch(tag) {

  1234.           default:

  1235.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  1236.             break;

  1237.           case 8: {

  1238.             Status = (global::Tensorflow.SessionLog.Types.SessionStatus) input.ReadEnum();

  1239.             break;

  1240.           }

  1241.           case 18: {

  1242.             CheckpointPath = input.ReadString();

  1243.             break;

  1244.           }

  1245.           case 26: {

  1246.             Msg = input.ReadString();

  1247.             break;

  1248.           }

  1249.         }

  1250.       }

  1251.     }

  1252.     #endif

  1253. 

  1254.     #region Nested types

  1255.     /// <summary>Container for nested types declared in the SessionLog message type.</summary>

  1256.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1257.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1258.     public static partial class Types {

  1259.       public enum SessionStatus {

  1260.         [pbr::OriginalName("STATUS_UNSPECIFIED")] StatusUnspecified = 0,

  1261.         [pbr::OriginalName("START")] Start = 1,

  1262.         [pbr::OriginalName("STOP")] Stop = 2,

  1263.         [pbr::OriginalName("CHECKPOINT")] Checkpoint = 3,

  1264.       }

  1265. 

  1266.     }

  1267.     #endregion

  1268. 

  1269.   }

  1270. 

  1271.   /// <summary>

  1272.   /// For logging the metadata output for a single session.run() call.

  1273.   /// </summary>

  1274.   public sealed partial class TaggedRunMetadata : pb::IMessage<TaggedRunMetadata>

  1275.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1276.       , pb::IBufferMessage

  1277.   #endif

  1278.   {

  1279.     private static readonly pb::MessageParser<TaggedRunMetadata> _parser = new pb::MessageParser<TaggedRunMetadata>(() => new TaggedRunMetadata());

  1280.     private pb::UnknownFieldSet _unknownFields;

  1281.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1282.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1283.     public static pb::MessageParser<TaggedRunMetadata> Parser { get { return _parser; } }

  1284. 

  1285.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1286.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1287.     public static pbr::MessageDescriptor Descriptor {

  1288.       get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[3]; }

  1289.     }

  1290. 

  1291.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1292.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1293.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1294.       get { return Descriptor; }

  1295.     }

  1296. 

  1297.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1298.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1299.     public TaggedRunMetadata() {

  1300.       OnConstruction();

  1301.     }

  1302. 

  1303.     partial void OnConstruction();

  1304. 

  1305.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1306.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1307.     public TaggedRunMetadata(TaggedRunMetadata other) : this() {

  1308.       tag_ = other.tag_;

  1309.       runMetadata_ = other.runMetadata_;

  1310.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  1311.     }

  1312. 

  1313.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1314.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1315.     public TaggedRunMetadata Clone() {

  1316.       return new TaggedRunMetadata(this);

  1317.     }

  1318. 

  1319.     /// <summary>Field number for the "tag" field.</summary>

  1320.     public const int TagFieldNumber = 1;

  1321.     private string tag_ = "";

  1322.     /// <summary>

  1323.     /// Tag name associated with this metadata.

  1324.     /// </summary>

  1325.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1326.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1327.     public string Tag {

  1328.       get { return tag_; }

  1329.       set {

  1330.         tag_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  1331.       }

  1332.     }

  1333. 

  1334.     /// <summary>Field number for the "run_metadata" field.</summary>

  1335.     public const int RunMetadataFieldNumber = 2;

  1336.     private pb::ByteString runMetadata_ = pb::ByteString.Empty;

  1337.     /// <summary>

  1338.     /// Byte-encoded version of the `RunMetadata` proto in order to allow lazy

  1339.     /// deserialization.

  1340.     /// </summary>

  1341.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1342.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1343.     public pb::ByteString RunMetadata {

  1344.       get { return runMetadata_; }

  1345.       set {

  1346.         runMetadata_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  1347.       }

  1348.     }

  1349. 

  1350.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1351.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1352.     public override bool Equals(object other) {

  1353.       return Equals(other as TaggedRunMetadata);

  1354.     }

  1355. 

  1356.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1357.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1358.     public bool Equals(TaggedRunMetadata other) {

  1359.       if (ReferenceEquals(other, null)) {

  1360.         return false;

  1361.       }

  1362.       if (ReferenceEquals(other, this)) {

  1363.         return true;

  1364.       }

  1365.       if (Tag != other.Tag) return false;

  1366.       if (RunMetadata != other.RunMetadata) return false;

  1367.       return Equals(_unknownFields, other._unknownFields);

  1368.     }

  1369. 

  1370.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1371.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1372.     public override int GetHashCode() {

  1373.       int hash = 1;

  1374.       if (Tag.Length != 0) hash ^= Tag.GetHashCode();

  1375.       if (RunMetadata.Length != 0) hash ^= RunMetadata.GetHashCode();

  1376.       if (_unknownFields != null) {

  1377.         hash ^= _unknownFields.GetHashCode();

  1378.       }

  1379.       return hash;

  1380.     }

  1381. 

  1382.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1383.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1384.     public override string ToString() {

  1385.       return pb::JsonFormatter.ToDiagnosticString(this);

  1386.     }

  1387. 

  1388.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1389.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1390.     public void WriteTo(pb::CodedOutputStream output) {

  1391.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1392.       output.WriteRawMessage(this);

  1393.     #else

  1394.       if (Tag.Length != 0) {

  1395.         output.WriteRawTag(10);

  1396.         output.WriteString(Tag);

  1397.       }

  1398.       if (RunMetadata.Length != 0) {

  1399.         output.WriteRawTag(18);

  1400.         output.WriteBytes(RunMetadata);

  1401.       }

  1402.       if (_unknownFields != null) {

  1403.         _unknownFields.WriteTo(output);

  1404.       }

  1405.     #endif

  1406.     }

  1407. 

  1408.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1409.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1410.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1411.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  1412.       if (Tag.Length != 0) {

  1413.         output.WriteRawTag(10);

  1414.         output.WriteString(Tag);

  1415.       }

  1416.       if (RunMetadata.Length != 0) {

  1417.         output.WriteRawTag(18);

  1418.         output.WriteBytes(RunMetadata);

  1419.       }

  1420.       if (_unknownFields != null) {

  1421.         _unknownFields.WriteTo(ref output);

  1422.       }

  1423.     }

  1424.     #endif

  1425. 

  1426.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1427.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1428.     public int CalculateSize() {

  1429.       int size = 0;

  1430.       if (Tag.Length != 0) {

  1431.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Tag);

  1432.       }

  1433.       if (RunMetadata.Length != 0) {

  1434.         size += 1 + pb::CodedOutputStream.ComputeBytesSize(RunMetadata);

  1435.       }

  1436.       if (_unknownFields != null) {

  1437.         size += _unknownFields.CalculateSize();

  1438.       }

  1439.       return size;

  1440.     }

  1441. 

  1442.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1443.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1444.     public void MergeFrom(TaggedRunMetadata other) {

  1445.       if (other == null) {

  1446.         return;

  1447.       }

  1448.       if (other.Tag.Length != 0) {

  1449.         Tag = other.Tag;

  1450.       }

  1451.       if (other.RunMetadata.Length != 0) {

  1452.         RunMetadata = other.RunMetadata;

  1453.       }

  1454.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  1455.     }

  1456. 

  1457.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1458.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1459.     public void MergeFrom(pb::CodedInputStream input) {

  1460.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1461.       input.ReadRawMessage(this);

  1462.     #else

  1463.       uint tag;

  1464.       while ((tag = input.ReadTag()) != 0) {

  1465.         switch(tag) {

  1466.           default:

  1467.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1468.             break;

  1469.           case 10: {

  1470.             Tag = input.ReadString();

  1471.             break;

  1472.           }

  1473.           case 18: {

  1474.             RunMetadata = input.ReadBytes();

  1475.             break;

  1476.           }

  1477.         }

  1478.       }

  1479.     #endif

  1480.     }

  1481. 

  1482.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1483.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1484.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1485.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  1486.       uint tag;

  1487.       while ((tag = input.ReadTag()) != 0) {

  1488.         switch(tag) {

  1489.           default:

  1490.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  1491.             break;

  1492.           case 10: {

  1493.             Tag = input.ReadString();

  1494.             break;

  1495.           }

  1496.           case 18: {

  1497.             RunMetadata = input.ReadBytes();

  1498.             break;

  1499.           }

  1500.         }

  1501.       }

  1502.     }

  1503.     #endif

  1504. 

  1505.   }

  1506. 

  1507.   public sealed partial class WatchdogConfig : pb::IMessage<WatchdogConfig>

  1508.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1509.       , pb::IBufferMessage

  1510.   #endif

  1511.   {

  1512.     private static readonly pb::MessageParser<WatchdogConfig> _parser = new pb::MessageParser<WatchdogConfig>(() => new WatchdogConfig());

  1513.     private pb::UnknownFieldSet _unknownFields;

  1514.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1515.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1516.     public static pb::MessageParser<WatchdogConfig> Parser { get { return _parser; } }

  1517. 

  1518.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1519.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1520.     public static pbr::MessageDescriptor Descriptor {

  1521.       get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[4]; }

  1522.     }

  1523. 

  1524.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1525.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1526.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1527.       get { return Descriptor; }

  1528.     }

  1529. 

  1530.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1531.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1532.     public WatchdogConfig() {

  1533.       OnConstruction();

  1534.     }

  1535. 

  1536.     partial void OnConstruction();

  1537. 

  1538.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1539.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1540.     public WatchdogConfig(WatchdogConfig other) : this() {

  1541.       timeoutMs_ = other.timeoutMs_;

  1542.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  1543.     }

  1544. 

  1545.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1546.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1547.     public WatchdogConfig Clone() {

  1548.       return new WatchdogConfig(this);

  1549.     }

  1550. 

  1551.     /// <summary>Field number for the "timeout_ms" field.</summary>

  1552.     public const int TimeoutMsFieldNumber = 1;

  1553.     private long timeoutMs_;

  1554.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1555.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1556.     public long TimeoutMs {

  1557.       get { return timeoutMs_; }

  1558.       set {

  1559.         timeoutMs_ = value;

  1560.       }

  1561.     }

  1562. 

  1563.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1564.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1565.     public override bool Equals(object other) {

  1566.       return Equals(other as WatchdogConfig);

  1567.     }

  1568. 

  1569.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1570.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1571.     public bool Equals(WatchdogConfig other) {

  1572.       if (ReferenceEquals(other, null)) {

  1573.         return false;

  1574.       }

  1575.       if (ReferenceEquals(other, this)) {

  1576.         return true;

  1577.       }

  1578.       if (TimeoutMs != other.TimeoutMs) return false;

  1579.       return Equals(_unknownFields, other._unknownFields);

  1580.     }

  1581. 

  1582.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1583.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1584.     public override int GetHashCode() {

  1585.       int hash = 1;

  1586.       if (TimeoutMs != 0L) hash ^= TimeoutMs.GetHashCode();

  1587.       if (_unknownFields != null) {

  1588.         hash ^= _unknownFields.GetHashCode();

  1589.       }

  1590.       return hash;

  1591.     }

  1592. 

  1593.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1594.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1595.     public override string ToString() {

  1596.       return pb::JsonFormatter.ToDiagnosticString(this);

  1597.     }

  1598. 

  1599.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1600.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1601.     public void WriteTo(pb::CodedOutputStream output) {

  1602.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1603.       output.WriteRawMessage(this);

  1604.     #else

  1605.       if (TimeoutMs != 0L) {

  1606.         output.WriteRawTag(8);

  1607.         output.WriteInt64(TimeoutMs);

  1608.       }

  1609.       if (_unknownFields != null) {

  1610.         _unknownFields.WriteTo(output);

  1611.       }

  1612.     #endif

  1613.     }

  1614. 

  1615.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1616.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1617.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1618.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  1619.       if (TimeoutMs != 0L) {

  1620.         output.WriteRawTag(8);

  1621.         output.WriteInt64(TimeoutMs);

  1622.       }

  1623.       if (_unknownFields != null) {

  1624.         _unknownFields.WriteTo(ref output);

  1625.       }

  1626.     }

  1627.     #endif

  1628. 

  1629.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1630.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1631.     public int CalculateSize() {

  1632.       int size = 0;

  1633.       if (TimeoutMs != 0L) {

  1634.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(TimeoutMs);

  1635.       }

  1636.       if (_unknownFields != null) {

  1637.         size += _unknownFields.CalculateSize();

  1638.       }

  1639.       return size;

  1640.     }

  1641. 

  1642.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1643.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1644.     public void MergeFrom(WatchdogConfig other) {

  1645.       if (other == null) {

  1646.         return;

  1647.       }

  1648.       if (other.TimeoutMs != 0L) {

  1649.         TimeoutMs = other.TimeoutMs;

  1650.       }

  1651.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  1652.     }

  1653. 

  1654.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1655.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1656.     public void MergeFrom(pb::CodedInputStream input) {

  1657.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1658.       input.ReadRawMessage(this);

  1659.     #else

  1660.       uint tag;

  1661.       while ((tag = input.ReadTag()) != 0) {

  1662.         switch(tag) {

  1663.           default:

  1664.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1665.             break;

  1666.           case 8: {

  1667.             TimeoutMs = input.ReadInt64();

  1668.             break;

  1669.           }

  1670.         }

  1671.       }

  1672.     #endif

  1673.     }

  1674. 

  1675.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1676.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1677.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1678.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  1679.       uint tag;

  1680.       while ((tag = input.ReadTag()) != 0) {

  1681.         switch(tag) {

  1682.           default:

  1683.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  1684.             break;

  1685.           case 8: {

  1686.             TimeoutMs = input.ReadInt64();

  1687.             break;

  1688.           }

  1689.         }

  1690.       }

  1691.     }

  1692.     #endif

  1693. 

  1694.   }

  1695. 

  1696.   public sealed partial class RequestedExitCode : pb::IMessage<RequestedExitCode>

  1697.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1698.       , pb::IBufferMessage

  1699.   #endif

  1700.   {

  1701.     private static readonly pb::MessageParser<RequestedExitCode> _parser = new pb::MessageParser<RequestedExitCode>(() => new RequestedExitCode());

  1702.     private pb::UnknownFieldSet _unknownFields;

  1703.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1704.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1705.     public static pb::MessageParser<RequestedExitCode> Parser { get { return _parser; } }

  1706. 

  1707.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1708.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1709.     public static pbr::MessageDescriptor Descriptor {

  1710.       get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[5]; }

  1711.     }

  1712. 

  1713.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1714.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1715.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1716.       get { return Descriptor; }

  1717.     }

  1718. 

  1719.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1720.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1721.     public RequestedExitCode() {

  1722.       OnConstruction();

  1723.     }

  1724. 

  1725.     partial void OnConstruction();

  1726. 

  1727.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1728.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1729.     public RequestedExitCode(RequestedExitCode other) : this() {

  1730.       exitCode_ = other.exitCode_;

  1731.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  1732.     }

  1733. 

  1734.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1735.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1736.     public RequestedExitCode Clone() {

  1737.       return new RequestedExitCode(this);

  1738.     }

  1739. 

  1740.     /// <summary>Field number for the "exit_code" field.</summary>

  1741.     public const int ExitCodeFieldNumber = 1;

  1742.     private int exitCode_;

  1743.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1744.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1745.     public int ExitCode {

  1746.       get { return exitCode_; }

  1747.       set {

  1748.         exitCode_ = value;

  1749.       }

  1750.     }

  1751. 

  1752.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1753.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1754.     public override bool Equals(object other) {

  1755.       return Equals(other as RequestedExitCode);

  1756.     }

  1757. 

  1758.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1759.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1760.     public bool Equals(RequestedExitCode other) {

  1761.       if (ReferenceEquals(other, null)) {

  1762.         return false;

  1763.       }

  1764.       if (ReferenceEquals(other, this)) {

  1765.         return true;

  1766.       }

  1767.       if (ExitCode != other.ExitCode) return false;

  1768.       return Equals(_unknownFields, other._unknownFields);

  1769.     }

  1770. 

  1771.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1772.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1773.     public override int GetHashCode() {

  1774.       int hash = 1;

  1775.       if (ExitCode != 0) hash ^= ExitCode.GetHashCode();

  1776.       if (_unknownFields != null) {

  1777.         hash ^= _unknownFields.GetHashCode();

  1778.       }

  1779.       return hash;

  1780.     }

  1781. 

  1782.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1783.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1784.     public override string ToString() {

  1785.       return pb::JsonFormatter.ToDiagnosticString(this);

  1786.     }

  1787. 

  1788.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1789.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1790.     public void WriteTo(pb::CodedOutputStream output) {

  1791.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1792.       output.WriteRawMessage(this);

  1793.     #else

  1794.       if (ExitCode != 0) {

  1795.         output.WriteRawTag(8);

  1796.         output.WriteInt32(ExitCode);

  1797.       }

  1798.       if (_unknownFields != null) {

  1799.         _unknownFields.WriteTo(output);

  1800.       }

  1801.     #endif

  1802.     }

  1803. 

  1804.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1805.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1806.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1807.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  1808.       if (ExitCode != 0) {

  1809.         output.WriteRawTag(8);

  1810.         output.WriteInt32(ExitCode);

  1811.       }

  1812.       if (_unknownFields != null) {

  1813.         _unknownFields.WriteTo(ref output);

  1814.       }

  1815.     }

  1816.     #endif

  1817. 

  1818.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1819.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1820.     public int CalculateSize() {

  1821.       int size = 0;

  1822.       if (ExitCode != 0) {

  1823.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(ExitCode);

  1824.       }

  1825.       if (_unknownFields != null) {

  1826.         size += _unknownFields.CalculateSize();

  1827.       }

  1828.       return size;

  1829.     }

  1830. 

  1831.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1832.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1833.     public void MergeFrom(RequestedExitCode other) {

  1834.       if (other == null) {

  1835.         return;

  1836.       }

  1837.       if (other.ExitCode != 0) {

  1838.         ExitCode = other.ExitCode;

  1839.       }

  1840.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  1841.     }

  1842. 

  1843.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1844.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1845.     public void MergeFrom(pb::CodedInputStream input) {

  1846.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1847.       input.ReadRawMessage(this);

  1848.     #else

  1849.       uint tag;

  1850.       while ((tag = input.ReadTag()) != 0) {

  1851.         switch(tag) {

  1852.           default:

  1853.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1854.             break;

  1855.           case 8: {

  1856.             ExitCode = input.ReadInt32();

  1857.             break;

  1858.           }

  1859.         }

  1860.       }

  1861.     #endif

  1862.     }

  1863. 

  1864.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1865.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1866.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1867.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  1868.       uint tag;

  1869.       while ((tag = input.ReadTag()) != 0) {

  1870.         switch(tag) {

  1871.           default:

  1872.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  1873.             break;

  1874.           case 8: {

  1875.             ExitCode = input.ReadInt32();

  1876.             break;

  1877.           }

  1878.         }

  1879.       }

  1880.     }

  1881.     #endif

  1882. 

  1883.   }

  1884. 

  1885.   public sealed partial class WorkerHeartbeatRequest : pb::IMessage<WorkerHeartbeatRequest>

  1886.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1887.       , pb::IBufferMessage

  1888.   #endif

  1889.   {

  1890.     private static readonly pb::MessageParser<WorkerHeartbeatRequest> _parser = new pb::MessageParser<WorkerHeartbeatRequest>(() => new WorkerHeartbeatRequest());

  1891.     private pb::UnknownFieldSet _unknownFields;

  1892.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1893.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1894.     public static pb::MessageParser<WorkerHeartbeatRequest> Parser { get { return _parser; } }

  1895. 

  1896.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1897.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1898.     public static pbr::MessageDescriptor Descriptor {

  1899.       get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[6]; }

  1900.     }

  1901. 

  1902.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1903.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1904.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1905.       get { return Descriptor; }

  1906.     }

  1907. 

  1908.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1909.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1910.     public WorkerHeartbeatRequest() {

  1911.       OnConstruction();

  1912.     }

  1913. 

  1914.     partial void OnConstruction();

  1915. 

  1916.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1917.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1918.     public WorkerHeartbeatRequest(WorkerHeartbeatRequest other) : this() {

  1919.       shutdownMode_ = other.shutdownMode_;

  1920.       watchdogConfig_ = other.watchdogConfig_ != null ? other.watchdogConfig_.Clone() : null;

  1921.       exitCode_ = other.exitCode_ != null ? other.exitCode_.Clone() : null;

  1922.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  1923.     }

  1924. 

  1925.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1926.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1927.     public WorkerHeartbeatRequest Clone() {

  1928.       return new WorkerHeartbeatRequest(this);

  1929.     }

  1930. 

  1931.     /// <summary>Field number for the "shutdown_mode" field.</summary>

  1932.     public const int ShutdownModeFieldNumber = 1;

  1933.     private global::Tensorflow.WorkerShutdownMode shutdownMode_ = global::Tensorflow.WorkerShutdownMode.Default;

  1934.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1935.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1936.     public global::Tensorflow.WorkerShutdownMode ShutdownMode {

  1937.       get { return shutdownMode_; }

  1938.       set {

  1939.         shutdownMode_ = value;

  1940.       }

  1941.     }

  1942. 

  1943.     /// <summary>Field number for the "watchdog_config" field.</summary>

  1944.     public const int WatchdogConfigFieldNumber = 2;

  1945.     private global::Tensorflow.WatchdogConfig watchdogConfig_;

  1946.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1947.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1948.     public global::Tensorflow.WatchdogConfig WatchdogConfig {

  1949.       get { return watchdogConfig_; }

  1950.       set {

  1951.         watchdogConfig_ = value;

  1952.       }

  1953.     }

  1954. 

  1955.     /// <summary>Field number for the "exit_code" field.</summary>

  1956.     public const int ExitCodeFieldNumber = 3;

  1957.     private global::Tensorflow.RequestedExitCode exitCode_;

  1958.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1959.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1960.     public global::Tensorflow.RequestedExitCode ExitCode {

  1961.       get { return exitCode_; }

  1962.       set {

  1963.         exitCode_ = value;

  1964.       }

  1965.     }

  1966. 

  1967.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1968.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1969.     public override bool Equals(object other) {

  1970.       return Equals(other as WorkerHeartbeatRequest);

  1971.     }

  1972. 

  1973.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1974.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1975.     public bool Equals(WorkerHeartbeatRequest other) {

  1976.       if (ReferenceEquals(other, null)) {

  1977.         return false;

  1978.       }

  1979.       if (ReferenceEquals(other, this)) {

  1980.         return true;

  1981.       }

  1982.       if (ShutdownMode != other.ShutdownMode) return false;

  1983.       if (!object.Equals(WatchdogConfig, other.WatchdogConfig)) return false;

  1984.       if (!object.Equals(ExitCode, other.ExitCode)) return false;

  1985.       return Equals(_unknownFields, other._unknownFields);

  1986.     }

  1987. 

  1988.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1989.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1990.     public override int GetHashCode() {

  1991.       int hash = 1;

  1992.       if (ShutdownMode != global::Tensorflow.WorkerShutdownMode.Default) hash ^= ShutdownMode.GetHashCode();

  1993.       if (watchdogConfig_ != null) hash ^= WatchdogConfig.GetHashCode();

  1994.       if (exitCode_ != null) hash ^= ExitCode.GetHashCode();

  1995.       if (_unknownFields != null) {

  1996.         hash ^= _unknownFields.GetHashCode();

  1997.       }

  1998.       return hash;

  1999.     }

  2000. 

  2001.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2002.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2003.     public override string ToString() {

  2004.       return pb::JsonFormatter.ToDiagnosticString(this);

  2005.     }

  2006. 

  2007.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2008.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2009.     public void WriteTo(pb::CodedOutputStream output) {

  2010.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2011.       output.WriteRawMessage(this);

  2012.     #else

  2013.       if (ShutdownMode != global::Tensorflow.WorkerShutdownMode.Default) {

  2014.         output.WriteRawTag(8);

  2015.         output.WriteEnum((int) ShutdownMode);

  2016.       }

  2017.       if (watchdogConfig_ != null) {

  2018.         output.WriteRawTag(18);

  2019.         output.WriteMessage(WatchdogConfig);

  2020.       }

  2021.       if (exitCode_ != null) {

  2022.         output.WriteRawTag(26);

  2023.         output.WriteMessage(ExitCode);

  2024.       }

  2025.       if (_unknownFields != null) {

  2026.         _unknownFields.WriteTo(output);

  2027.       }

  2028.     #endif

  2029.     }

  2030. 

  2031.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2032.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2033.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2034.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  2035.       if (ShutdownMode != global::Tensorflow.WorkerShutdownMode.Default) {

  2036.         output.WriteRawTag(8);

  2037.         output.WriteEnum((int) ShutdownMode);

  2038.       }

  2039.       if (watchdogConfig_ != null) {

  2040.         output.WriteRawTag(18);

  2041.         output.WriteMessage(WatchdogConfig);

  2042.       }

  2043.       if (exitCode_ != null) {

  2044.         output.WriteRawTag(26);

  2045.         output.WriteMessage(ExitCode);

  2046.       }

  2047.       if (_unknownFields != null) {

  2048.         _unknownFields.WriteTo(ref output);

  2049.       }

  2050.     }

  2051.     #endif

  2052. 

  2053.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2054.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2055.     public int CalculateSize() {

  2056.       int size = 0;

  2057.       if (ShutdownMode != global::Tensorflow.WorkerShutdownMode.Default) {

  2058.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) ShutdownMode);

  2059.       }

  2060.       if (watchdogConfig_ != null) {

  2061.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(WatchdogConfig);

  2062.       }

  2063.       if (exitCode_ != null) {

  2064.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(ExitCode);

  2065.       }

  2066.       if (_unknownFields != null) {

  2067.         size += _unknownFields.CalculateSize();

  2068.       }

  2069.       return size;

  2070.     }

  2071. 

  2072.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2073.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2074.     public void MergeFrom(WorkerHeartbeatRequest other) {

  2075.       if (other == null) {

  2076.         return;

  2077.       }

  2078.       if (other.ShutdownMode != global::Tensorflow.WorkerShutdownMode.Default) {

  2079.         ShutdownMode = other.ShutdownMode;

  2080.       }

  2081.       if (other.watchdogConfig_ != null) {

  2082.         if (watchdogConfig_ == null) {

  2083.           WatchdogConfig = new global::Tensorflow.WatchdogConfig();

  2084.         }

  2085.         WatchdogConfig.MergeFrom(other.WatchdogConfig);

  2086.       }

  2087.       if (other.exitCode_ != null) {

  2088.         if (exitCode_ == null) {

  2089.           ExitCode = new global::Tensorflow.RequestedExitCode();

  2090.         }

  2091.         ExitCode.MergeFrom(other.ExitCode);

  2092.       }

  2093.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  2094.     }

  2095. 

  2096.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2097.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2098.     public void MergeFrom(pb::CodedInputStream input) {

  2099.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2100.       input.ReadRawMessage(this);

  2101.     #else

  2102.       uint tag;

  2103.       while ((tag = input.ReadTag()) != 0) {

  2104.         switch(tag) {

  2105.           default:

  2106.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  2107.             break;

  2108.           case 8: {

  2109.             ShutdownMode = (global::Tensorflow.WorkerShutdownMode) input.ReadEnum();

  2110.             break;

  2111.           }

  2112.           case 18: {

  2113.             if (watchdogConfig_ == null) {

  2114.               WatchdogConfig = new global::Tensorflow.WatchdogConfig();

  2115.             }

  2116.             input.ReadMessage(WatchdogConfig);

  2117.             break;

  2118.           }

  2119.           case 26: {

  2120.             if (exitCode_ == null) {

  2121.               ExitCode = new global::Tensorflow.RequestedExitCode();

  2122.             }

  2123.             input.ReadMessage(ExitCode);

  2124.             break;

  2125.           }

  2126.         }

  2127.       }

  2128.     #endif

  2129.     }

  2130. 

  2131.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2132.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2133.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2134.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  2135.       uint tag;

  2136.       while ((tag = input.ReadTag()) != 0) {

  2137.         switch(tag) {

  2138.           default:

  2139.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  2140.             break;

  2141.           case 8: {

  2142.             ShutdownMode = (global::Tensorflow.WorkerShutdownMode) input.ReadEnum();

  2143.             break;

  2144.           }

  2145.           case 18: {

  2146.             if (watchdogConfig_ == null) {

  2147.               WatchdogConfig = new global::Tensorflow.WatchdogConfig();

  2148.             }

  2149.             input.ReadMessage(WatchdogConfig);

  2150.             break;

  2151.           }

  2152.           case 26: {

  2153.             if (exitCode_ == null) {

  2154.               ExitCode = new global::Tensorflow.RequestedExitCode();

  2155.             }

  2156.             input.ReadMessage(ExitCode);

  2157.             break;

  2158.           }

  2159.         }

  2160.       }

  2161.     }

  2162.     #endif

  2163. 

  2164.   }

  2165. 

  2166.   public sealed partial class WorkerHeartbeatResponse : pb::IMessage<WorkerHeartbeatResponse>

  2167.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2168.       , pb::IBufferMessage

  2169.   #endif

  2170.   {

  2171.     private static readonly pb::MessageParser<WorkerHeartbeatResponse> _parser = new pb::MessageParser<WorkerHeartbeatResponse>(() => new WorkerHeartbeatResponse());

  2172.     private pb::UnknownFieldSet _unknownFields;

  2173.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2174.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2175.     public static pb::MessageParser<WorkerHeartbeatResponse> Parser { get { return _parser; } }

  2176. 

  2177.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2178.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2179.     public static pbr::MessageDescriptor Descriptor {

  2180.       get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[7]; }

  2181.     }

  2182. 

  2183.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2184.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2185.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  2186.       get { return Descriptor; }

  2187.     }

  2188. 

  2189.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2190.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2191.     public WorkerHeartbeatResponse() {

  2192.       OnConstruction();

  2193.     }

  2194. 

  2195.     partial void OnConstruction();

  2196. 

  2197.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2198.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2199.     public WorkerHeartbeatResponse(WorkerHeartbeatResponse other) : this() {

  2200.       healthStatus_ = other.healthStatus_;

  2201.       workerLog_ = other.workerLog_.Clone();

  2202.       hostname_ = other.hostname_;

  2203.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  2204.     }

  2205. 

  2206.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2207.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2208.     public WorkerHeartbeatResponse Clone() {

  2209.       return new WorkerHeartbeatResponse(this);

  2210.     }

  2211. 

  2212.     /// <summary>Field number for the "health_status" field.</summary>

  2213.     public const int HealthStatusFieldNumber = 1;

  2214.     private global::Tensorflow.WorkerHealth healthStatus_ = global::Tensorflow.WorkerHealth.Ok;

  2215.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2216.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2217.     public global::Tensorflow.WorkerHealth HealthStatus {

  2218.       get { return healthStatus_; }

  2219.       set {

  2220.         healthStatus_ = value;

  2221.       }

  2222.     }

  2223. 

  2224.     /// <summary>Field number for the "worker_log" field.</summary>

  2225.     public const int WorkerLogFieldNumber = 2;

  2226.     private static readonly pb::FieldCodec<global::Tensorflow.Event> _repeated_workerLog_codec

  2227.         = pb::FieldCodec.ForMessage(18, global::Tensorflow.Event.Parser);

  2228.     private readonly pbc::RepeatedField<global::Tensorflow.Event> workerLog_ = new pbc::RepeatedField<global::Tensorflow.Event>();

  2229.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2230.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2231.     public pbc::RepeatedField<global::Tensorflow.Event> WorkerLog {

  2232.       get { return workerLog_; }

  2233.     }

  2234. 

  2235.     /// <summary>Field number for the "hostname" field.</summary>

  2236.     public const int HostnameFieldNumber = 3;

  2237.     private string hostname_ = "";

  2238.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2239.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2240.     public string Hostname {

  2241.       get { return hostname_; }

  2242.       set {

  2243.         hostname_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  2244.       }

  2245.     }

  2246. 

  2247.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2248.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2249.     public override bool Equals(object other) {

  2250.       return Equals(other as WorkerHeartbeatResponse);

  2251.     }

  2252. 

  2253.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2254.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2255.     public bool Equals(WorkerHeartbeatResponse other) {

  2256.       if (ReferenceEquals(other, null)) {

  2257.         return false;

  2258.       }

  2259.       if (ReferenceEquals(other, this)) {

  2260.         return true;

  2261.       }

  2262.       if (HealthStatus != other.HealthStatus) return false;

  2263.       if(!workerLog_.Equals(other.workerLog_)) return false;

  2264.       if (Hostname != other.Hostname) return false;

  2265.       return Equals(_unknownFields, other._unknownFields);

  2266.     }

  2267. 

  2268.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2269.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2270.     public override int GetHashCode() {

  2271.       int hash = 1;

  2272.       if (HealthStatus != global::Tensorflow.WorkerHealth.Ok) hash ^= HealthStatus.GetHashCode();

  2273.       hash ^= workerLog_.GetHashCode();

  2274.       if (Hostname.Length != 0) hash ^= Hostname.GetHashCode();

  2275.       if (_unknownFields != null) {

  2276.         hash ^= _unknownFields.GetHashCode();

  2277.       }

  2278.       return hash;

  2279.     }

  2280. 

  2281.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2282.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2283.     public override string ToString() {

  2284.       return pb::JsonFormatter.ToDiagnosticString(this);

  2285.     }

  2286. 

  2287.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2288.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2289.     public void WriteTo(pb::CodedOutputStream output) {

  2290.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2291.       output.WriteRawMessage(this);

  2292.     #else

  2293.       if (HealthStatus != global::Tensorflow.WorkerHealth.Ok) {

  2294.         output.WriteRawTag(8);

  2295.         output.WriteEnum((int) HealthStatus);

  2296.       }

  2297.       workerLog_.WriteTo(output, _repeated_workerLog_codec);

  2298.       if (Hostname.Length != 0) {

  2299.         output.WriteRawTag(26);

  2300.         output.WriteString(Hostname);

  2301.       }

  2302.       if (_unknownFields != null) {

  2303.         _unknownFields.WriteTo(output);

  2304.       }

  2305.     #endif

  2306.     }

  2307. 

  2308.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2309.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2310.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2311.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  2312.       if (HealthStatus != global::Tensorflow.WorkerHealth.Ok) {

  2313.         output.WriteRawTag(8);

  2314.         output.WriteEnum((int) HealthStatus);

  2315.       }

  2316.       workerLog_.WriteTo(ref output, _repeated_workerLog_codec);

  2317.       if (Hostname.Length != 0) {

  2318.         output.WriteRawTag(26);

  2319.         output.WriteString(Hostname);

  2320.       }

  2321.       if (_unknownFields != null) {

  2322.         _unknownFields.WriteTo(ref output);

  2323.       }

  2324.     }

  2325.     #endif

  2326. 

  2327.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2328.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2329.     public int CalculateSize() {

  2330.       int size = 0;

  2331.       if (HealthStatus != global::Tensorflow.WorkerHealth.Ok) {

  2332.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) HealthStatus);

  2333.       }

  2334.       size += workerLog_.CalculateSize(_repeated_workerLog_codec);

  2335.       if (Hostname.Length != 0) {

  2336.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Hostname);

  2337.       }

  2338.       if (_unknownFields != null) {

  2339.         size += _unknownFields.CalculateSize();

  2340.       }

  2341.       return size;

  2342.     }

  2343. 

  2344.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2345.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2346.     public void MergeFrom(WorkerHeartbeatResponse other) {

  2347.       if (other == null) {

  2348.         return;

  2349.       }

  2350.       if (other.HealthStatus != global::Tensorflow.WorkerHealth.Ok) {

  2351.         HealthStatus = other.HealthStatus;

  2352.       }

  2353.       workerLog_.Add(other.workerLog_);

  2354.       if (other.Hostname.Length != 0) {

  2355.         Hostname = other.Hostname;

  2356.       }

  2357.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  2358.     }

  2359. 

  2360.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2361.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2362.     public void MergeFrom(pb::CodedInputStream input) {

  2363.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2364.       input.ReadRawMessage(this);

  2365.     #else

  2366.       uint tag;

  2367.       while ((tag = input.ReadTag()) != 0) {

  2368.         switch(tag) {

  2369.           default:

  2370.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  2371.             break;

  2372.           case 8: {

  2373.             HealthStatus = (global::Tensorflow.WorkerHealth) input.ReadEnum();

  2374.             break;

  2375.           }

  2376.           case 18: {

  2377.             workerLog_.AddEntriesFrom(input, _repeated_workerLog_codec);

  2378.             break;

  2379.           }

  2380.           case 26: {

  2381.             Hostname = input.ReadString();

  2382.             break;

  2383.           }

  2384.         }

  2385.       }

  2386.     #endif

  2387.     }

  2388. 

  2389.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2390.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2391.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2392.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  2393.       uint tag;

  2394.       while ((tag = input.ReadTag()) != 0) {

  2395.         switch(tag) {

  2396.           default:

  2397.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  2398.             break;

  2399.           case 8: {

  2400.             HealthStatus = (global::Tensorflow.WorkerHealth) input.ReadEnum();

  2401.             break;

  2402.           }

  2403.           case 18: {

  2404.             workerLog_.AddEntriesFrom(ref input, _repeated_workerLog_codec);

  2405.             break;

  2406.           }

  2407.           case 26: {

  2408.             Hostname = input.ReadString();

  2409.             break;

  2410.           }

  2411.         }

  2412.       }

  2413.     }

  2414.     #endif

  2415. 

  2416.   }

  2417. 

  2418.   #endregion

  2419. 

  2420. }

  2421. 

  2422. #endregion Designer generated code