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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "client.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

namespace ipc {
namespace invalidation {
class AckHandlePDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<AckHandleP> {
} _AckHandleP_default_instance_;
class PersistentTiclStateDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<PersistentTiclState> {
} _PersistentTiclState_default_instance_;
class PersistentStateBlobDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<PersistentStateBlob> {
} _PersistentStateBlob_default_instance_;
class RunStatePDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<RunStateP> {
} _RunStateP_default_instance_;

namespace protobuf_client_2eproto {

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTableField
    const TableStruct::entries[] = {
  {0, 0, 0, ::google::protobuf::internal::kInvalidMask, 0, 0},
};

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::AuxillaryParseTableField
    const TableStruct::aux[] = {
  ::google::protobuf::internal::AuxillaryParseTableField(),
};
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTable const
    TableStruct::schema[] = {
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
};


void TableStruct::Shutdown() {
  _AckHandleP_default_instance_.Shutdown();
  _PersistentTiclState_default_instance_.Shutdown();
  _PersistentStateBlob_default_instance_.Shutdown();
  _RunStateP_default_instance_.Shutdown();
}

void TableStruct::InitDefaultsImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::internal::InitProtobufDefaults();
  ::ipc::invalidation::protobuf_client_5fprotocol_2eproto::InitDefaults();
  _AckHandleP_default_instance_.DefaultConstruct();
  _PersistentTiclState_default_instance_.DefaultConstruct();
  _PersistentStateBlob_default_instance_.DefaultConstruct();
  _RunStateP_default_instance_.DefaultConstruct();
  _AckHandleP_default_instance_.get_mutable()->invalidation_ = const_cast< ::ipc::invalidation::InvalidationP*>(
      ::ipc::invalidation::InvalidationP::internal_default_instance());
  _PersistentStateBlob_default_instance_.get_mutable()->ticl_state_ = const_cast< ::ipc::invalidation::PersistentTiclState*>(
      ::ipc::invalidation::PersistentTiclState::internal_default_instance());
}

void InitDefaults() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void AddDescriptorsImpl() {
  InitDefaults();
  ::ipc::invalidation::protobuf_client_5fprotocol_2eproto::AddDescriptors();
  ::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}

}  // namespace protobuf_client_2eproto

bool RunStateP_State_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const RunStateP_State RunStateP::NOT_STARTED;
const RunStateP_State RunStateP::STARTED;
const RunStateP_State RunStateP::STOPPED;
const RunStateP_State RunStateP::State_MIN;
const RunStateP_State RunStateP::State_MAX;
const int RunStateP::State_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int AckHandleP::kInvalidationFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

AckHandleP::AckHandleP()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_client_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:ipc.invalidation.AckHandleP)
}
AckHandleP::AckHandleP(const AckHandleP& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_invalidation()) {
    invalidation_ = new ::ipc::invalidation::InvalidationP(*from.invalidation_);
  } else {
    invalidation_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:ipc.invalidation.AckHandleP)
}

void AckHandleP::SharedCtor() {
  _cached_size_ = 0;
  invalidation_ = NULL;
}

AckHandleP::~AckHandleP() {
  // @@protoc_insertion_point(destructor:ipc.invalidation.AckHandleP)
  SharedDtor();
}

void AckHandleP::SharedDtor() {
  if (this != internal_default_instance()) {
    delete invalidation_;
  }
}

void AckHandleP::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AckHandleP& AckHandleP::default_instance() {
  protobuf_client_2eproto::InitDefaults();
  return *internal_default_instance();
}

AckHandleP* AckHandleP::New(::google::protobuf::Arena* arena) const {
  AckHandleP* n = new AckHandleP;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void AckHandleP::Clear() {
// @@protoc_insertion_point(message_clear_start:ipc.invalidation.AckHandleP)
  if (has_invalidation()) {
    GOOGLE_DCHECK(invalidation_ != NULL);
    invalidation_->::ipc::invalidation::InvalidationP::Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool AckHandleP::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:ipc.invalidation.AckHandleP)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .ipc.invalidation.InvalidationP invalidation = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_invalidation()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ipc.invalidation.AckHandleP)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ipc.invalidation.AckHandleP)
  return false;
#undef DO_
}

void AckHandleP::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ipc.invalidation.AckHandleP)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .ipc.invalidation.InvalidationP invalidation = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, *this->invalidation_, output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:ipc.invalidation.AckHandleP)
}

size_t AckHandleP::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:ipc.invalidation.AckHandleP)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional .ipc.invalidation.InvalidationP invalidation = 1;
  if (has_invalidation()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->invalidation_);
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AckHandleP::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AckHandleP*>(&from));
}

