// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tensorflow/core/util/event.proto

#ifndef PROTOBUF_tensorflow_2fcore_2futil_2fevent_2eproto__INCLUDED
#define PROTOBUF_tensorflow_2fcore_2futil_2fevent_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3001000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "tensorflow/core/framework/summary.pb.h"
// @@protoc_insertion_point(includes)

namespace tensorflow {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_tensorflow_2fcore_2futil_2fevent_2eproto();
void protobuf_InitDefaults_tensorflow_2fcore_2futil_2fevent_2eproto();
void protobuf_AssignDesc_tensorflow_2fcore_2futil_2fevent_2eproto();
void protobuf_ShutdownFile_tensorflow_2fcore_2futil_2fevent_2eproto();

class Event;
class LogMessage;
class SessionLog;
class TaggedRunMetadata;

enum LogMessage_Level {
  LogMessage_Level_UNKNOWN = 0,
  LogMessage_Level_DEBUGGING = 10,
  LogMessage_Level_INFO = 20,
  LogMessage_Level_WARN = 30,
  LogMessage_Level_ERROR = 40,
  LogMessage_Level_FATAL = 50,
  LogMessage_Level_LogMessage_Level_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  LogMessage_Level_LogMessage_Level_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool LogMessage_Level_IsValid(int value);
const LogMessage_Level LogMessage_Level_Level_MIN = LogMessage_Level_UNKNOWN;
const LogMessage_Level LogMessage_Level_Level_MAX = LogMessage_Level_FATAL;
const int LogMessage_Level_Level_ARRAYSIZE = LogMessage_Level_Level_MAX + 1;

const ::google::protobuf::EnumDescriptor* LogMessage_Level_descriptor();
inline const ::std::string& LogMessage_Level_Name(LogMessage_Level value) {
  return ::google::protobuf::internal::NameOfEnum(
    LogMessage_Level_descriptor(), value);
}
inline bool LogMessage_Level_Parse(
    const ::std::string& name, LogMessage_Level* value) {
  return ::google::protobuf::internal::ParseNamedEnum<LogMessage_Level>(
    LogMessage_Level_descriptor(), name, value);
}
enum SessionLog_SessionStatus {
  SessionLog_SessionStatus_STATUS_UNSPECIFIED = 0,
  SessionLog_SessionStatus_START = 1,
  SessionLog_SessionStatus_STOP = 2,
  SessionLog_SessionStatus_CHECKPOINT = 3,
  SessionLog_SessionStatus_SessionLog_SessionStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  SessionLog_SessionStatus_SessionLog_SessionStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool SessionLog_SessionStatus_IsValid(int value);
const SessionLog_SessionStatus SessionLog_SessionStatus_SessionStatus_MIN = SessionLog_SessionStatus_STATUS_UNSPECIFIED;
const SessionLog_SessionStatus SessionLog_SessionStatus_SessionStatus_MAX = SessionLog_SessionStatus_CHECKPOINT;
const int SessionLog_SessionStatus_SessionStatus_ARRAYSIZE = SessionLog_SessionStatus_SessionStatus_MAX + 1;

const ::google::protobuf::EnumDescriptor* SessionLog_SessionStatus_descriptor();
inline const ::std::string& SessionLog_SessionStatus_Name(SessionLog_SessionStatus value) {
  return ::google::protobuf::internal::NameOfEnum(
    SessionLog_SessionStatus_descriptor(), value);
}
inline bool SessionLog_SessionStatus_Parse(
    const ::std::string& name, SessionLog_SessionStatus* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SessionLog_SessionStatus>(
    SessionLog_SessionStatus_descriptor(), name, value);
}
// ===================================================================

class Event : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.Event) */ {
 public:
  Event();
  virtual ~Event();

  Event(const Event& from);

