// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: client.proto

#ifndef PROTOBUF_client_2eproto__INCLUDED
#define PROTOBUF_client_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3003000
#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 3003002 < 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/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
#include "client_protocol.pb.h"
// @@protoc_insertion_point(includes)
namespace ipc {
namespace invalidation {
class AckHandleP;
class AckHandlePDefaultTypeInternal;
extern AckHandlePDefaultTypeInternal _AckHandleP_default_instance_;
class PersistentStateBlob;
class PersistentStateBlobDefaultTypeInternal;
extern PersistentStateBlobDefaultTypeInternal _PersistentStateBlob_default_instance_;
class PersistentTiclState;
class PersistentTiclStateDefaultTypeInternal;
extern PersistentTiclStateDefaultTypeInternal _PersistentTiclState_default_instance_;
class RunStateP;
class RunStatePDefaultTypeInternal;
extern RunStatePDefaultTypeInternal _RunStateP_default_instance_;
}  // namespace invalidation
}  // namespace ipc

namespace ipc {
namespace invalidation {

namespace protobuf_client_2eproto {
// Internal implementation detail -- do not call these.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[];
  static const ::google::protobuf::uint32 offsets[];
  static void InitDefaultsImpl();
  static void Shutdown();
};
void AddDescriptors();
void InitDefaults();
}  // namespace protobuf_client_2eproto

enum RunStateP_State {
  RunStateP_State_NOT_STARTED = 1,
  RunStateP_State_STARTED = 2,
  RunStateP_State_STOPPED = 3
};
bool RunStateP_State_IsValid(int value);
const RunStateP_State RunStateP_State_State_MIN = RunStateP_State_NOT_STARTED;
const RunStateP_State RunStateP_State_State_MAX = RunStateP_State_STOPPED;
const int RunStateP_State_State_ARRAYSIZE = RunStateP_State_State_MAX + 1;

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

class AckHandleP : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:ipc.invalidation.AckHandleP) */ {
 public:
  AckHandleP();
  virtual ~AckHandleP();