void AckHandleP::MergeFrom(const AckHandleP& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:ipc.invalidation.AckHandleP)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_invalidation()) {
    mutable_invalidation()->::ipc::invalidation::InvalidationP::MergeFrom(from.invalidation());
  }
}

void AckHandleP::CopyFrom(const AckHandleP& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ipc.invalidation.AckHandleP)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AckHandleP::IsInitialized() const {
  return true;
}

void AckHandleP::Swap(AckHandleP* other) {
  if (other == this) return;
  InternalSwap(other);
}
void AckHandleP::InternalSwap(AckHandleP* other) {
  std::swap(invalidation_, other->invalidation_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string AckHandleP::GetTypeName() const {
  return "ipc.invalidation.AckHandleP";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// AckHandleP

// optional .ipc.invalidation.InvalidationP invalidation = 1;
bool AckHandleP::has_invalidation() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void AckHandleP::set_has_invalidation() {
  _has_bits_[0] |= 0x00000001u;
}
void AckHandleP::clear_has_invalidation() {
  _has_bits_[0] &= ~0x00000001u;
}
void AckHandleP::clear_invalidation() {
  if (invalidation_ != NULL) invalidation_->::ipc::invalidation::InvalidationP::Clear();
  clear_has_invalidation();
}
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();
}
::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_;
}
::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;
}
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)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PersistentTiclState::kClientTokenFieldNumber;
const int PersistentTiclState::kLastMessageSendTimeMsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PersistentTiclState::PersistentTiclState()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_client_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:ipc.invalidation.PersistentTiclState)
}
PersistentTiclState::PersistentTiclState(const PersistentTiclState& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  client_token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_client_token()) {
    client_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.client_token_);
  }
  last_message_send_time_ms_ = from.last_message_send_time_ms_;
  // @@protoc_insertion_point(copy_constructor:ipc.invalidation.PersistentTiclState)
}

void PersistentTiclState::SharedCtor() {
  _cached_size_ = 0;
  client_token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  last_message_send_time_ms_ = GOOGLE_LONGLONG(0);
}

PersistentTiclState::~PersistentTiclState() {
  // @@protoc_insertion_point(destructor:ipc.invalidation.PersistentTiclState)
  SharedDtor();
}

void PersistentTiclState::SharedDtor() {
  client_token_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void PersistentTiclState::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PersistentTiclState& PersistentTiclState::default_instance() {
  protobuf_client_2eproto::InitDefaults();
  return *internal_default_instance();
}

PersistentTiclState* PersistentTiclState::New(::google::protobuf::Arena* arena) const {
  PersistentTiclState* n = new PersistentTiclState;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PersistentTiclState::Clear() {
// @@protoc_insertion_point(message_clear_start:ipc.invalidation.PersistentTiclState)
  if (has_client_token()) {
    GOOGLE_DCHECK(!client_token_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*client_token_.UnsafeRawStringPointer())->clear();
  }
  last_message_send_time_ms_ = GOOGLE_LONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PersistentTiclState::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:ipc.invalidation.PersistentTiclState)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes client_token = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_client_token()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 last_message_send_time_ms = 2 [default = 0];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_last_message_send_time_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &last_message_send_time_ms_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ipc.invalidation.PersistentTiclState)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ipc.invalidation.PersistentTiclState)
  return false;
#undef DO_
}

void PersistentTiclState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ipc.invalidation.PersistentTiclState)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes client_token = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->client_token(), output);
  }

  // optional int64 last_message_send_time_ms = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->last_message_send_time_ms(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:ipc.invalidation.PersistentTiclState)
}

size_t PersistentTiclState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:ipc.invalidation.PersistentTiclState)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes client_token = 1;
    if (has_client_token()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->client_token());
    }

    // optional int64 last_message_send_time_ms = 2 [default = 0];
    if (has_last_message_send_time_ms()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->last_message_send_time_ms());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PersistentTiclState::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PersistentTiclState*>(&from));
}