  inline Event& operator=(const Event& from) {
    CopyFrom(from);
    return *this;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const Event& default_instance();

  enum WhatCase {
    kFileVersion = 3,
    kGraphDef = 4,
    kSummary = 5,
    kLogMessage = 6,
    kSessionLog = 7,
    kTaggedRunMetadata = 8,
    kMetaGraphDef = 9,
    WHAT_NOT_SET = 0,
  };

  static const Event* internal_default_instance();

  void UnsafeArenaSwap(Event* other);
  void Swap(Event* other);

  // implements Message ----------------------------------------------

  inline Event* New() const { return New(NULL); }

  Event* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Event& from);
  void MergeFrom(const Event& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Event* other);
  void UnsafeMergeFrom(const Event& from);
  protected:
  explicit Event(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional double wall_time = 1;
  void clear_wall_time();
  static const int kWallTimeFieldNumber = 1;
  double wall_time() const;
  void set_wall_time(double value);

  // optional int64 step = 2;
  void clear_step();
  static const int kStepFieldNumber = 2;
  ::google::protobuf::int64 step() const;
  void set_step(::google::protobuf::int64 value);

  // optional string file_version = 3;
  private:
  bool has_file_version() const;
  public:
  void clear_file_version();
  static const int kFileVersionFieldNumber = 3;
  const ::std::string& file_version() const;
  void set_file_version(const ::std::string& value);
  void set_file_version(const char* value);
  void set_file_version(const char* value, size_t size);
  ::std::string* mutable_file_version();
  ::std::string* release_file_version();
  void set_allocated_file_version(::std::string* file_version);
  ::std::string* unsafe_arena_release_file_version();
  void unsafe_arena_set_allocated_file_version(
      ::std::string* file_version);

  // optional bytes graph_def = 4;
  private:
  bool has_graph_def() const;
  public:
  void clear_graph_def();
  static const int kGraphDefFieldNumber = 4;
  const ::std::string& graph_def() const;
  void set_graph_def(const ::std::string& value);
  void set_graph_def(const char* value);
  void set_graph_def(const void* value, size_t size);
  ::std::string* mutable_graph_def();
  ::std::string* release_graph_def();
  void set_allocated_graph_def(::std::string* graph_def);
  ::std::string* unsafe_arena_release_graph_def();
  void unsafe_arena_set_allocated_graph_def(
      ::std::string* graph_def);

  // optional .tensorflow.Summary summary = 5;
  bool has_summary() const;
  void clear_summary();
  static const int kSummaryFieldNumber = 5;
  private:
  void _slow_mutable_summary();
  void _slow_set_allocated_summary(
      ::google::protobuf::Arena* message_arena, ::tensorflow::Summary** summary);
  ::tensorflow::Summary* _slow_release_summary();
  public:
  const ::tensorflow::Summary& summary() const;
  ::tensorflow::Summary* mutable_summary();
  ::tensorflow::Summary* release_summary();
  void set_allocated_summary(::tensorflow::Summary* summary);
  ::tensorflow::Summary* unsafe_arena_release_summary();
  void unsafe_arena_set_allocated_summary(
      ::tensorflow::Summary* summary);

  // optional .tensorflow.LogMessage log_message = 6;
  bool has_log_message() const;
  void clear_log_message();
  static const int kLogMessageFieldNumber = 6;
  private:
  void _slow_mutable_log_message();
  void _slow_set_allocated_log_message(
      ::google::protobuf::Arena* message_arena, ::tensorflow::LogMessage** log_message);
  ::tensorflow::LogMessage* _slow_release_log_message();
  public:
  const ::tensorflow::LogMessage& log_message() const;
  ::tensorflow::LogMessage* mutable_log_message();
  ::tensorflow::LogMessage* release_log_message();
  void set_allocated_log_message(::tensorflow::LogMessage* log_message);
  ::tensorflow::LogMessage* unsafe_arena_release_log_message();
  void unsafe_arena_set_allocated_log_message(
      ::tensorflow::LogMessage* log_message);

  // optional .tensorflow.SessionLog session_log = 7;
  bool has_session_log() const;
  void clear_session_log();
  static const int kSessionLogFieldNumber = 7;
  private:
  void _slow_mutable_session_log();
  void _slow_set_allocated_session_log(
      ::google::protobuf::Arena* message_arena, ::tensorflow::SessionLog** session_log);
  ::tensorflow::SessionLog* _slow_release_session_log();
  public:
  const ::tensorflow::SessionLog& session_log() const;
  ::tensorflow::SessionLog* mutable_session_log();
  ::tensorflow::SessionLog* release_session_log();
  void set_allocated_session_log(::tensorflow::SessionLog* session_log);
  ::tensorflow::SessionLog* unsafe_arena_release_session_log();
  void unsafe_arena_set_allocated_session_log(
      ::tensorflow::SessionLog* session_log);

  // optional .tensorflow.TaggedRunMetadata tagged_run_metadata = 8;
  bool has_tagged_run_metadata() const;
  void clear_tagged_run_metadata();
  static const int kTaggedRunMetadataFieldNumber = 8;
  private:
  void _slow_mutable_tagged_run_metadata();
  void _slow_set_allocated_tagged_run_metadata(
      ::google::protobuf::Arena* message_arena, ::tensorflow::TaggedRunMetadata** tagged_run_metadata);
  ::tensorflow::TaggedRunMetadata* _slow_release_tagged_run_metadata();
  public:
  const ::tensorflow::TaggedRunMetadata& tagged_run_metadata() const;
  ::tensorflow::TaggedRunMetadata* mutable_tagged_run_metadata();
  ::tensorflow::TaggedRunMetadata* release_tagged_run_metadata();
  void set_allocated_tagged_run_metadata(::tensorflow::TaggedRunMetadata* tagged_run_metadata);
  ::tensorflow::TaggedRunMetadata* unsafe_arena_release_tagged_run_metadata();
  void unsafe_arena_set_allocated_tagged_run_metadata(
      ::tensorflow::TaggedRunMetadata* tagged_run_metadata);

  // optional bytes meta_graph_def = 9;
  private:
  bool has_meta_graph_def() const;
  public:
  void clear_meta_graph_def();
  static const int kMetaGraphDefFieldNumber = 9;
  const ::std::string& meta_graph_def() const;
  void set_meta_graph_def(const ::std::string& value);
  void set_meta_graph_def(const char* value);
  void set_meta_graph_def(const void* value, size_t size);
  ::std::string* mutable_meta_graph_def();
  ::std::string* release_meta_graph_def();
  void set_allocated_meta_graph_def(::std::string* meta_graph_def);
  ::std::string* unsafe_arena_release_meta_graph_def();
  void unsafe_arena_set_allocated_meta_graph_def(
      ::std::string* meta_graph_def);

  WhatCase what_case() const;
  // @@protoc_insertion_point(class_scope:tensorflow.Event)
 private:
  inline void set_has_file_version();
  inline void set_has_graph_def();
  inline void set_has_summary();
  inline void set_has_log_message();
  inline void set_has_session_log();
  inline void set_has_tagged_run_metadata();
  inline void set_has_meta_graph_def();

  inline bool has_what() const;
  void clear_what();
  inline void clear_has_what();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double wall_time_;
  ::google::protobuf::int64 step_;
  union WhatUnion {
    WhatUnion() {}
    ::google::protobuf::internal::ArenaStringPtr file_version_;
    ::google::protobuf::internal::ArenaStringPtr graph_def_;
    ::tensorflow::Summary* summary_;
    ::tensorflow::LogMessage* log_message_;
    ::tensorflow::SessionLog* session_log_;
    ::tensorflow::TaggedRunMetadata* tagged_run_metadata_;
    ::google::protobuf::internal::ArenaStringPtr meta_graph_def_;
  } what_;
  mutable int _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend void  protobuf_InitDefaults_tensorflow_2fcore_2futil_2fevent_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2futil_2fevent_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2futil_2fevent_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2futil_2fevent_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<Event> Event_default_instance_;

// -------------------------------------------------------------------

class LogMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.LogMessage) */ {
 public:
  LogMessage();
  virtual ~LogMessage();

  LogMessage(const LogMessage& from);