  AckHandleP(const AckHandleP& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const AckHandleP& default_instance();

  static inline const AckHandleP* internal_default_instance() {
    return reinterpret_cast<const AckHandleP*>(
               &_AckHandleP_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    0;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(AckHandleP* other);

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

  inline AckHandleP* New() const PROTOBUF_FINAL { return New(NULL); }

  AckHandleP* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const AckHandleP& from);
  void MergeFrom(const AckHandleP& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AckHandleP* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional .ipc.invalidation.InvalidationP invalidation = 1;
  bool has_invalidation() const;
  void clear_invalidation();
  static const int kInvalidationFieldNumber = 1;
  const ::ipc::invalidation::InvalidationP& invalidation() const;
  ::ipc::invalidation::InvalidationP* mutable_invalidation();
  ::ipc::invalidation::InvalidationP* release_invalidation();
  void set_allocated_invalidation(::ipc::invalidation::InvalidationP* invalidation);

  // @@protoc_insertion_point(class_scope:ipc.invalidation.AckHandleP)
 private:
  void set_has_invalidation();
  void clear_has_invalidation();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::ipc::invalidation::InvalidationP* invalidation_;
  friend struct protobuf_client_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class PersistentTiclState : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:ipc.invalidation.PersistentTiclState) */ {
 public:
  PersistentTiclState();
  virtual ~PersistentTiclState();

  PersistentTiclState(const PersistentTiclState& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const PersistentTiclState& default_instance();

  static inline const PersistentTiclState* internal_default_instance() {
    return reinterpret_cast<const PersistentTiclState*>(
               &_PersistentTiclState_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    1;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(PersistentTiclState* other);

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

  inline PersistentTiclState* New() const PROTOBUF_FINAL { return New(NULL); }

  PersistentTiclState* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const PersistentTiclState& from);
  void MergeFrom(const PersistentTiclState& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PersistentTiclState* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional bytes client_token = 1;
  bool has_client_token() const;
  void clear_client_token();
  static const int kClientTokenFieldNumber = 1;
  const ::std::string& client_token() const;
  void set_client_token(const ::std::string& value);
  #if LANG_CXX11
  void set_client_token(::std::string&& value);
  #endif
  void set_client_token(const char* value);
  void set_client_token(const void* value, size_t size);
  ::std::string* mutable_client_token();
  ::std::string* release_client_token();
  void set_allocated_client_token(::std::string* client_token);

  // optional int64 last_message_send_time_ms = 2 [default = 0];
  bool has_last_message_send_time_ms() const;
  void clear_last_message_send_time_ms();
  static const int kLastMessageSendTimeMsFieldNumber = 2;
  ::google::protobuf::int64 last_message_send_time_ms() const;
  void set_last_message_send_time_ms(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:ipc.invalidation.PersistentTiclState)
 private:
  void set_has_client_token();
  void clear_has_client_token();
  void set_has_last_message_send_time_ms();
  void clear_has_last_message_send_time_ms();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr client_token_;
  ::google::protobuf::int64 last_message_send_time_ms_;
  friend struct protobuf_client_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class PersistentStateBlob : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:ipc.invalidation.PersistentStateBlob) */ {
 public:
  PersistentStateBlob();
  virtual ~PersistentStateBlob();

  PersistentStateBlob(const PersistentStateBlob& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const PersistentStateBlob& default_instance();

  static inline const PersistentStateBlob* internal_default_instance() {
    return reinterpret_cast<const PersistentStateBlob*>(
               &_PersistentStateBlob_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    2;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(PersistentStateBlob* other);

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

  inline PersistentStateBlob* New() const PROTOBUF_FINAL { return New(NULL); }

  PersistentStateBlob* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const PersistentStateBlob& from);
  void MergeFrom(const PersistentStateBlob& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PersistentStateBlob* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional bytes authentication_code = 2;
  bool has_authentication_code() const;
  void clear_authentication_code();
  static const int kAuthenticationCodeFieldNumber = 2;
  const ::std::string& authentication_code() const;
  void set_authentication_code(const ::std::string& value);
  #if LANG_CXX11
  void set_authentication_code(::std::string&& value);
  #endif
  void set_authentication_code(const char* value);
  void set_authentication_code(const void* value, size_t size);
  ::std::string* mutable_authentication_code();
  ::std::string* release_authentication_code();
  void set_allocated_authentication_code(::std::string* authentication_code);

  // optional .ipc.invalidation.PersistentTiclState ticl_state = 1;
  bool has_ticl_state() const;
  void clear_ticl_state();
  static const int kTiclStateFieldNumber = 1;
  const ::ipc::invalidation::PersistentTiclState& ticl_state() const;
  ::ipc::invalidation::PersistentTiclState* mutable_ticl_state();
  ::ipc::invalidation::PersistentTiclState* release_ticl_state();
  void set_allocated_ticl_state(::ipc::invalidation::PersistentTiclState* ticl_state);

  // @@protoc_insertion_point(class_scope:ipc.invalidation.PersistentStateBlob)
 private:
  void set_has_ticl_state();
  void clear_has_ticl_state();
  void set_has_authentication_code();
  void clear_has_authentication_code();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr authentication_code_;
  ::ipc::invalidation::PersistentTiclState* ticl_state_;
  friend struct protobuf_client_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RunStateP : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:ipc.invalidation.RunStateP) */ {
 public:
  RunStateP();
  virtual ~RunStateP();

  RunStateP(const RunStateP& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const RunStateP& default_instance();

  static inline const RunStateP* internal_default_instance() {
    return reinterpret_cast<const RunStateP*>(
               &_RunStateP_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    3;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(RunStateP* other);

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

  inline RunStateP* New() const PROTOBUF_FINAL { return New(NULL); }

  RunStateP* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const RunStateP& from);
  void MergeFrom(const RunStateP& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RunStateP* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

  typedef RunStateP_State State;
  static const State NOT_STARTED =
    RunStateP_State_NOT_STARTED;
  static const State STARTED =
    RunStateP_State_STARTED;
  static const State STOPPED =
    RunStateP_State_STOPPED;
  static inline bool State_IsValid(int value) {
    return RunStateP_State_IsValid(value);
  }
  static const State State_MIN =
    RunStateP_State_State_MIN;
  static const State State_MAX =
    RunStateP_State_State_MAX;
  static const int State_ARRAYSIZE =
    RunStateP_State_State_ARRAYSIZE;

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

  // optional .ipc.invalidation.RunStateP.State state = 1;
  bool has_state() const;
  void clear_state();
  static const int kStateFieldNumber = 1;
  ::ipc::invalidation::RunStateP_State state() const;
  void set_state(::ipc::invalidation::RunStateP_State value);

  // @@protoc_insertion_point(class_scope:ipc.invalidation.RunStateP)
 private:
  void set_has_state();
  void clear_has_state();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  int state_;
  friend struct protobuf_client_2eproto::TableStruct;
};
// ===================================================================


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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// AckHandleP

// optional .ipc.invalidation.InvalidationP invalidation = 1;
inline bool AckHandleP::has_invalidation() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AckHandleP::set_has_invalidation() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AckHandleP::clear_has_invalidation() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AckHandleP::clear_invalidation() {
  if (invalidation_ != NULL) invalidation_->::ipc::invalidation::InvalidationP::Clear();
  clear_has_invalidation();
}
inline const ::ipc::invalidation::InvalidationP& AckHandleP::invalidation() const {
  // @@protoc_insertion_point(field_get:ipc.invalidation.AckHandleP.invalidation)
  return invalidation_ != NULL ? *invalidation_
                         : *::ipc::invalidation::InvalidationP::internal_default_instance();
}
inline ::ipc::invalidation::InvalidationP* AckHandleP::mutable_invalidation() {
  set_has_invalidation();
  if (invalidation_ == NULL) {
    invalidation_ = new ::ipc::invalidation::InvalidationP;
  }
  // @@protoc_insertion_point(field_mutable:ipc.invalidation.AckHandleP.invalidation)
  return invalidation_;
}
inline ::ipc::invalidation::InvalidationP* AckHandleP::release_invalidation() {
  // @@protoc_insertion_point(field_release:ipc.invalidation.AckHandleP.invalidation)
  clear_has_invalidation();
  ::ipc::invalidation::InvalidationP* temp = invalidation_;
  invalidation_ = NULL;
  return temp;
}
inline void AckHandleP::set_allocated_invalidation(::ipc::invalidation::InvalidationP* invalidation) {
  delete invalidation_;
  invalidation_ = invalidation;
  if (invalidation) {
    set_has_invalidation();
  } else {
    clear_has_invalidation();
  }
  // @@protoc_insertion_point(field_set_allocated:ipc.invalidation.AckHandleP.invalidation)
}

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

// PersistentTiclState

// optional bytes client_token = 1;
inline bool PersistentTiclState::has_client_token() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PersistentTiclState::set_has_client_token() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PersistentTiclState::clear_has_client_token() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PersistentTiclState::clear_client_token() {
  client_token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_client_token();
}
inline const ::std::string& PersistentTiclState::client_token() const {
  // @@protoc_insertion_point(field_get:ipc.invalidation.PersistentTiclState.client_token)
  return client_token_.GetNoArena();
}
inline void PersistentTiclState::set_client_token(const ::std::string& value) {
  set_has_client_token();
  client_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ipc.invalidation.PersistentTiclState.client_token)
}
#if LANG_CXX11
inline void PersistentTiclState::set_client_token(::std::string&& value) {
  set_has_client_token();
  client_token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ipc.invalidation.PersistentTiclState.client_token)
}
#endif
inline void PersistentTiclState::set_client_token(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_client_token();
  client_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ipc.invalidation.PersistentTiclState.client_token)
}
inline void PersistentTiclState::set_client_token(const void* value, size_t size) {
  set_has_client_token();
  client_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ipc.invalidation.PersistentTiclState.client_token)
}
inline ::std::string* PersistentTiclState::mutable_client_token() {
  set_has_client_token();
  // @@protoc_insertion_point(field_mutable:ipc.invalidation.PersistentTiclState.client_token)
  return client_token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PersistentTiclState::release_client_token() {
  // @@protoc_insertion_point(field_release:ipc.invalidation.PersistentTiclState.client_token)
  clear_has_client_token();
  return client_token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PersistentTiclState::set_allocated_client_token(::std::string* client_token) {
  if (client_token != NULL) {
    set_has_client_token();
  } else {
    clear_has_client_token();
  }
  client_token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), client_token);
  // @@protoc_insertion_point(field_set_allocated:ipc.invalidation.PersistentTiclState.client_token)
}

// optional int64 last_message_send_time_ms = 2 [default = 0];
inline bool PersistentTiclState::has_last_message_send_time_ms() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PersistentTiclState::set_has_last_message_send_time_ms() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PersistentTiclState::clear_has_last_message_send_time_ms() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PersistentTiclState::clear_last_message_send_time_ms() {
  last_message_send_time_ms_ = GOOGLE_LONGLONG(0);
  clear_has_last_message_send_time_ms();
}
inline ::google::protobuf::int64 PersistentTiclState::last_message_send_time_ms() const {
  // @@protoc_insertion_point(field_get:ipc.invalidation.PersistentTiclState.last_message_send_time_ms)
  return last_message_send_time_ms_;
}
inline void PersistentTiclState::set_last_message_send_time_ms(::google::protobuf::int64 value) {
  set_has_last_message_send_time_ms();
  last_message_send_time_ms_ = value;
  // @@protoc_insertion_point(field_set:ipc.invalidation.PersistentTiclState.last_message_send_time_ms)
}

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

// PersistentStateBlob

// optional .ipc.invalidation.PersistentTiclState ticl_state = 1;
inline bool PersistentStateBlob::has_ticl_state() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PersistentStateBlob::set_has_ticl_state() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PersistentStateBlob::clear_has_ticl_state() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PersistentStateBlob::clear_ticl_state() {
  if (ticl_state_ != NULL) ticl_state_->::ipc::invalidation::PersistentTiclState::Clear();
  clear_has_ticl_state();
}
inline const ::ipc::invalidation::PersistentTiclState& PersistentStateBlob::ticl_state() const {
  // @@protoc_insertion_point(field_get:ipc.invalidation.PersistentStateBlob.ticl_state)
  return ticl_state_ != NULL ? *ticl_state_
                         : *::ipc::invalidation::PersistentTiclState::internal_default_instance();
}
inline ::ipc::invalidation::PersistentTiclState* PersistentStateBlob::mutable_ticl_state() {
  set_has_ticl_state();
  if (ticl_state_ == NULL) {
    ticl_state_ = new ::ipc::invalidation::PersistentTiclState;
  }
  // @@protoc_insertion_point(field_mutable:ipc.invalidation.PersistentStateBlob.ticl_state)
  return ticl_state_;
}
inline ::ipc::invalidation::PersistentTiclState* PersistentStateBlob::release_ticl_state() {
  // @@protoc_insertion_point(field_release:ipc.invalidation.PersistentStateBlob.ticl_state)
  clear_has_ticl_state();
  ::ipc::invalidation::PersistentTiclState* temp = ticl_state_;
  ticl_state_ = NULL;
  return temp;
}
inline void PersistentStateBlob::set_allocated_ticl_state(::ipc::invalidation::PersistentTiclState* ticl_state) {
  delete ticl_state_;
  ticl_state_ = ticl_state;
  if (ticl_state) {
    set_has_ticl_state();
  } else {
    clear_has_ticl_state();
  }
  // @@protoc_insertion_point(field_set_allocated:ipc.invalidation.PersistentStateBlob.ticl_state)
}

// optional bytes authentication_code = 2;
inline bool PersistentStateBlob::has_authentication_code() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PersistentStateBlob::set_has_authentication_code() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PersistentStateBlob::clear_has_authentication_code() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PersistentStateBlob::clear_authentication_code() {
  authentication_code_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_authentication_code();
}
inline const ::std::string& PersistentStateBlob::authentication_code() const {
  // @@protoc_insertion_point(field_get:ipc.invalidation.PersistentStateBlob.authentication_code)
  return authentication_code_.GetNoArena();
}
inline void PersistentStateBlob::set_authentication_code(const ::std::string& value) {
  set_has_authentication_code();
  authentication_code_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ipc.invalidation.PersistentStateBlob.authentication_code)
}
#if LANG_CXX11
inline void PersistentStateBlob::set_authentication_code(::std::string&& value) {
  set_has_authentication_code();
  authentication_code_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ipc.invalidation.PersistentStateBlob.authentication_code)
}
#endif
inline void PersistentStateBlob::set_authentication_code(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_authentication_code();
  authentication_code_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ipc.invalidation.PersistentStateBlob.authentication_code)
}
inline void PersistentStateBlob::set_authentication_code(const void* value, size_t size) {
  set_has_authentication_code();
  authentication_code_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ipc.invalidation.PersistentStateBlob.authentication_code)
}
inline ::std::string* PersistentStateBlob::mutable_authentication_code() {
  set_has_authentication_code();
  // @@protoc_insertion_point(field_mutable:ipc.invalidation.PersistentStateBlob.authentication_code)
  return authentication_code_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PersistentStateBlob::release_authentication_code() {
  // @@protoc_insertion_point(field_release:ipc.invalidation.PersistentStateBlob.authentication_code)
  clear_has_authentication_code();
  return authentication_code_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PersistentStateBlob::set_allocated_authentication_code(::std::string* authentication_code) {
  if (authentication_code != NULL) {
    set_has_authentication_code();
  } else {
    clear_has_authentication_code();
  }
  authentication_code_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), authentication_code);
  // @@protoc_insertion_point(field_set_allocated:ipc.invalidation.PersistentStateBlob.authentication_code)
}

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

// RunStateP

// optional .ipc.invalidation.RunStateP.State state = 1;
inline bool RunStateP::has_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RunStateP::set_has_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RunStateP::clear_has_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RunStateP::clear_state() {
  state_ = 1;
  clear_has_state();
}
inline ::ipc::invalidation::RunStateP_State RunStateP::state() const {
  // @@protoc_insertion_point(field_get:ipc.invalidation.RunStateP.state)
  return static_cast< ::ipc::invalidation::RunStateP_State >(state_);
}
inline void RunStateP::set_state(::ipc::invalidation::RunStateP_State value) {
  assert(::ipc::invalidation::RunStateP_State_IsValid(value));
  set_has_state();
  state_ = value;
  // @@protoc_insertion_point(field_set:ipc.invalidation.RunStateP.state)
}

#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

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

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


// @@protoc_insertion_point(namespace_scope)


}  // namespace invalidation
}  // namespace ipc

#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::ipc::invalidation::RunStateP_State> : ::google::protobuf::internal::true_type {};

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

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_client_2eproto__INCLUDED