void PersistentTiclState::MergeFrom(const PersistentTiclState& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:ipc.invalidation.PersistentTiclState)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_client_token();
      client_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.client_token_);
    }
    if (cached_has_bits & 0x00000002u) {
      last_message_send_time_ms_ = from.last_message_send_time_ms_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void PersistentTiclState::CopyFrom(const PersistentTiclState& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ipc.invalidation.PersistentTiclState)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PersistentTiclState::IsInitialized() const {
  return true;
}

void PersistentTiclState::Swap(PersistentTiclState* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PersistentTiclState::InternalSwap(PersistentTiclState* other) {
  client_token_.Swap(&other->client_token_);
  std::swap(last_message_send_time_ms_, other->last_message_send_time_ms_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string PersistentTiclState::GetTypeName() const {
  return "ipc.invalidation.PersistentTiclState";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// PersistentTiclState

// optional bytes client_token = 1;
bool PersistentTiclState::has_client_token() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void PersistentTiclState::set_has_client_token() {
  _has_bits_[0] |= 0x00000001u;
}
void PersistentTiclState::clear_has_client_token() {
  _has_bits_[0] &= ~0x00000001u;
}
void PersistentTiclState::clear_client_token() {
  client_token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_client_token();
}
const ::std::string& PersistentTiclState::client_token() const {
  // @@protoc_insertion_point(field_get:ipc.invalidation.PersistentTiclState.client_token)
  return client_token_.GetNoArena();
}
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
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
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)
}
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)
}
::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());
}
::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());
}
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];
bool PersistentTiclState::has_last_message_send_time_ms() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void PersistentTiclState::set_has_last_message_send_time_ms() {
  _has_bits_[0] |= 0x00000002u;
}
void PersistentTiclState::clear_has_last_message_send_time_ms() {
  _has_bits_[0] &= ~0x00000002u;
}
void PersistentTiclState::clear_last_message_send_time_ms() {
  last_message_send_time_ms_ = GOOGLE_LONGLONG(0);
  clear_has_last_message_send_time_ms();
}
::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_;
}
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)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PersistentStateBlob::kTiclStateFieldNumber;
const int PersistentStateBlob::kAuthenticationCodeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PersistentStateBlob::PersistentStateBlob()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_client_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:ipc.invalidation.PersistentStateBlob)
}
PersistentStateBlob::PersistentStateBlob(const PersistentStateBlob& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  authentication_code_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_authentication_code()) {
    authentication_code_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.authentication_code_);
  }
  if (from.has_ticl_state()) {
    ticl_state_ = new ::ipc::invalidation::PersistentTiclState(*from.ticl_state_);
  } else {
    ticl_state_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:ipc.invalidation.PersistentStateBlob)
}

void PersistentStateBlob::SharedCtor() {
  _cached_size_ = 0;
  authentication_code_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ticl_state_ = NULL;
}

PersistentStateBlob::~PersistentStateBlob() {
  // @@protoc_insertion_point(destructor:ipc.invalidation.PersistentStateBlob)
  SharedDtor();
}

void PersistentStateBlob::SharedDtor() {
  authentication_code_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete ticl_state_;
  }
}

void PersistentStateBlob::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PersistentStateBlob& PersistentStateBlob::default_instance() {
  protobuf_client_2eproto::InitDefaults();
  return *internal_default_instance();
}

PersistentStateBlob* PersistentStateBlob::New(::google::protobuf::Arena* arena) const {
  PersistentStateBlob* n = new PersistentStateBlob;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PersistentStateBlob::Clear() {
// @@protoc_insertion_point(message_clear_start:ipc.invalidation.PersistentStateBlob)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_authentication_code()) {
      GOOGLE_DCHECK(!authentication_code_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*authentication_code_.UnsafeRawStringPointer())->clear();
    }
    if (has_ticl_state()) {
      GOOGLE_DCHECK(ticl_state_ != NULL);
      ticl_state_->::ipc::invalidation::PersistentTiclState::Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PersistentStateBlob::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:ipc.invalidation.PersistentStateBlob)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .ipc.invalidation.PersistentTiclState ticl_state = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_ticl_state()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes authentication_code = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_authentication_code()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ipc.invalidation.PersistentStateBlob)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ipc.invalidation.PersistentStateBlob)
  return false;
#undef DO_
}

void PersistentStateBlob::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ipc.invalidation.PersistentStateBlob)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .ipc.invalidation.PersistentTiclState ticl_state = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, *this->ticl_state_, output);
  }

  // optional bytes authentication_code = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->authentication_code(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:ipc.invalidation.PersistentStateBlob)
}

size_t PersistentStateBlob::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:ipc.invalidation.PersistentStateBlob)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes authentication_code = 2;
    if (has_authentication_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->authentication_code());
    }

    // optional .ipc.invalidation.PersistentTiclState ticl_state = 1;
    if (has_ticl_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->ticl_state_);
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PersistentStateBlob::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PersistentStateBlob*>(&from));
}

void PersistentStateBlob::MergeFrom(const PersistentStateBlob& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:ipc.invalidation.PersistentStateBlob)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_authentication_code();
      authentication_code_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.authentication_code_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_ticl_state()->::ipc::invalidation::PersistentTiclState::MergeFrom(from.ticl_state());
    }
  }
}

void PersistentStateBlob::CopyFrom(const PersistentStateBlob& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ipc.invalidation.PersistentStateBlob)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PersistentStateBlob::IsInitialized() const {
  return true;
}