  inline LogMessage& operator=(const LogMessage& from) {
    CopyFrom(from);
    return *this;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const LogMessage& default_instance();

  static const LogMessage* internal_default_instance();

  void UnsafeArenaSwap(LogMessage* other);
  void Swap(LogMessage* other);

  // implements Message ----------------------------------------------

  inline LogMessage* New() const { return New(NULL); }

  LogMessage* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LogMessage& from);
  void MergeFrom(const LogMessage& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LogMessage* other);
  void UnsafeMergeFrom(const LogMessage& from);
  protected:
  explicit LogMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef LogMessage_Level Level;
  static const Level UNKNOWN =
    LogMessage_Level_UNKNOWN;
  static const Level DEBUGGING =
    LogMessage_Level_DEBUGGING;
  static const Level INFO =
    LogMessage_Level_INFO;
  static const Level WARN =
    LogMessage_Level_WARN;
  static const Level ERROR =
    LogMessage_Level_ERROR;
  static const Level FATAL =
    LogMessage_Level_FATAL;
  static inline bool Level_IsValid(int value) {
    return LogMessage_Level_IsValid(value);
  }
  static const Level Level_MIN =
    LogMessage_Level_Level_MIN;
  static const Level Level_MAX =
    LogMessage_Level_Level_MAX;
  static const int Level_ARRAYSIZE =
    LogMessage_Level_Level_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Level_descriptor() {
    return LogMessage_Level_descriptor();
  }
  static inline const ::std::string& Level_Name(Level value) {
    return LogMessage_Level_Name(value);
  }
  static inline bool Level_Parse(const ::std::string& name,
      Level* value) {
    return LogMessage_Level_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional .tensorflow.LogMessage.Level level = 1;
  void clear_level();
  static const int kLevelFieldNumber = 1;
  ::tensorflow::LogMessage_Level level() const;
  void set_level(::tensorflow::LogMessage_Level value);

  // optional string message = 2;
  void clear_message();
  static const int kMessageFieldNumber = 2;
  const ::std::string& message() const;
  void set_message(const ::std::string& value);
  void set_message(const char* value);
  void set_message(const char* value, size_t size);
  ::std::string* mutable_message();
  ::std::string* release_message();
  void set_allocated_message(::std::string* message);
  ::std::string* unsafe_arena_release_message();
  void unsafe_arena_set_allocated_message(
      ::std::string* message);

  // @@protoc_insertion_point(class_scope:tensorflow.LogMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::ArenaStringPtr message_;
  int level_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2futil_2fevent_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2futil_2fevent_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2futil_2fevent_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2futil_2fevent_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<LogMessage> LogMessage_default_instance_;

// -------------------------------------------------------------------

class SessionLog : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.SessionLog) */ {
 public:
  SessionLog();
  virtual ~SessionLog();

  SessionLog(const SessionLog& from);

