TensorFlow.NET/src/TensorFlowNET.Core/Protobuf/Event.cs

// <auto-generated>
//     Generated by the protocol buffer compiler.  DO NOT EDIT!
//     source: tensorflow/core/util/event.proto
// </auto-generated>
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Tensorflow {

  /// <summary>Holder for reflection information generated from tensorflow/core/util/event.proto</summary>
  public static partial class EventReflection {

    #region Descriptor
    /// <summary>File descriptor for tensorflow/core/util/event.proto</summary>
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static EventReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "CiB0ZW5zb3JmbG93L2NvcmUvdXRpbC9ldmVudC5wcm90bxIKdGVuc29yZmxv",
            "dxondGVuc29yZmxvdy9jb3JlL2ZyYW1ld29yay9zdW1tYXJ5LnByb3RvIrsC",
            "CgVFdmVudBIRCgl3YWxsX3RpbWUYASABKAESDAoEc3RlcBgCIAEoAxIWCgxm",
            "aWxlX3ZlcnNpb24YAyABKAlIABITCglncmFwaF9kZWYYBCABKAxIABImCgdz",
            "dW1tYXJ5GAUgASgLMhMudGVuc29yZmxvdy5TdW1tYXJ5SAASLQoLbG9nX21l",
            "c3NhZ2UYBiABKAsyFi50ZW5zb3JmbG93LkxvZ01lc3NhZ2VIABItCgtzZXNz",
            "aW9uX2xvZxgHIAEoCzIWLnRlbnNvcmZsb3cuU2Vzc2lvbkxvZ0gAEjwKE3Rh",
            "Z2dlZF9ydW5fbWV0YWRhdGEYCCABKAsyHS50ZW5zb3JmbG93LlRhZ2dlZFJ1",
            "bk1ldGFkYXRhSAASGAoObWV0YV9ncmFwaF9kZWYYCSABKAxIAEIGCgR3aGF0",
            "IpkBCgpMb2dNZXNzYWdlEisKBWxldmVsGAEgASgOMhwudGVuc29yZmxvdy5M",
            "b2dNZXNzYWdlLkxldmVsEg8KB21lc3NhZ2UYAiABKAkiTQoFTGV2ZWwSCwoH",
            "VU5LTk9XThAAEg0KCURFQlVHR0lORxAKEggKBElORk8QFBIICgRXQVJOEB4S",
            "CQoFRVJST1IQKBIJCgVGQVRBTBAyIrYBCgpTZXNzaW9uTG9nEjQKBnN0YXR1",
            "cxgBIAEoDjIkLnRlbnNvcmZsb3cuU2Vzc2lvbkxvZy5TZXNzaW9uU3RhdHVz",
            "EhcKD2NoZWNrcG9pbnRfcGF0aBgCIAEoCRILCgNtc2cYAyABKAkiTAoNU2Vz",
            "c2lvblN0YXR1cxIWChJTVEFUVVNfVU5TUEVDSUZJRUQQABIJCgVTVEFSVBAB",
            "EggKBFNUT1AQAhIOCgpDSEVDS1BPSU5UEAMiNgoRVGFnZ2VkUnVuTWV0YWRh",
            "dGESCwoDdGFnGAEgASgJEhQKDHJ1bl9tZXRhZGF0YRgCIAEoDCIkCg5XYXRj",
            "aGRvZ0NvbmZpZxISCgp0aW1lb3V0X21zGAEgASgDIiYKEVJlcXVlc3RlZEV4",
            "aXRDb2RlEhEKCWV4aXRfY29kZRgBIAEoBSK2AQoWV29ya2VySGVhcnRiZWF0",
            "UmVxdWVzdBI1Cg1zaHV0ZG93bl9tb2RlGAEgASgOMh4udGVuc29yZmxvdy5X",
            "b3JrZXJTaHV0ZG93bk1vZGUSMwoPd2F0Y2hkb2dfY29uZmlnGAIgASgLMhou",
            "dGVuc29yZmxvdy5XYXRjaGRvZ0NvbmZpZxIwCglleGl0X2NvZGUYAyABKAsy",
            "HS50ZW5zb3JmbG93LlJlcXVlc3RlZEV4aXRDb2RlIoMBChdXb3JrZXJIZWFy",
            "dGJlYXRSZXNwb25zZRIvCg1oZWFsdGhfc3RhdHVzGAEgASgOMhgudGVuc29y",
            "Zmxvdy5Xb3JrZXJIZWFsdGgSJQoKd29ya2VyX2xvZxgCIAMoCzIRLnRlbnNv",
            "cmZsb3cuRXZlbnQSEAoIaG9zdG5hbWUYAyABKAkqWwoMV29ya2VySGVhbHRo",
            "EgYKAk9LEAASHAoYUkVDRUlWRURfU0hVVERPV05fU0lHTkFMEAESEgoOSU5U",
            "RVJOQUxfRVJST1IQAhIRCg1TSFVUVElOR19ET1dOEAMqawoSV29ya2VyU2h1",
            "dGRvd25Nb2RlEgsKB0RFRkFVTFQQABISCg5OT1RfQ09ORklHVVJFRBABEhgK",
            "FFdBSVRfRk9SX0NPT1JESU5BVE9SEAISGgoWU0hVVERPV05fQUZURVJfVElN",
            "RU9VVBADQicKE29yZy50ZW5zb3JmbG93LnV0aWxCC0V2ZW50UHJvdG9zUAH4",
            "AQFiBnByb3RvMw=="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { global::Tensorflow.SummaryReflection.Descriptor, },
          new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Tensorflow.WorkerHealth), typeof(global::Tensorflow.WorkerShutdownMode), }, null, new pbr::GeneratedClrTypeInfo[] {
            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),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.LogMessage), global::Tensorflow.LogMessage.Parser, new[]{ "Level", "Message" }, null, new[]{ typeof(global::Tensorflow.LogMessage.Types.Level) }, null, null),
            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),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.TaggedRunMetadata), global::Tensorflow.TaggedRunMetadata.Parser, new[]{ "Tag", "RunMetadata" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.WatchdogConfig), global::Tensorflow.WatchdogConfig.Parser, new[]{ "TimeoutMs" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.RequestedExitCode), global::Tensorflow.RequestedExitCode.Parser, new[]{ "ExitCode" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.WorkerHeartbeatRequest), global::Tensorflow.WorkerHeartbeatRequest.Parser, new[]{ "ShutdownMode", "WatchdogConfig", "ExitCode" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.WorkerHeartbeatResponse), global::Tensorflow.WorkerHeartbeatResponse.Parser, new[]{ "HealthStatus", "WorkerLog", "Hostname" }, null, null, null, null)
          }));
    }
    #endregion

  }
  #region Enums
  /// <summary>
  /// Current health status of a worker.
  /// </summary>
  public enum WorkerHealth {
    /// <summary>
    /// By default a worker is healthy.
    /// </summary>
    [pbr::OriginalName("OK")] Ok = 0,
    [pbr::OriginalName("RECEIVED_SHUTDOWN_SIGNAL")] ReceivedShutdownSignal = 1,
    [pbr::OriginalName("INTERNAL_ERROR")] InternalError = 2,
    /// <summary>
    /// Worker has been instructed to shutdown after a timeout.
    /// </summary>
    [pbr::OriginalName("SHUTTING_DOWN")] ShuttingDown = 3,
  }

  /// <summary>
  /// Indicates the behavior of the worker when an internal error or shutdown
  /// signal is received.
  /// </summary>
  public enum WorkerShutdownMode {
    [pbr::OriginalName("DEFAULT")] Default = 0,
    [pbr::OriginalName("NOT_CONFIGURED")] NotConfigured = 1,
    [pbr::OriginalName("WAIT_FOR_COORDINATOR")] WaitForCoordinator = 2,
    [pbr::OriginalName("SHUTDOWN_AFTER_TIMEOUT")] ShutdownAfterTimeout = 3,
  }

  #endregion

  #region Messages
  /// <summary>
  /// Protocol buffer representing an event that happened during
  /// the execution of a Brain model.
  /// </summary>
  public sealed partial class Event : pb::IMessage<Event> {
    private static readonly pb::MessageParser<Event> _parser = new pb::MessageParser<Event>(() => new Event());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<Event> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Event() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Event(Event other) : this() {
      wallTime_ = other.wallTime_;
      step_ = other.step_;
      switch (other.WhatCase) {
        case WhatOneofCase.FileVersion:
          FileVersion = other.FileVersion;
          break;
        case WhatOneofCase.GraphDef:
          GraphDef = other.GraphDef;
          break;
        case WhatOneofCase.Summary:
          Summary = other.Summary.Clone();
          break;
        case WhatOneofCase.LogMessage:
          LogMessage = other.LogMessage.Clone();
          break;
        case WhatOneofCase.SessionLog:
          SessionLog = other.SessionLog.Clone();
          break;
        case WhatOneofCase.TaggedRunMetadata:
          TaggedRunMetadata = other.TaggedRunMetadata.Clone();
          break;
        case WhatOneofCase.MetaGraphDef:
          MetaGraphDef = other.MetaGraphDef;
          break;
      }

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

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Event Clone() {
      return new Event(this);
    }

    /// <summary>Field number for the "wall_time" field.</summary>
    public const int WallTimeFieldNumber = 1;
    private double wallTime_;
    /// <summary>
    /// Timestamp of the event.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double WallTime {
      get { return wallTime_; }
      set {
        wallTime_ = value;
      }
    }

    /// <summary>Field number for the "step" field.</summary>
    public const int StepFieldNumber = 2;
    private long step_;
    /// <summary>
    /// Global step of the event.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long Step {
      get { return step_; }
      set {
        step_ = value;
      }
    }

    /// <summary>Field number for the "file_version" field.</summary>
    public const int FileVersionFieldNumber = 3;
    /// <summary>
    /// An event file was started, with the specified version.
    /// This is use to identify the contents of the record IO files
    /// easily.  Current version is "brain.Event:2".  All versions
    /// start with "brain.Event:".
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string FileVersion {
      get { return whatCase_ == WhatOneofCase.FileVersion ? (string) what_ : ""; }
      set {
        what_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
        whatCase_ = WhatOneofCase.FileVersion;
      }
    }

    /// <summary>Field number for the "graph_def" field.</summary>
    public const int GraphDefFieldNumber = 4;
    /// <summary>
    /// An encoded version of a GraphDef.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pb::ByteString GraphDef {
      get { return whatCase_ == WhatOneofCase.GraphDef ? (pb::ByteString) what_ : pb::ByteString.Empty; }
      set {
        what_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
        whatCase_ = WhatOneofCase.GraphDef;
      }
    }

    /// <summary>Field number for the "summary" field.</summary>
    public const int SummaryFieldNumber = 5;
    /// <summary>
    /// A summary was generated.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.Summary Summary {
      get { return whatCase_ == WhatOneofCase.Summary ? (global::Tensorflow.Summary) what_ : null; }
      set {
        what_ = value;
        whatCase_ = value == null ? WhatOneofCase.None : WhatOneofCase.Summary;
      }
    }

    /// <summary>Field number for the "log_message" field.</summary>
    public const int LogMessageFieldNumber = 6;
    /// <summary>
    /// The user output a log message. Not all messages are logged, only ones
    /// generated via the Python tensorboard_logging module.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.LogMessage LogMessage {
      get { return whatCase_ == WhatOneofCase.LogMessage ? (global::Tensorflow.LogMessage) what_ : null; }
      set {
        what_ = value;
        whatCase_ = value == null ? WhatOneofCase.None : WhatOneofCase.LogMessage;
      }
    }

    /// <summary>Field number for the "session_log" field.</summary>
    public const int SessionLogFieldNumber = 7;
    /// <summary>
    /// The state of the session which can be used for restarting after crashes.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.SessionLog SessionLog {
      get { return whatCase_ == WhatOneofCase.SessionLog ? (global::Tensorflow.SessionLog) what_ : null; }
      set {
        what_ = value;
        whatCase_ = value == null ? WhatOneofCase.None : WhatOneofCase.SessionLog;
      }
    }

    /// <summary>Field number for the "tagged_run_metadata" field.</summary>
    public const int TaggedRunMetadataFieldNumber = 8;
    /// <summary>
    /// The metadata returned by running a session.run() call.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.TaggedRunMetadata TaggedRunMetadata {
      get { return whatCase_ == WhatOneofCase.TaggedRunMetadata ? (global::Tensorflow.TaggedRunMetadata) what_ : null; }
      set {
        what_ = value;
        whatCase_ = value == null ? WhatOneofCase.None : WhatOneofCase.TaggedRunMetadata;
      }
    }

    /// <summary>Field number for the "meta_graph_def" field.</summary>
    public const int MetaGraphDefFieldNumber = 9;
    /// <summary>
    /// An encoded version of a MetaGraphDef.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pb::ByteString MetaGraphDef {
      get { return whatCase_ == WhatOneofCase.MetaGraphDef ? (pb::ByteString) what_ : pb::ByteString.Empty; }
      set {
        what_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
        whatCase_ = WhatOneofCase.MetaGraphDef;
      }
    }

    private object what_;
    /// <summary>Enum of possible cases for the "what" oneof.</summary>
    public enum WhatOneofCase {
      None = 0,
      FileVersion = 3,
      GraphDef = 4,
      Summary = 5,
      LogMessage = 6,
      SessionLog = 7,
      TaggedRunMetadata = 8,
      MetaGraphDef = 9,
    }
    private WhatOneofCase whatCase_ = WhatOneofCase.None;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WhatOneofCase WhatCase {
      get { return whatCase_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearWhat() {
      whatCase_ = WhatOneofCase.None;
      what_ = null;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as Event);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(Event other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(WallTime, other.WallTime)) return false;
      if (Step != other.Step) return false;
      if (FileVersion != other.FileVersion) return false;
      if (GraphDef != other.GraphDef) return false;
      if (!object.Equals(Summary, other.Summary)) return false;
      if (!object.Equals(LogMessage, other.LogMessage)) return false;
      if (!object.Equals(SessionLog, other.SessionLog)) return false;
      if (!object.Equals(TaggedRunMetadata, other.TaggedRunMetadata)) return false;
      if (MetaGraphDef != other.MetaGraphDef) return false;
      if (WhatCase != other.WhatCase) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (WallTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(WallTime);
      if (Step != 0L) hash ^= Step.GetHashCode();
      if (whatCase_ == WhatOneofCase.FileVersion) hash ^= FileVersion.GetHashCode();
      if (whatCase_ == WhatOneofCase.GraphDef) hash ^= GraphDef.GetHashCode();
      if (whatCase_ == WhatOneofCase.Summary) hash ^= Summary.GetHashCode();
      if (whatCase_ == WhatOneofCase.LogMessage) hash ^= LogMessage.GetHashCode();
      if (whatCase_ == WhatOneofCase.SessionLog) hash ^= SessionLog.GetHashCode();
      if (whatCase_ == WhatOneofCase.TaggedRunMetadata) hash ^= TaggedRunMetadata.GetHashCode();
      if (whatCase_ == WhatOneofCase.MetaGraphDef) hash ^= MetaGraphDef.GetHashCode();
      hash ^= (int) whatCase_;
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (WallTime != 0D) {
        output.WriteRawTag(9);
        output.WriteDouble(WallTime);
      }
      if (Step != 0L) {
        output.WriteRawTag(16);
        output.WriteInt64(Step);
      }
      if (whatCase_ == WhatOneofCase.FileVersion) {
        output.WriteRawTag(26);
        output.WriteString(FileVersion);
      }
      if (whatCase_ == WhatOneofCase.GraphDef) {
        output.WriteRawTag(34);
        output.WriteBytes(GraphDef);
      }
      if (whatCase_ == WhatOneofCase.Summary) {
        output.WriteRawTag(42);
        output.WriteMessage(Summary);
      }
      if (whatCase_ == WhatOneofCase.LogMessage) {
        output.WriteRawTag(50);
        output.WriteMessage(LogMessage);
      }
      if (whatCase_ == WhatOneofCase.SessionLog) {
        output.WriteRawTag(58);
        output.WriteMessage(SessionLog);
      }
      if (whatCase_ == WhatOneofCase.TaggedRunMetadata) {
        output.WriteRawTag(66);
        output.WriteMessage(TaggedRunMetadata);
      }
      if (whatCase_ == WhatOneofCase.MetaGraphDef) {
        output.WriteRawTag(74);
        output.WriteBytes(MetaGraphDef);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (WallTime != 0D) {
        size += 1 + 8;
      }
      if (Step != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(Step);
      }
      if (whatCase_ == WhatOneofCase.FileVersion) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(FileVersion);
      }
      if (whatCase_ == WhatOneofCase.GraphDef) {
        size += 1 + pb::CodedOutputStream.ComputeBytesSize(GraphDef);
      }
      if (whatCase_ == WhatOneofCase.Summary) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Summary);
      }
      if (whatCase_ == WhatOneofCase.LogMessage) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(LogMessage);
      }
      if (whatCase_ == WhatOneofCase.SessionLog) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(SessionLog);
      }
      if (whatCase_ == WhatOneofCase.TaggedRunMetadata) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(TaggedRunMetadata);
      }
      if (whatCase_ == WhatOneofCase.MetaGraphDef) {
        size += 1 + pb::CodedOutputStream.ComputeBytesSize(MetaGraphDef);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(Event other) {
      if (other == null) {
        return;
      }
      if (other.WallTime != 0D) {
        WallTime = other.WallTime;
      }
      if (other.Step != 0L) {
        Step = other.Step;
      }
      switch (other.WhatCase) {
        case WhatOneofCase.FileVersion:
          FileVersion = other.FileVersion;
          break;
        case WhatOneofCase.GraphDef:
          GraphDef = other.GraphDef;
          break;
        case WhatOneofCase.Summary:
          if (Summary == null) {
            Summary = new global::Tensorflow.Summary();
          }
          Summary.MergeFrom(other.Summary);
          break;
        case WhatOneofCase.LogMessage:
          if (LogMessage == null) {
            LogMessage = new global::Tensorflow.LogMessage();
          }
          LogMessage.MergeFrom(other.LogMessage);
          break;
        case WhatOneofCase.SessionLog:
          if (SessionLog == null) {
            SessionLog = new global::Tensorflow.SessionLog();
          }
          SessionLog.MergeFrom(other.SessionLog);
          break;
        case WhatOneofCase.TaggedRunMetadata:
          if (TaggedRunMetadata == null) {
            TaggedRunMetadata = new global::Tensorflow.TaggedRunMetadata();
          }
          TaggedRunMetadata.MergeFrom(other.TaggedRunMetadata);
          break;
        case WhatOneofCase.MetaGraphDef:
          MetaGraphDef = other.MetaGraphDef;
          break;
      }

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

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 9: {
            WallTime = input.ReadDouble();
            break;
          }
          case 16: {
            Step = input.ReadInt64();
            break;
          }
          case 26: {
            FileVersion = input.ReadString();
            break;
          }
          case 34: {
            GraphDef = input.ReadBytes();
            break;
          }
          case 42: {
            global::Tensorflow.Summary subBuilder = new global::Tensorflow.Summary();
            if (whatCase_ == WhatOneofCase.Summary) {
              subBuilder.MergeFrom(Summary);
            }
            input.ReadMessage(subBuilder);
            Summary = subBuilder;
            break;
          }
          case 50: {
            global::Tensorflow.LogMessage subBuilder = new global::Tensorflow.LogMessage();
            if (whatCase_ == WhatOneofCase.LogMessage) {
              subBuilder.MergeFrom(LogMessage);
            }
            input.ReadMessage(subBuilder);
            LogMessage = subBuilder;
            break;
          }
          case 58: {
            global::Tensorflow.SessionLog subBuilder = new global::Tensorflow.SessionLog();
            if (whatCase_ == WhatOneofCase.SessionLog) {
              subBuilder.MergeFrom(SessionLog);
            }
            input.ReadMessage(subBuilder);
            SessionLog = subBuilder;
            break;
          }
          case 66: {
            global::Tensorflow.TaggedRunMetadata subBuilder = new global::Tensorflow.TaggedRunMetadata();
            if (whatCase_ == WhatOneofCase.TaggedRunMetadata) {
              subBuilder.MergeFrom(TaggedRunMetadata);
            }
            input.ReadMessage(subBuilder);
            TaggedRunMetadata = subBuilder;
            break;
          }
          case 74: {
            MetaGraphDef = input.ReadBytes();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// Protocol buffer used for logging messages to the events file.
  /// </summary>
  public sealed partial class LogMessage : pb::IMessage<LogMessage> {
    private static readonly pb::MessageParser<LogMessage> _parser = new pb::MessageParser<LogMessage>(() => new LogMessage());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<LogMessage> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[1]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LogMessage() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LogMessage(LogMessage other) : this() {
      level_ = other.level_;
      message_ = other.message_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LogMessage Clone() {
      return new LogMessage(this);
    }

    /// <summary>Field number for the "level" field.</summary>
    public const int LevelFieldNumber = 1;
    private global::Tensorflow.LogMessage.Types.Level level_ = global::Tensorflow.LogMessage.Types.Level.Unknown;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.LogMessage.Types.Level Level {
      get { return level_; }
      set {
        level_ = value;
      }
    }

    /// <summary>Field number for the "message" field.</summary>
    public const int MessageFieldNumber = 2;
    private string message_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Message {
      get { return message_; }
      set {
        message_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as LogMessage);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(LogMessage other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Level != other.Level) return false;
      if (Message != other.Message) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Level != global::Tensorflow.LogMessage.Types.Level.Unknown) hash ^= Level.GetHashCode();
      if (Message.Length != 0) hash ^= Message.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Level != global::Tensorflow.LogMessage.Types.Level.Unknown) {
        output.WriteRawTag(8);
        output.WriteEnum((int) Level);
      }
      if (Message.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(Message);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Level != global::Tensorflow.LogMessage.Types.Level.Unknown) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Level);
      }
      if (Message.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Message);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(LogMessage other) {
      if (other == null) {
        return;
      }
      if (other.Level != global::Tensorflow.LogMessage.Types.Level.Unknown) {
        Level = other.Level;
      }
      if (other.Message.Length != 0) {
        Message = other.Message;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Level = (global::Tensorflow.LogMessage.Types.Level) input.ReadEnum();
            break;
          }
          case 18: {
            Message = input.ReadString();
            break;
          }
        }
      }
    }

    #region Nested types
    /// <summary>Container for nested types declared in the LogMessage message type.</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static partial class Types {
      public enum Level {
        [pbr::OriginalName("UNKNOWN")] Unknown = 0,
        /// <summary>
        /// Note: The logging level 10 cannot be named DEBUG. Some software
        /// projects compile their C/C++ code with -DDEBUG in debug builds. So the
        /// C++ code generated from this file should not have an identifier named
        /// DEBUG.
        /// </summary>
        [pbr::OriginalName("DEBUGGING")] Debugging = 10,
        [pbr::OriginalName("INFO")] Info = 20,
        [pbr::OriginalName("WARN")] Warn = 30,
        [pbr::OriginalName("ERROR")] Error = 40,
        [pbr::OriginalName("FATAL")] Fatal = 50,
      }

    }
    #endregion

  }

  /// <summary>
  /// Protocol buffer used for logging session state.
  /// </summary>
  public sealed partial class SessionLog : pb::IMessage<SessionLog> {
    private static readonly pb::MessageParser<SessionLog> _parser = new pb::MessageParser<SessionLog>(() => new SessionLog());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SessionLog> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[2]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SessionLog() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SessionLog(SessionLog other) : this() {
      status_ = other.status_;
      checkpointPath_ = other.checkpointPath_;
      msg_ = other.msg_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SessionLog Clone() {
      return new SessionLog(this);
    }

    /// <summary>Field number for the "status" field.</summary>
    public const int StatusFieldNumber = 1;
    private global::Tensorflow.SessionLog.Types.SessionStatus status_ = global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.SessionLog.Types.SessionStatus Status {
      get { return status_; }
      set {
        status_ = value;
      }
    }

    /// <summary>Field number for the "checkpoint_path" field.</summary>
    public const int CheckpointPathFieldNumber = 2;
    private string checkpointPath_ = "";
    /// <summary>
    /// This checkpoint_path contains both the path and filename.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string CheckpointPath {
      get { return checkpointPath_; }
      set {
        checkpointPath_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "msg" field.</summary>
    public const int MsgFieldNumber = 3;
    private string msg_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Msg {
      get { return msg_; }
      set {
        msg_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SessionLog);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SessionLog other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Status != other.Status) return false;
      if (CheckpointPath != other.CheckpointPath) return false;
      if (Msg != other.Msg) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Status != global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified) hash ^= Status.GetHashCode();
      if (CheckpointPath.Length != 0) hash ^= CheckpointPath.GetHashCode();
      if (Msg.Length != 0) hash ^= Msg.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Status != global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified) {
        output.WriteRawTag(8);
        output.WriteEnum((int) Status);
      }
      if (CheckpointPath.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(CheckpointPath);
      }
      if (Msg.Length != 0) {
        output.WriteRawTag(26);
        output.WriteString(Msg);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Status != global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Status);
      }
      if (CheckpointPath.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(CheckpointPath);
      }
      if (Msg.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Msg);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SessionLog other) {
      if (other == null) {
        return;
      }
      if (other.Status != global::Tensorflow.SessionLog.Types.SessionStatus.StatusUnspecified) {
        Status = other.Status;
      }
      if (other.CheckpointPath.Length != 0) {
        CheckpointPath = other.CheckpointPath;
      }
      if (other.Msg.Length != 0) {
        Msg = other.Msg;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Status = (global::Tensorflow.SessionLog.Types.SessionStatus) input.ReadEnum();
            break;
          }
          case 18: {
            CheckpointPath = input.ReadString();
            break;
          }
          case 26: {
            Msg = input.ReadString();
            break;
          }
        }
      }
    }

    #region Nested types
    /// <summary>Container for nested types declared in the SessionLog message type.</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static partial class Types {
      public enum SessionStatus {
        [pbr::OriginalName("STATUS_UNSPECIFIED")] StatusUnspecified = 0,
        [pbr::OriginalName("START")] Start = 1,
        [pbr::OriginalName("STOP")] Stop = 2,
        [pbr::OriginalName("CHECKPOINT")] Checkpoint = 3,
      }

    }
    #endregion

  }

  /// <summary>
  /// For logging the metadata output for a single session.run() call.
  /// </summary>
  public sealed partial class TaggedRunMetadata : pb::IMessage<TaggedRunMetadata> {
    private static readonly pb::MessageParser<TaggedRunMetadata> _parser = new pb::MessageParser<TaggedRunMetadata>(() => new TaggedRunMetadata());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<TaggedRunMetadata> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[3]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public TaggedRunMetadata() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public TaggedRunMetadata(TaggedRunMetadata other) : this() {
      tag_ = other.tag_;
      runMetadata_ = other.runMetadata_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public TaggedRunMetadata Clone() {
      return new TaggedRunMetadata(this);
    }

    /// <summary>Field number for the "tag" field.</summary>
    public const int TagFieldNumber = 1;
    private string tag_ = "";
    /// <summary>
    /// Tag name associated with this metadata.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Tag {
      get { return tag_; }
      set {
        tag_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "run_metadata" field.</summary>
    public const int RunMetadataFieldNumber = 2;
    private pb::ByteString runMetadata_ = pb::ByteString.Empty;
    /// <summary>
    /// Byte-encoded version of the `RunMetadata` proto in order to allow lazy
    /// deserialization.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pb::ByteString RunMetadata {
      get { return runMetadata_; }
      set {
        runMetadata_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as TaggedRunMetadata);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(TaggedRunMetadata other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Tag != other.Tag) return false;
      if (RunMetadata != other.RunMetadata) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Tag.Length != 0) hash ^= Tag.GetHashCode();
      if (RunMetadata.Length != 0) hash ^= RunMetadata.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Tag.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Tag);
      }
      if (RunMetadata.Length != 0) {
        output.WriteRawTag(18);
        output.WriteBytes(RunMetadata);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Tag.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Tag);
      }
      if (RunMetadata.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeBytesSize(RunMetadata);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(TaggedRunMetadata other) {
      if (other == null) {
        return;
      }
      if (other.Tag.Length != 0) {
        Tag = other.Tag;
      }
      if (other.RunMetadata.Length != 0) {
        RunMetadata = other.RunMetadata;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            Tag = input.ReadString();
            break;
          }
          case 18: {
            RunMetadata = input.ReadBytes();
            break;
          }
        }
      }
    }

  }

  public sealed partial class WatchdogConfig : pb::IMessage<WatchdogConfig> {
    private static readonly pb::MessageParser<WatchdogConfig> _parser = new pb::MessageParser<WatchdogConfig>(() => new WatchdogConfig());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<WatchdogConfig> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[4]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WatchdogConfig() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WatchdogConfig(WatchdogConfig other) : this() {
      timeoutMs_ = other.timeoutMs_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WatchdogConfig Clone() {
      return new WatchdogConfig(this);
    }

    /// <summary>Field number for the "timeout_ms" field.</summary>
    public const int TimeoutMsFieldNumber = 1;
    private long timeoutMs_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long TimeoutMs {
      get { return timeoutMs_; }
      set {
        timeoutMs_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as WatchdogConfig);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(WatchdogConfig other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (TimeoutMs != other.TimeoutMs) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (TimeoutMs != 0L) hash ^= TimeoutMs.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (TimeoutMs != 0L) {
        output.WriteRawTag(8);
        output.WriteInt64(TimeoutMs);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (TimeoutMs != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(TimeoutMs);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(WatchdogConfig other) {
      if (other == null) {
        return;
      }
      if (other.TimeoutMs != 0L) {
        TimeoutMs = other.TimeoutMs;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            TimeoutMs = input.ReadInt64();
            break;
          }
        }
      }
    }

  }

  public sealed partial class RequestedExitCode : pb::IMessage<RequestedExitCode> {
    private static readonly pb::MessageParser<RequestedExitCode> _parser = new pb::MessageParser<RequestedExitCode>(() => new RequestedExitCode());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<RequestedExitCode> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[5]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RequestedExitCode() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RequestedExitCode(RequestedExitCode other) : this() {
      exitCode_ = other.exitCode_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RequestedExitCode Clone() {
      return new RequestedExitCode(this);
    }

    /// <summary>Field number for the "exit_code" field.</summary>
    public const int ExitCodeFieldNumber = 1;
    private int exitCode_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int ExitCode {
      get { return exitCode_; }
      set {
        exitCode_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as RequestedExitCode);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(RequestedExitCode other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (ExitCode != other.ExitCode) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (ExitCode != 0) hash ^= ExitCode.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (ExitCode != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(ExitCode);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (ExitCode != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(ExitCode);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(RequestedExitCode other) {
      if (other == null) {
        return;
      }
      if (other.ExitCode != 0) {
        ExitCode = other.ExitCode;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            ExitCode = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  public sealed partial class WorkerHeartbeatRequest : pb::IMessage<WorkerHeartbeatRequest> {
    private static readonly pb::MessageParser<WorkerHeartbeatRequest> _parser = new pb::MessageParser<WorkerHeartbeatRequest>(() => new WorkerHeartbeatRequest());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<WorkerHeartbeatRequest> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[6]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WorkerHeartbeatRequest() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WorkerHeartbeatRequest(WorkerHeartbeatRequest other) : this() {
      shutdownMode_ = other.shutdownMode_;
      watchdogConfig_ = other.watchdogConfig_ != null ? other.watchdogConfig_.Clone() : null;
      exitCode_ = other.exitCode_ != null ? other.exitCode_.Clone() : null;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WorkerHeartbeatRequest Clone() {
      return new WorkerHeartbeatRequest(this);
    }

    /// <summary>Field number for the "shutdown_mode" field.</summary>
    public const int ShutdownModeFieldNumber = 1;
    private global::Tensorflow.WorkerShutdownMode shutdownMode_ = global::Tensorflow.WorkerShutdownMode.Default;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.WorkerShutdownMode ShutdownMode {
      get { return shutdownMode_; }
      set {
        shutdownMode_ = value;
      }
    }

    /// <summary>Field number for the "watchdog_config" field.</summary>
    public const int WatchdogConfigFieldNumber = 2;
    private global::Tensorflow.WatchdogConfig watchdogConfig_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.WatchdogConfig WatchdogConfig {
      get { return watchdogConfig_; }
      set {
        watchdogConfig_ = value;
      }
    }

    /// <summary>Field number for the "exit_code" field.</summary>
    public const int ExitCodeFieldNumber = 3;
    private global::Tensorflow.RequestedExitCode exitCode_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.RequestedExitCode ExitCode {
      get { return exitCode_; }
      set {
        exitCode_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as WorkerHeartbeatRequest);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(WorkerHeartbeatRequest other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (ShutdownMode != other.ShutdownMode) return false;
      if (!object.Equals(WatchdogConfig, other.WatchdogConfig)) return false;
      if (!object.Equals(ExitCode, other.ExitCode)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (ShutdownMode != global::Tensorflow.WorkerShutdownMode.Default) hash ^= ShutdownMode.GetHashCode();
      if (watchdogConfig_ != null) hash ^= WatchdogConfig.GetHashCode();
      if (exitCode_ != null) hash ^= ExitCode.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (ShutdownMode != global::Tensorflow.WorkerShutdownMode.Default) {
        output.WriteRawTag(8);
        output.WriteEnum((int) ShutdownMode);
      }
      if (watchdogConfig_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(WatchdogConfig);
      }
      if (exitCode_ != null) {
        output.WriteRawTag(26);
        output.WriteMessage(ExitCode);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (ShutdownMode != global::Tensorflow.WorkerShutdownMode.Default) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) ShutdownMode);
      }
      if (watchdogConfig_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(WatchdogConfig);
      }
      if (exitCode_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(ExitCode);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(WorkerHeartbeatRequest other) {
      if (other == null) {
        return;
      }
      if (other.ShutdownMode != global::Tensorflow.WorkerShutdownMode.Default) {
        ShutdownMode = other.ShutdownMode;
      }
      if (other.watchdogConfig_ != null) {
        if (watchdogConfig_ == null) {
          WatchdogConfig = new global::Tensorflow.WatchdogConfig();
        }
        WatchdogConfig.MergeFrom(other.WatchdogConfig);
      }
      if (other.exitCode_ != null) {
        if (exitCode_ == null) {
          ExitCode = new global::Tensorflow.RequestedExitCode();
        }
        ExitCode.MergeFrom(other.ExitCode);
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            ShutdownMode = (global::Tensorflow.WorkerShutdownMode) input.ReadEnum();
            break;
          }
          case 18: {
            if (watchdogConfig_ == null) {
              WatchdogConfig = new global::Tensorflow.WatchdogConfig();
            }
            input.ReadMessage(WatchdogConfig);
            break;
          }
          case 26: {
            if (exitCode_ == null) {
              ExitCode = new global::Tensorflow.RequestedExitCode();
            }
            input.ReadMessage(ExitCode);
            break;
          }
        }
      }
    }

  }

  public sealed partial class WorkerHeartbeatResponse : pb::IMessage<WorkerHeartbeatResponse> {
    private static readonly pb::MessageParser<WorkerHeartbeatResponse> _parser = new pb::MessageParser<WorkerHeartbeatResponse>(() => new WorkerHeartbeatResponse());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<WorkerHeartbeatResponse> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.EventReflection.Descriptor.MessageTypes[7]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WorkerHeartbeatResponse() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WorkerHeartbeatResponse(WorkerHeartbeatResponse other) : this() {
      healthStatus_ = other.healthStatus_;
      workerLog_ = other.workerLog_.Clone();
      hostname_ = other.hostname_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public WorkerHeartbeatResponse Clone() {
      return new WorkerHeartbeatResponse(this);
    }

    /// <summary>Field number for the "health_status" field.</summary>
    public const int HealthStatusFieldNumber = 1;
    private global::Tensorflow.WorkerHealth healthStatus_ = global::Tensorflow.WorkerHealth.Ok;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.WorkerHealth HealthStatus {
      get { return healthStatus_; }
      set {
        healthStatus_ = value;
      }
    }

    /// <summary>Field number for the "worker_log" field.</summary>
    public const int WorkerLogFieldNumber = 2;
    private static readonly pb::FieldCodec<global::Tensorflow.Event> _repeated_workerLog_codec
        = pb::FieldCodec.ForMessage(18, global::Tensorflow.Event.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.Event> workerLog_ = new pbc::RepeatedField<global::Tensorflow.Event>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.Event> WorkerLog {
      get { return workerLog_; }
    }

    /// <summary>Field number for the "hostname" field.</summary>
    public const int HostnameFieldNumber = 3;
    private string hostname_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Hostname {
      get { return hostname_; }
      set {
        hostname_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as WorkerHeartbeatResponse);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(WorkerHeartbeatResponse other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (HealthStatus != other.HealthStatus) return false;
      if(!workerLog_.Equals(other.workerLog_)) return false;
      if (Hostname != other.Hostname) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (HealthStatus != global::Tensorflow.WorkerHealth.Ok) hash ^= HealthStatus.GetHashCode();
      hash ^= workerLog_.GetHashCode();
      if (Hostname.Length != 0) hash ^= Hostname.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (HealthStatus != global::Tensorflow.WorkerHealth.Ok) {
        output.WriteRawTag(8);
        output.WriteEnum((int) HealthStatus);
      }
      workerLog_.WriteTo(output, _repeated_workerLog_codec);
      if (Hostname.Length != 0) {
        output.WriteRawTag(26);
        output.WriteString(Hostname);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (HealthStatus != global::Tensorflow.WorkerHealth.Ok) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) HealthStatus);
      }
      size += workerLog_.CalculateSize(_repeated_workerLog_codec);
      if (Hostname.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Hostname);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(WorkerHeartbeatResponse other) {
      if (other == null) {
        return;
      }
      if (other.HealthStatus != global::Tensorflow.WorkerHealth.Ok) {
        HealthStatus = other.HealthStatus;
      }
      workerLog_.Add(other.workerLog_);
      if (other.Hostname.Length != 0) {
        Hostname = other.Hostname;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            HealthStatus = (global::Tensorflow.WorkerHealth) input.ReadEnum();
            break;
          }
          case 18: {
            workerLog_.AddEntriesFrom(input, _repeated_workerLog_codec);
            break;
          }
          case 26: {
            Hostname = input.ReadString();
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code