void PersistentStateBlob::Swap(PersistentStateBlob* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PersistentStateBlob::InternalSwap(PersistentStateBlob* other) {
  authentication_code_.Swap(&other->authentication_code_);
  std::swap(ticl_state_, other->ticl_state_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string PersistentStateBlob::GetTypeName() const {
  return "ipc.invalidation.PersistentStateBlob";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// PersistentStateBlob

// optional .ipc.invalidation.PersistentTiclState ticl_state = 1;
bool PersistentStateBlob::has_ticl_state() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void PersistentStateBlob::set_has_ticl_state() {
  _has_bits_[0] |= 0x00000002u;
}
void PersistentStateBlob::clear_has_ticl_state() {
  _has_bits_[0] &= ~0x00000002u;
}
void PersistentStateBlob::clear_ticl_state() {
  if (ticl_state_ != NULL) ticl_state_->::ipc::invalidation::PersistentTiclState::Clear();
  clear_has_ticl_state();
}
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();
}
::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_;
}
::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;
}
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;
bool PersistentStateBlob::has_authentication_code() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void PersistentStateBlob::set_has_authentication_code() {
  _has_bits_[0] |= 0x00000001u;
}
void PersistentStateBlob::clear_has_authentication_code() {
  _has_bits_[0] &= ~0x00000001u;
}
void PersistentStateBlob::clear_authentication_code() {
  authentication_code_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_authentication_code();
}
const ::std::string& PersistentStateBlob::authentication_code() const {
  // @@protoc_insertion_point(field_get:ipc.invalidation.PersistentStateBlob.authentication_code)
  return authentication_code_.GetNoArena();
}
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
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
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)
}
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)
}
::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());
}
::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());
}
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)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RunStateP::kStateFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RunStateP::RunStateP()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_client_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:ipc.invalidation.RunStateP)
}
RunStateP::RunStateP(const RunStateP& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  state_ = from.state_;
  // @@protoc_insertion_point(copy_constructor:ipc.invalidation.RunStateP)
}

void RunStateP::SharedCtor() {
  _cached_size_ = 0;
  state_ = 1;
}

RunStateP::~RunStateP() {
  // @@protoc_insertion_point(destructor:ipc.invalidation.RunStateP)
  SharedDtor();
}

void RunStateP::SharedDtor() {
}

void RunStateP::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RunStateP& RunStateP::default_instance() {
  protobuf_client_2eproto::InitDefaults();
  return *internal_default_instance();
}

RunStateP* RunStateP::New(::google::protobuf::Arena* arena) const {
  RunStateP* n = new RunStateP;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RunStateP::Clear() {
// @@protoc_insertion_point(message_clear_start:ipc.invalidation.RunStateP)
  state_ = 1;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RunStateP::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:ipc.invalidation.RunStateP)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .ipc.invalidation.RunStateP.State state = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::ipc::invalidation::RunStateP_State_IsValid(value)) {
            set_state(static_cast< ::ipc::invalidation::RunStateP_State >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ipc.invalidation.RunStateP)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ipc.invalidation.RunStateP)
  return false;
#undef DO_
}

void RunStateP::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ipc.invalidation.RunStateP)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .ipc.invalidation.RunStateP.State state = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->state(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:ipc.invalidation.RunStateP)
}

size_t RunStateP::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:ipc.invalidation.RunStateP)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional .ipc.invalidation.RunStateP.State state = 1;
  if (has_state()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RunStateP::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RunStateP*>(&from));
}

void RunStateP::MergeFrom(const RunStateP& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:ipc.invalidation.RunStateP)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_state()) {
    set_state(from.state());
  }
}

void RunStateP::CopyFrom(const RunStateP& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ipc.invalidation.RunStateP)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RunStateP::IsInitialized() const {
  return true;
}

void RunStateP::Swap(RunStateP* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RunStateP::InternalSwap(RunStateP* other) {
  std::swap(state_, other->state_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RunStateP::GetTypeName() const {
  return "ipc.invalidation.RunStateP";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RunStateP

// optional .ipc.invalidation.RunStateP.State state = 1;
bool RunStateP::has_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RunStateP::set_has_state() {
  _has_bits_[0] |= 0x00000001u;
}
void RunStateP::clear_has_state() {
  _has_bits_[0] &= ~0x00000001u;
}
void RunStateP::clear_state() {
  state_ = 1;
  clear_has_state();
}
::ipc::invalidation::RunStateP_State RunStateP::state() const {
  // @@protoc_insertion_point(field_get:ipc.invalidation.RunStateP.state)
  return static_cast< ::ipc::invalidation::RunStateP_State >(state_);
}
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

// @@protoc_insertion_point(global_scope)