  inline SessionLog& operator=(const SessionLog& from) {
    CopyFrom(from);
    return *this;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const SessionLog& default_instance();

  static const SessionLog* internal_default_instance();

  void UnsafeArenaSwap(SessionLog* other);
  void Swap(SessionLog* other);

  // implements Message ----------------------------------------------

  inline SessionLog* New() const { return New(NULL); }

  SessionLog* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SessionLog& from);
  void MergeFrom(const SessionLog& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SessionLog* other);
  void UnsafeMergeFrom(const SessionLog& from);
  protected:
  explicit SessionLog(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef SessionLog_SessionStatus SessionStatus;
  static const SessionStatus STATUS_UNSPECIFIED =
    SessionLog_SessionStatus_STATUS_UNSPECIFIED;
  static const SessionStatus START =
    SessionLog_SessionStatus_START;
  static const SessionStatus STOP =
    SessionLog_SessionStatus_STOP;
  static const SessionStatus CHECKPOINT =
    SessionLog_SessionStatus_CHECKPOINT;
  static inline bool SessionStatus_IsValid(int value) {
    return SessionLog_SessionStatus_IsValid(value);
  }
  static const SessionStatus SessionStatus_MIN =
    SessionLog_SessionStatus_SessionStatus_MIN;
  static const SessionStatus SessionStatus_MAX =
    SessionLog_SessionStatus_SessionStatus_MAX;
  static const int SessionStatus_ARRAYSIZE =
    SessionLog_SessionStatus_SessionStatus_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  SessionStatus_descriptor() {
    return SessionLog_SessionStatus_descriptor();
  }
  static inline const ::std::string& SessionStatus_Name(SessionStatus value) {
    return SessionLog_SessionStatus_Name(value);
  }
  static inline bool SessionStatus_Parse(const ::std::string& name,
      SessionStatus* value) {
    return SessionLog_SessionStatus_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional .tensorflow.SessionLog.SessionStatus status = 1;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  ::tensorflow::SessionLog_SessionStatus status() const;
  void set_status(::tensorflow::SessionLog_SessionStatus value);

  // optional string checkpoint_path = 2;
  void clear_checkpoint_path();
  static const int kCheckpointPathFieldNumber = 2;
  const ::std::string& checkpoint_path() const;
  void set_checkpoint_path(const ::std::string& value);
  void set_checkpoint_path(const char* value);
  void set_checkpoint_path(const char* value, size_t size);
  ::std::string* mutable_checkpoint_path();
  ::std::string* release_checkpoint_path();
  void set_allocated_checkpoint_path(::std::string* checkpoint_path);
  ::std::string* unsafe_arena_release_checkpoint_path();
  void unsafe_arena_set_allocated_checkpoint_path(
      ::std::string* checkpoint_path);

  // optional string msg = 3;
  void clear_msg();
  static const int kMsgFieldNumber = 3;
  const ::std::string& msg() const;
  void set_msg(const ::std::string& value);
  void set_msg(const char* value);
  void set_msg(const char* value, size_t size);
  ::std::string* mutable_msg();
  ::std::string* release_msg();
  void set_allocated_msg(::std::string* msg);
  ::std::string* unsafe_arena_release_msg();
  void unsafe_arena_set_allocated_msg(
      ::std::string* msg);

  // @@protoc_insertion_point(class_scope:tensorflow.SessionLog)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::ArenaStringPtr checkpoint_path_;
  ::google::protobuf::internal::ArenaStringPtr msg_;
  int status_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2futil_2fevent_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2futil_2fevent_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2futil_2fevent_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2futil_2fevent_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<SessionLog> SessionLog_default_instance_;

// -------------------------------------------------------------------

class TaggedRunMetadata : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.TaggedRunMetadata) */ {
 public:
  TaggedRunMetadata();
  virtual ~TaggedRunMetadata();

  TaggedRunMetadata(const TaggedRunMetadata& from);

  inline TaggedRunMetadata& operator=(const TaggedRunMetadata& from) {
    CopyFrom(from);
    return *this;
  }

  inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); }
  inline void* GetMaybeArenaPointer() const {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TaggedRunMetadata& default_instance();

  static const TaggedRunMetadata* internal_default_instance();

  void UnsafeArenaSwap(TaggedRunMetadata* other);
  void Swap(TaggedRunMetadata* other);

  // implements Message ----------------------------------------------

  inline TaggedRunMetadata* New() const { return New(NULL); }

  TaggedRunMetadata* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TaggedRunMetadata& from);
  void MergeFrom(const TaggedRunMetadata& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TaggedRunMetadata* other);
  void UnsafeMergeFrom(const TaggedRunMetadata& from);
  protected:
  explicit TaggedRunMetadata(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string tag = 1;
  void clear_tag();
  static const int kTagFieldNumber = 1;
  const ::std::string& tag() const;
  void set_tag(const ::std::string& value);
  void set_tag(const char* value);
  void set_tag(const char* value, size_t size);
  ::std::string* mutable_tag();
  ::std::string* release_tag();
  void set_allocated_tag(::std::string* tag);
  ::std::string* unsafe_arena_release_tag();
  void unsafe_arena_set_allocated_tag(
      ::std::string* tag);

  // optional bytes run_metadata = 2;
  void clear_run_metadata();
  static const int kRunMetadataFieldNumber = 2;
  const ::std::string& run_metadata() const;
  void set_run_metadata(const ::std::string& value);
  void set_run_metadata(const char* value);
  void set_run_metadata(const void* value, size_t size);
  ::std::string* mutable_run_metadata();
  ::std::string* release_run_metadata();
  void set_allocated_run_metadata(::std::string* run_metadata);
  ::std::string* unsafe_arena_release_run_metadata();
  void unsafe_arena_set_allocated_run_metadata(
      ::std::string* run_metadata);

  // @@protoc_insertion_point(class_scope:tensorflow.TaggedRunMetadata)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  friend class ::google::protobuf::Arena;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::ArenaStringPtr tag_;
  ::google::protobuf::internal::ArenaStringPtr run_metadata_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_tensorflow_2fcore_2futil_2fevent_2eproto_impl();
  friend void  protobuf_AddDesc_tensorflow_2fcore_2futil_2fevent_2eproto_impl();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2futil_2fevent_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2futil_2fevent_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<TaggedRunMetadata> TaggedRunMetadata_default_instance_;

// ===================================================================


// ===================================================================

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// Event

// optional double wall_time = 1;
inline void Event::clear_wall_time() {
  wall_time_ = 0;
}
inline double Event::wall_time() const {
  // @@protoc_insertion_point(field_get:tensorflow.Event.wall_time)
  return wall_time_;
}
inline void Event::set_wall_time(double value) {
  
  wall_time_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.Event.wall_time)
}

// optional int64 step = 2;
inline void Event::clear_step() {
  step_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 Event::step() const {
  // @@protoc_insertion_point(field_get:tensorflow.Event.step)
  return step_;
}
inline void Event::set_step(::google::protobuf::int64 value) {
  
  step_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.Event.step)
}

// optional string file_version = 3;
inline bool Event::has_file_version() const {
  return what_case() == kFileVersion;
}
inline void Event::set_has_file_version() {
  _oneof_case_[0] = kFileVersion;
}
inline void Event::clear_file_version() {
  if (has_file_version()) {
    what_.file_version_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_what();
  }
}
inline const ::std::string& Event::file_version() const {
  // @@protoc_insertion_point(field_get:tensorflow.Event.file_version)
  if (has_file_version()) {
    return what_.file_version_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void Event::set_file_version(const ::std::string& value) {
  if (!has_file_version()) {
    clear_what();
    set_has_file_version();
    what_.file_version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  what_.file_version_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.Event.file_version)
}
inline void Event::set_file_version(const char* value) {
  if (!has_file_version()) {
    clear_what();
    set_has_file_version();
    what_.file_version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  what_.file_version_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.Event.file_version)
}
inline void Event::set_file_version(const char* value,
                             size_t size) {
  if (!has_file_version()) {
    clear_what();
    set_has_file_version();
    what_.file_version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  what_.file_version_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.Event.file_version)
}
inline ::std::string* Event::mutable_file_version() {
  if (!has_file_version()) {
    clear_what();
    set_has_file_version();
    what_.file_version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return what_.file_version_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:tensorflow.Event.file_version)
}
inline ::std::string* Event::release_file_version() {
  // @@protoc_insertion_point(field_release:tensorflow.Event.file_version)
  if (has_file_version()) {
    clear_has_what();
    return what_.file_version_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline ::std::string* Event::unsafe_arena_release_file_version() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Event.file_version)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_file_version()) {
    clear_has_what();
    return what_.file_version_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void Event::set_allocated_file_version(::std::string* file_version) {
  if (!has_file_version()) {
    what_.file_version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_what();
  if (file_version != NULL) {
    set_has_file_version();
    what_.file_version_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), file_version,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.file_version)
}
inline void Event::unsafe_arena_set_allocated_file_version(::std::string* file_version) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_file_version()) {
    what_.file_version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_what();
  if (file_version) {
    set_has_file_version();
    what_.file_version_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), file_version, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Event.file_version)
}

// optional bytes graph_def = 4;
inline bool Event::has_graph_def() const {
  return what_case() == kGraphDef;
}
inline void Event::set_has_graph_def() {
  _oneof_case_[0] = kGraphDef;
}
inline void Event::clear_graph_def() {
  if (has_graph_def()) {
    what_.graph_def_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_what();
  }
}
inline const ::std::string& Event::graph_def() const {
  // @@protoc_insertion_point(field_get:tensorflow.Event.graph_def)
  if (has_graph_def()) {
    return what_.graph_def_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void Event::set_graph_def(const ::std::string& value) {
  if (!has_graph_def()) {
    clear_what();
    set_has_graph_def();
    what_.graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  what_.graph_def_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.Event.graph_def)
}
inline void Event::set_graph_def(const char* value) {
  if (!has_graph_def()) {
    clear_what();
    set_has_graph_def();
    what_.graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  what_.graph_def_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.Event.graph_def)
}
inline void Event::set_graph_def(const void* value,
                             size_t size) {
  if (!has_graph_def()) {
    clear_what();
    set_has_graph_def();
    what_.graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  what_.graph_def_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.Event.graph_def)
}
inline ::std::string* Event::mutable_graph_def() {
  if (!has_graph_def()) {
    clear_what();
    set_has_graph_def();
    what_.graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return what_.graph_def_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:tensorflow.Event.graph_def)
}
inline ::std::string* Event::release_graph_def() {
  // @@protoc_insertion_point(field_release:tensorflow.Event.graph_def)
  if (has_graph_def()) {
    clear_has_what();
    return what_.graph_def_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline ::std::string* Event::unsafe_arena_release_graph_def() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Event.graph_def)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_graph_def()) {
    clear_has_what();
    return what_.graph_def_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void Event::set_allocated_graph_def(::std::string* graph_def) {
  if (!has_graph_def()) {
    what_.graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_what();
  if (graph_def != NULL) {
    set_has_graph_def();
    what_.graph_def_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), graph_def,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.graph_def)
}
inline void Event::unsafe_arena_set_allocated_graph_def(::std::string* graph_def) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_graph_def()) {
    what_.graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_what();
  if (graph_def) {
    set_has_graph_def();
    what_.graph_def_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), graph_def, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Event.graph_def)
}

// optional .tensorflow.Summary summary = 5;
inline bool Event::has_summary() const {
  return what_case() == kSummary;
}
inline void Event::set_has_summary() {
  _oneof_case_[0] = kSummary;
}
inline void Event::clear_summary() {
  if (has_summary()) {
    if (GetArenaNoVirtual() == NULL) {
      delete what_.summary_;
    }
    clear_has_what();
  }
}
inline  const ::tensorflow::Summary& Event::summary() const {
  // @@protoc_insertion_point(field_get:tensorflow.Event.summary)
  return has_summary()
      ? *what_.summary_
      : ::tensorflow::Summary::default_instance();
}
inline ::tensorflow::Summary* Event::mutable_summary() {
  if (!has_summary()) {
    clear_what();
    set_has_summary();
    what_.summary_ = 
      ::google::protobuf::Arena::CreateMessage< ::tensorflow::Summary >(
      GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.Event.summary)
  return what_.summary_;
}
inline ::tensorflow::Summary* Event::release_summary() {
  // @@protoc_insertion_point(field_release:tensorflow.Event.summary)
  if (has_summary()) {
    clear_has_what();
    if (GetArenaNoVirtual() != NULL) {
      ::tensorflow::Summary* temp = new ::tensorflow::Summary(*what_.summary_);
      what_.summary_ = NULL;
      return temp;
    } else {
      ::tensorflow::Summary* temp = what_.summary_;
      what_.summary_ = NULL;
      return temp;
    }
  } else {
    return NULL;
  }
}
inline void Event::set_allocated_summary(::tensorflow::Summary* summary) {
  clear_what();
  if (summary) {
    if (GetArenaNoVirtual() != NULL &&
        ::google::protobuf::Arena::GetArena(summary) == NULL) {
      GetArenaNoVirtual()->Own(summary);
    } else if (GetArenaNoVirtual() !=
               ::google::protobuf::Arena::GetArena(summary)) {
      ::tensorflow::Summary* new_summary = 
          ::google::protobuf::Arena::CreateMessage< ::tensorflow::Summary >(
          GetArenaNoVirtual());
      new_summary->CopyFrom(*summary);
      summary = new_summary;
    }
    set_has_summary();
    what_.summary_ = summary;
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.summary)
}
inline  ::tensorflow::Summary* Event::unsafe_arena_release_summary() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Event.summary)
  if (has_summary()) {
    clear_has_what();
    ::tensorflow::Summary* temp = what_.summary_;
    what_.summary_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline  void Event::unsafe_arena_set_allocated_summary(::tensorflow::Summary* summary) {
  clear_what();
  if (summary) {
    set_has_summary();
    what_.summary_ = summary;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Event.summary)
}

// optional .tensorflow.LogMessage log_message = 6;
inline bool Event::has_log_message() const {
  return what_case() == kLogMessage;
}
inline void Event::set_has_log_message() {
  _oneof_case_[0] = kLogMessage;
}
inline void Event::clear_log_message() {
  if (has_log_message()) {
    if (GetArenaNoVirtual() == NULL) {
      delete what_.log_message_;
    }
    clear_has_what();
  }
}
inline  const ::tensorflow::LogMessage& Event::log_message() const {
  // @@protoc_insertion_point(field_get:tensorflow.Event.log_message)
  return has_log_message()
      ? *what_.log_message_
      : ::tensorflow::LogMessage::default_instance();
}
inline ::tensorflow::LogMessage* Event::mutable_log_message() {
  if (!has_log_message()) {
    clear_what();
    set_has_log_message();
    what_.log_message_ = 
      ::google::protobuf::Arena::CreateMessage< ::tensorflow::LogMessage >(
      GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.Event.log_message)
  return what_.log_message_;
}
inline ::tensorflow::LogMessage* Event::release_log_message() {
  // @@protoc_insertion_point(field_release:tensorflow.Event.log_message)
  if (has_log_message()) {
    clear_has_what();
    if (GetArenaNoVirtual() != NULL) {
      ::tensorflow::LogMessage* temp = new ::tensorflow::LogMessage(*what_.log_message_);
      what_.log_message_ = NULL;
      return temp;
    } else {
      ::tensorflow::LogMessage* temp = what_.log_message_;
      what_.log_message_ = NULL;
      return temp;
    }
  } else {
    return NULL;
  }
}
inline void Event::set_allocated_log_message(::tensorflow::LogMessage* log_message) {
  clear_what();
  if (log_message) {
    if (GetArenaNoVirtual() != NULL &&
        ::google::protobuf::Arena::GetArena(log_message) == NULL) {
      GetArenaNoVirtual()->Own(log_message);
    } else if (GetArenaNoVirtual() !=
               ::google::protobuf::Arena::GetArena(log_message)) {
      ::tensorflow::LogMessage* new_log_message = 
          ::google::protobuf::Arena::CreateMessage< ::tensorflow::LogMessage >(
          GetArenaNoVirtual());
      new_log_message->CopyFrom(*log_message);
      log_message = new_log_message;
    }
    set_has_log_message();
    what_.log_message_ = log_message;
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.log_message)
}
inline  ::tensorflow::LogMessage* Event::unsafe_arena_release_log_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Event.log_message)
  if (has_log_message()) {
    clear_has_what();
    ::tensorflow::LogMessage* temp = what_.log_message_;
    what_.log_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline  void Event::unsafe_arena_set_allocated_log_message(::tensorflow::LogMessage* log_message) {
  clear_what();
  if (log_message) {
    set_has_log_message();
    what_.log_message_ = log_message;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Event.log_message)
}

// optional .tensorflow.SessionLog session_log = 7;
inline bool Event::has_session_log() const {
  return what_case() == kSessionLog;
}
inline void Event::set_has_session_log() {
  _oneof_case_[0] = kSessionLog;
}
inline void Event::clear_session_log() {
  if (has_session_log()) {
    if (GetArenaNoVirtual() == NULL) {
      delete what_.session_log_;
    }
    clear_has_what();
  }
}
inline  const ::tensorflow::SessionLog& Event::session_log() const {
  // @@protoc_insertion_point(field_get:tensorflow.Event.session_log)
  return has_session_log()
      ? *what_.session_log_
      : ::tensorflow::SessionLog::default_instance();
}
inline ::tensorflow::SessionLog* Event::mutable_session_log() {
  if (!has_session_log()) {
    clear_what();
    set_has_session_log();
    what_.session_log_ = 
      ::google::protobuf::Arena::CreateMessage< ::tensorflow::SessionLog >(
      GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.Event.session_log)
  return what_.session_log_;
}
inline ::tensorflow::SessionLog* Event::release_session_log() {
  // @@protoc_insertion_point(field_release:tensorflow.Event.session_log)
  if (has_session_log()) {
    clear_has_what();
    if (GetArenaNoVirtual() != NULL) {
      ::tensorflow::SessionLog* temp = new ::tensorflow::SessionLog(*what_.session_log_);
      what_.session_log_ = NULL;
      return temp;
    } else {
      ::tensorflow::SessionLog* temp = what_.session_log_;
      what_.session_log_ = NULL;
      return temp;
    }
  } else {
    return NULL;
  }
}
inline void Event::set_allocated_session_log(::tensorflow::SessionLog* session_log) {
  clear_what();
  if (session_log) {
    if (GetArenaNoVirtual() != NULL &&
        ::google::protobuf::Arena::GetArena(session_log) == NULL) {
      GetArenaNoVirtual()->Own(session_log);
    } else if (GetArenaNoVirtual() !=
               ::google::protobuf::Arena::GetArena(session_log)) {
      ::tensorflow::SessionLog* new_session_log = 
          ::google::protobuf::Arena::CreateMessage< ::tensorflow::SessionLog >(
          GetArenaNoVirtual());
      new_session_log->CopyFrom(*session_log);
      session_log = new_session_log;
    }
    set_has_session_log();
    what_.session_log_ = session_log;
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.session_log)
}
inline  ::tensorflow::SessionLog* Event::unsafe_arena_release_session_log() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Event.session_log)
  if (has_session_log()) {
    clear_has_what();
    ::tensorflow::SessionLog* temp = what_.session_log_;
    what_.session_log_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline  void Event::unsafe_arena_set_allocated_session_log(::tensorflow::SessionLog* session_log) {
  clear_what();
  if (session_log) {
    set_has_session_log();
    what_.session_log_ = session_log;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Event.session_log)
}

// optional .tensorflow.TaggedRunMetadata tagged_run_metadata = 8;
inline bool Event::has_tagged_run_metadata() const {
  return what_case() == kTaggedRunMetadata;
}
inline void Event::set_has_tagged_run_metadata() {
  _oneof_case_[0] = kTaggedRunMetadata;
}
inline void Event::clear_tagged_run_metadata() {
  if (has_tagged_run_metadata()) {
    if (GetArenaNoVirtual() == NULL) {
      delete what_.tagged_run_metadata_;
    }
    clear_has_what();
  }
}
inline  const ::tensorflow::TaggedRunMetadata& Event::tagged_run_metadata() const {
  // @@protoc_insertion_point(field_get:tensorflow.Event.tagged_run_metadata)
  return has_tagged_run_metadata()
      ? *what_.tagged_run_metadata_
      : ::tensorflow::TaggedRunMetadata::default_instance();
}
inline ::tensorflow::TaggedRunMetadata* Event::mutable_tagged_run_metadata() {
  if (!has_tagged_run_metadata()) {
    clear_what();
    set_has_tagged_run_metadata();
    what_.tagged_run_metadata_ = 
      ::google::protobuf::Arena::CreateMessage< ::tensorflow::TaggedRunMetadata >(
      GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.Event.tagged_run_metadata)
  return what_.tagged_run_metadata_;
}
inline ::tensorflow::TaggedRunMetadata* Event::release_tagged_run_metadata() {
  // @@protoc_insertion_point(field_release:tensorflow.Event.tagged_run_metadata)
  if (has_tagged_run_metadata()) {
    clear_has_what();
    if (GetArenaNoVirtual() != NULL) {
      ::tensorflow::TaggedRunMetadata* temp = new ::tensorflow::TaggedRunMetadata(*what_.tagged_run_metadata_);
      what_.tagged_run_metadata_ = NULL;
      return temp;
    } else {
      ::tensorflow::TaggedRunMetadata* temp = what_.tagged_run_metadata_;
      what_.tagged_run_metadata_ = NULL;
      return temp;
    }
  } else {
    return NULL;
  }
}
inline void Event::set_allocated_tagged_run_metadata(::tensorflow::TaggedRunMetadata* tagged_run_metadata) {
  clear_what();
  if (tagged_run_metadata) {
    if (GetArenaNoVirtual() != NULL &&
        ::google::protobuf::Arena::GetArena(tagged_run_metadata) == NULL) {
      GetArenaNoVirtual()->Own(tagged_run_metadata);
    } else if (GetArenaNoVirtual() !=
               ::google::protobuf::Arena::GetArena(tagged_run_metadata)) {
      ::tensorflow::TaggedRunMetadata* new_tagged_run_metadata = 
          ::google::protobuf::Arena::CreateMessage< ::tensorflow::TaggedRunMetadata >(
          GetArenaNoVirtual());
      new_tagged_run_metadata->CopyFrom(*tagged_run_metadata);
      tagged_run_metadata = new_tagged_run_metadata;
    }
    set_has_tagged_run_metadata();
    what_.tagged_run_metadata_ = tagged_run_metadata;
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.tagged_run_metadata)
}
inline  ::tensorflow::TaggedRunMetadata* Event::unsafe_arena_release_tagged_run_metadata() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Event.tagged_run_metadata)
  if (has_tagged_run_metadata()) {
    clear_has_what();
    ::tensorflow::TaggedRunMetadata* temp = what_.tagged_run_metadata_;
    what_.tagged_run_metadata_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline  void Event::unsafe_arena_set_allocated_tagged_run_metadata(::tensorflow::TaggedRunMetadata* tagged_run_metadata) {
  clear_what();
  if (tagged_run_metadata) {
    set_has_tagged_run_metadata();
    what_.tagged_run_metadata_ = tagged_run_metadata;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Event.tagged_run_metadata)
}

// optional bytes meta_graph_def = 9;
inline bool Event::has_meta_graph_def() const {
  return what_case() == kMetaGraphDef;
}
inline void Event::set_has_meta_graph_def() {
  _oneof_case_[0] = kMetaGraphDef;
}
inline void Event::clear_meta_graph_def() {
  if (has_meta_graph_def()) {
    what_.meta_graph_def_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_what();
  }
}
inline const ::std::string& Event::meta_graph_def() const {
  // @@protoc_insertion_point(field_get:tensorflow.Event.meta_graph_def)
  if (has_meta_graph_def()) {
    return what_.meta_graph_def_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void Event::set_meta_graph_def(const ::std::string& value) {
  if (!has_meta_graph_def()) {
    clear_what();
    set_has_meta_graph_def();
    what_.meta_graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  what_.meta_graph_def_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.Event.meta_graph_def)
}
inline void Event::set_meta_graph_def(const char* value) {
  if (!has_meta_graph_def()) {
    clear_what();
    set_has_meta_graph_def();
    what_.meta_graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  what_.meta_graph_def_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.Event.meta_graph_def)
}
inline void Event::set_meta_graph_def(const void* value,
                             size_t size) {
  if (!has_meta_graph_def()) {
    clear_what();
    set_has_meta_graph_def();
    what_.meta_graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  what_.meta_graph_def_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.Event.meta_graph_def)
}
inline ::std::string* Event::mutable_meta_graph_def() {
  if (!has_meta_graph_def()) {
    clear_what();
    set_has_meta_graph_def();
    what_.meta_graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return what_.meta_graph_def_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:tensorflow.Event.meta_graph_def)
}
inline ::std::string* Event::release_meta_graph_def() {
  // @@protoc_insertion_point(field_release:tensorflow.Event.meta_graph_def)
  if (has_meta_graph_def()) {
    clear_has_what();
    return what_.meta_graph_def_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline ::std::string* Event::unsafe_arena_release_meta_graph_def() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Event.meta_graph_def)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_meta_graph_def()) {
    clear_has_what();
    return what_.meta_graph_def_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void Event::set_allocated_meta_graph_def(::std::string* meta_graph_def) {
  if (!has_meta_graph_def()) {
    what_.meta_graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_what();
  if (meta_graph_def != NULL) {
    set_has_meta_graph_def();
    what_.meta_graph_def_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), meta_graph_def,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.meta_graph_def)
}
inline void Event::unsafe_arena_set_allocated_meta_graph_def(::std::string* meta_graph_def) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_meta_graph_def()) {
    what_.meta_graph_def_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_what();
  if (meta_graph_def) {
    set_has_meta_graph_def();
    what_.meta_graph_def_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), meta_graph_def, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Event.meta_graph_def)
}

inline bool Event::has_what() const {
  return what_case() != WHAT_NOT_SET;
}
inline void Event::clear_has_what() {
  _oneof_case_[0] = WHAT_NOT_SET;
}
inline Event::WhatCase Event::what_case() const {
  return Event::WhatCase(_oneof_case_[0]);
}
inline const Event* Event::internal_default_instance() {
  return &Event_default_instance_.get();
}
// -------------------------------------------------------------------

// LogMessage

// optional .tensorflow.LogMessage.Level level = 1;
inline void LogMessage::clear_level() {
  level_ = 0;
}
inline ::tensorflow::LogMessage_Level LogMessage::level() const {
  // @@protoc_insertion_point(field_get:tensorflow.LogMessage.level)
  return static_cast< ::tensorflow::LogMessage_Level >(level_);
}
inline void LogMessage::set_level(::tensorflow::LogMessage_Level value) {
  
  level_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.LogMessage.level)
}

// optional string message = 2;
inline void LogMessage::clear_message() {
  message_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& LogMessage::message() const {
  // @@protoc_insertion_point(field_get:tensorflow.LogMessage.message)
  return message_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LogMessage::set_message(const ::std::string& value) {
  
  message_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.LogMessage.message)
}
inline void LogMessage::set_message(const char* value) {
  
  message_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.LogMessage.message)
}
inline void LogMessage::set_message(const char* value,
    size_t size) {
  
  message_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.LogMessage.message)
}
inline ::std::string* LogMessage::mutable_message() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.LogMessage.message)
  return message_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* LogMessage::release_message() {
  // @@protoc_insertion_point(field_release:tensorflow.LogMessage.message)
  
  return message_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* LogMessage::unsafe_arena_release_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.LogMessage.message)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return message_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void LogMessage::set_allocated_message(::std::string* message) {
  if (message != NULL) {
    
  } else {
    
  }
  message_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.LogMessage.message)
}
inline void LogMessage::unsafe_arena_set_allocated_message(
    ::std::string* message) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (message != NULL) {
    
  } else {
    
  }
  message_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      message, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.LogMessage.message)
}

inline const LogMessage* LogMessage::internal_default_instance() {
  return &LogMessage_default_instance_.get();
}
// -------------------------------------------------------------------

// SessionLog

// optional .tensorflow.SessionLog.SessionStatus status = 1;
inline void SessionLog::clear_status() {
  status_ = 0;
}
inline ::tensorflow::SessionLog_SessionStatus SessionLog::status() const {
  // @@protoc_insertion_point(field_get:tensorflow.SessionLog.status)
  return static_cast< ::tensorflow::SessionLog_SessionStatus >(status_);
}
inline void SessionLog::set_status(::tensorflow::SessionLog_SessionStatus value) {
  
  status_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.SessionLog.status)
}

// optional string checkpoint_path = 2;
inline void SessionLog::clear_checkpoint_path() {
  checkpoint_path_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& SessionLog::checkpoint_path() const {
  // @@protoc_insertion_point(field_get:tensorflow.SessionLog.checkpoint_path)
  return checkpoint_path_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SessionLog::set_checkpoint_path(const ::std::string& value) {
  
  checkpoint_path_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.SessionLog.checkpoint_path)
}
inline void SessionLog::set_checkpoint_path(const char* value) {
  
  checkpoint_path_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.SessionLog.checkpoint_path)
}
inline void SessionLog::set_checkpoint_path(const char* value,
    size_t size) {
  
  checkpoint_path_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.SessionLog.checkpoint_path)
}
inline ::std::string* SessionLog::mutable_checkpoint_path() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.SessionLog.checkpoint_path)
  return checkpoint_path_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* SessionLog::release_checkpoint_path() {
  // @@protoc_insertion_point(field_release:tensorflow.SessionLog.checkpoint_path)
  
  return checkpoint_path_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* SessionLog::unsafe_arena_release_checkpoint_path() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SessionLog.checkpoint_path)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return checkpoint_path_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void SessionLog::set_allocated_checkpoint_path(::std::string* checkpoint_path) {
  if (checkpoint_path != NULL) {
    
  } else {
    
  }
  checkpoint_path_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), checkpoint_path,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.SessionLog.checkpoint_path)
}
inline void SessionLog::unsafe_arena_set_allocated_checkpoint_path(
    ::std::string* checkpoint_path) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (checkpoint_path != NULL) {
    
  } else {
    
  }
  checkpoint_path_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      checkpoint_path, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SessionLog.checkpoint_path)
}

// optional string msg = 3;
inline void SessionLog::clear_msg() {
  msg_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& SessionLog::msg() const {
  // @@protoc_insertion_point(field_get:tensorflow.SessionLog.msg)
  return msg_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SessionLog::set_msg(const ::std::string& value) {
  
  msg_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.SessionLog.msg)
}
inline void SessionLog::set_msg(const char* value) {
  
  msg_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.SessionLog.msg)
}
inline void SessionLog::set_msg(const char* value,
    size_t size) {
  
  msg_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.SessionLog.msg)
}
inline ::std::string* SessionLog::mutable_msg() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.SessionLog.msg)
  return msg_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* SessionLog::release_msg() {
  // @@protoc_insertion_point(field_release:tensorflow.SessionLog.msg)
  
  return msg_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* SessionLog::unsafe_arena_release_msg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SessionLog.msg)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return msg_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void SessionLog::set_allocated_msg(::std::string* msg) {
  if (msg != NULL) {
    
  } else {
    
  }
  msg_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), msg,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.SessionLog.msg)
}
inline void SessionLog::unsafe_arena_set_allocated_msg(
    ::std::string* msg) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (msg != NULL) {
    
  } else {
    
  }
  msg_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      msg, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SessionLog.msg)
}

inline const SessionLog* SessionLog::internal_default_instance() {
  return &SessionLog_default_instance_.get();
}
// -------------------------------------------------------------------

// TaggedRunMetadata

// optional string tag = 1;
inline void TaggedRunMetadata::clear_tag() {
  tag_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& TaggedRunMetadata::tag() const {
  // @@protoc_insertion_point(field_get:tensorflow.TaggedRunMetadata.tag)
  return tag_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TaggedRunMetadata::set_tag(const ::std::string& value) {
  
  tag_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.TaggedRunMetadata.tag)
}
inline void TaggedRunMetadata::set_tag(const char* value) {
  
  tag_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.TaggedRunMetadata.tag)
}
inline void TaggedRunMetadata::set_tag(const char* value,
    size_t size) {
  
  tag_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.TaggedRunMetadata.tag)
}
inline ::std::string* TaggedRunMetadata::mutable_tag() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.TaggedRunMetadata.tag)
  return tag_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TaggedRunMetadata::release_tag() {
  // @@protoc_insertion_point(field_release:tensorflow.TaggedRunMetadata.tag)
  
  return tag_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TaggedRunMetadata::unsafe_arena_release_tag() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TaggedRunMetadata.tag)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return tag_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TaggedRunMetadata::set_allocated_tag(::std::string* tag) {
  if (tag != NULL) {
    
  } else {
    
  }
  tag_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), tag,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TaggedRunMetadata.tag)
}
inline void TaggedRunMetadata::unsafe_arena_set_allocated_tag(
    ::std::string* tag) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (tag != NULL) {
    
  } else {
    
  }
  tag_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      tag, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TaggedRunMetadata.tag)
}

// optional bytes run_metadata = 2;
inline void TaggedRunMetadata::clear_run_metadata() {
  run_metadata_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& TaggedRunMetadata::run_metadata() const {
  // @@protoc_insertion_point(field_get:tensorflow.TaggedRunMetadata.run_metadata)
  return run_metadata_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TaggedRunMetadata::set_run_metadata(const ::std::string& value) {
  
  run_metadata_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.TaggedRunMetadata.run_metadata)
}
inline void TaggedRunMetadata::set_run_metadata(const char* value) {
  
  run_metadata_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.TaggedRunMetadata.run_metadata)
}
inline void TaggedRunMetadata::set_run_metadata(const void* value,
    size_t size) {
  
  run_metadata_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.TaggedRunMetadata.run_metadata)
}
inline ::std::string* TaggedRunMetadata::mutable_run_metadata() {
  
  // @@protoc_insertion_point(field_mutable:tensorflow.TaggedRunMetadata.run_metadata)
  return run_metadata_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TaggedRunMetadata::release_run_metadata() {
  // @@protoc_insertion_point(field_release:tensorflow.TaggedRunMetadata.run_metadata)
  
  return run_metadata_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TaggedRunMetadata::unsafe_arena_release_run_metadata() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TaggedRunMetadata.run_metadata)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  
  return run_metadata_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TaggedRunMetadata::set_allocated_run_metadata(::std::string* run_metadata) {
  if (run_metadata != NULL) {
    
  } else {
    
  }
  run_metadata_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), run_metadata,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TaggedRunMetadata.run_metadata)
}
inline void TaggedRunMetadata::unsafe_arena_set_allocated_run_metadata(
    ::std::string* run_metadata) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (run_metadata != NULL) {
    
  } else {
    
  }
  run_metadata_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      run_metadata, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TaggedRunMetadata.run_metadata)
}

inline const TaggedRunMetadata* TaggedRunMetadata::internal_default_instance() {
  return &TaggedRunMetadata_default_instance_.get();
}
#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace tensorflow

#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::tensorflow::LogMessage_Level> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::LogMessage_Level>() {
  return ::tensorflow::LogMessage_Level_descriptor();
}
template <> struct is_proto_enum< ::tensorflow::SessionLog_SessionStatus> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::SessionLog_SessionStatus>() {
  return ::tensorflow::SessionLog_SessionStatus_descriptor();
}

}  // namespace protobuf
}  // namespace google
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_tensorflow_2fcore_2futil_2fevent_2eproto__INCLUDED
