/Users/deen/code/yugabyte-db/build/debugcov-clang-dynamic-arm64-ninja/src/yb/master/master_backup.pb.cc

Source (jump to first uncovered line)
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: yb/master/master_backup.proto

#include "yb/master/master_backup.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/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// This is a temporary google only hack
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
#include "third_party/protobuf/version.h"
#endif
#include "yb/util/protobuf-annotations.h"
// @@protoc_insertion_point(includes)
namespace yb {
namespace master {
class BackupRowEntryPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<BackupRowEntryPB>
      _instance;
} _BackupRowEntryPB_default_instance_;
class CreateSnapshotRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<CreateSnapshotRequestPB>
      _instance;
} _CreateSnapshotRequestPB_default_instance_;
class CreateSnapshotResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<CreateSnapshotResponsePB>
      _instance;
} _CreateSnapshotResponsePB_default_instance_;
class SnapshotInfoPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SnapshotInfoPB>
      _instance;
} _SnapshotInfoPB_default_instance_;
class TabletRestorationPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TabletRestorationPB>
      _instance;
} _TabletRestorationPB_default_instance_;
class SysRestorationEntryPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SysRestorationEntryPB>
      _instance;
} _SysRestorationEntryPB_default_instance_;
class RestorationInfoPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RestorationInfoPB>
      _instance;
} _RestorationInfoPB_default_instance_;
class ListSnapshotsRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ListSnapshotsRequestPB>
      _instance;
} _ListSnapshotsRequestPB_default_instance_;
class ListSnapshotsResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ListSnapshotsResponsePB>
      _instance;
} _ListSnapshotsResponsePB_default_instance_;
class RestoreSnapshotRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RestoreSnapshotRequestPB>
      _instance;
} _RestoreSnapshotRequestPB_default_instance_;
class RestoreSnapshotResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RestoreSnapshotResponsePB>
      _instance;
} _RestoreSnapshotResponsePB_default_instance_;
class DeleteSnapshotRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<DeleteSnapshotRequestPB>
      _instance;
} _DeleteSnapshotRequestPB_default_instance_;
class DeleteSnapshotResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<DeleteSnapshotResponsePB>
      _instance;
} _DeleteSnapshotResponsePB_default_instance_;
class ImportSnapshotMetaRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ImportSnapshotMetaRequestPB>
      _instance;
} _ImportSnapshotMetaRequestPB_default_instance_;
class ListSnapshotRestorationsRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ListSnapshotRestorationsRequestPB>
      _instance;
} _ListSnapshotRestorationsRequestPB_default_instance_;
class ListSnapshotRestorationsResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ListSnapshotRestorationsResponsePB>
      _instance;
} _ListSnapshotRestorationsResponsePB_default_instance_;
class IdPairPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<IdPairPB>
      _instance;
} _IdPairPB_default_instance_;
class ImportSnapshotMetaResponsePB_TableMetaPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ImportSnapshotMetaResponsePB_TableMetaPB>
      _instance;
} _ImportSnapshotMetaResponsePB_TableMetaPB_default_instance_;
class ImportSnapshotMetaResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ImportSnapshotMetaResponsePB>
      _instance;
} _ImportSnapshotMetaResponsePB_default_instance_;
class TableIdentifiersPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TableIdentifiersPB>
      _instance;
} _TableIdentifiersPB_default_instance_;
class SnapshotScheduleFilterPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SnapshotScheduleFilterPB>
      _instance;
  const ::yb::master::TableIdentifiersPB* tables_;
} _SnapshotScheduleFilterPB_default_instance_;
class SnapshotScheduleOptionsPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SnapshotScheduleOptionsPB>
      _instance;
} _SnapshotScheduleOptionsPB_default_instance_;
class CreateSnapshotScheduleRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<CreateSnapshotScheduleRequestPB>
      _instance;
} _CreateSnapshotScheduleRequestPB_default_instance_;
class CreateSnapshotScheduleResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<CreateSnapshotScheduleResponsePB>
      _instance;
} _CreateSnapshotScheduleResponsePB_default_instance_;
class ListSnapshotSchedulesRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ListSnapshotSchedulesRequestPB>
      _instance;
} _ListSnapshotSchedulesRequestPB_default_instance_;
class SnapshotScheduleInfoPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SnapshotScheduleInfoPB>
      _instance;
} _SnapshotScheduleInfoPB_default_instance_;
class ListSnapshotSchedulesResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ListSnapshotSchedulesResponsePB>
      _instance;
} _ListSnapshotSchedulesResponsePB_default_instance_;
class DeleteSnapshotScheduleRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<DeleteSnapshotScheduleRequestPB>
      _instance;
} _DeleteSnapshotScheduleRequestPB_default_instance_;
class DeleteSnapshotScheduleResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<DeleteSnapshotScheduleResponsePB>
      _instance;
} _DeleteSnapshotScheduleResponsePB_default_instance_;
}  // namespace master
}  // namespace yb
namespace protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto {
void InitDefaultsBackupRowEntryPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fcatalog_5fentity_5finfo_2eproto::InitDefaultsSysRowEntry();
  {
    void* ptr = &::yb::master::_BackupRowEntryPB_default_instance_;
    new (ptr) ::yb::master::BackupRowEntryPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::BackupRowEntryPB::InitAsDefaultInstance();
}

void InitDefaultsBackupRowEntryPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsBackupRowEntryPBImpl);
}

void InitDefaultsCreateSnapshotRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsTableIdentifierPB();
  {
    void* ptr = &::yb::master::_CreateSnapshotRequestPB_default_instance_;
    new (ptr) ::yb::master::CreateSnapshotRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::CreateSnapshotRequestPB::InitAsDefaultInstance();
}

void InitDefaultsCreateSnapshotRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsCreateSnapshotRequestPBImpl);
}

void InitDefaultsCreateSnapshotResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsMasterErrorPB();
  {
    void* ptr = &::yb::master::_CreateSnapshotResponsePB_default_instance_;
    new (ptr) ::yb::master::CreateSnapshotResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::CreateSnapshotResponsePB::InitAsDefaultInstance();
}

void InitDefaultsCreateSnapshotResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsCreateSnapshotResponsePBImpl);
}

void InitDefaultsSnapshotInfoPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fcatalog_5fentity_5finfo_2eproto::InitDefaultsSysSnapshotEntryPB();
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsBackupRowEntryPB();
  {
    void* ptr = &::yb::master::_SnapshotInfoPB_default_instance_;
    new (ptr) ::yb::master::SnapshotInfoPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::SnapshotInfoPB::InitAsDefaultInstance();
}

void InitDefaultsSnapshotInfoPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSnapshotInfoPBImpl);
}

void InitDefaultsTabletRestorationPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::master::_TabletRestorationPB_default_instance_;
    new (ptr) ::yb::master::TabletRestorationPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::TabletRestorationPB::InitAsDefaultInstance();
}

void InitDefaultsTabletRestorationPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTabletRestorationPBImpl);
}

void InitDefaultsSysRestorationEntryPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsTabletRestorationPB();
  {
    void* ptr = &::yb::master::_SysRestorationEntryPB_default_instance_;
    new (ptr) ::yb::master::SysRestorationEntryPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::SysRestorationEntryPB::InitAsDefaultInstance();
}

void InitDefaultsSysRestorationEntryPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSysRestorationEntryPBImpl);
}

void InitDefaultsRestorationInfoPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSysRestorationEntryPB();
  {
    void* ptr = &::yb::master::_RestorationInfoPB_default_instance_;
    new (ptr) ::yb::master::RestorationInfoPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::RestorationInfoPB::InitAsDefaultInstance();
}

void InitDefaultsRestorationInfoPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRestorationInfoPBImpl);
}

void InitDefaultsListSnapshotsRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::master::_ListSnapshotsRequestPB_default_instance_;
    new (ptr) ::yb::master::ListSnapshotsRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::ListSnapshotsRequestPB::InitAsDefaultInstance();
}

void InitDefaultsListSnapshotsRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsListSnapshotsRequestPBImpl);
}

void InitDefaultsListSnapshotsResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsMasterErrorPB();
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotInfoPB();
  {
    void* ptr = &::yb::master::_ListSnapshotsResponsePB_default_instance_;
    new (ptr) ::yb::master::ListSnapshotsResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::ListSnapshotsResponsePB::InitAsDefaultInstance();
}

void InitDefaultsListSnapshotsResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsListSnapshotsResponsePBImpl);
}

void InitDefaultsRestoreSnapshotRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::master::_RestoreSnapshotRequestPB_default_instance_;
    new (ptr) ::yb::master::RestoreSnapshotRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::RestoreSnapshotRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRestoreSnapshotRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRestoreSnapshotRequestPBImpl);
}

void InitDefaultsRestoreSnapshotResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsMasterErrorPB();
  {
    void* ptr = &::yb::master::_RestoreSnapshotResponsePB_default_instance_;
    new (ptr) ::yb::master::RestoreSnapshotResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::RestoreSnapshotResponsePB::InitAsDefaultInstance();
}

void InitDefaultsRestoreSnapshotResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRestoreSnapshotResponsePBImpl);
}

void InitDefaultsDeleteSnapshotRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::master::_DeleteSnapshotRequestPB_default_instance_;
    new (ptr) ::yb::master::DeleteSnapshotRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::DeleteSnapshotRequestPB::InitAsDefaultInstance();
}

void InitDefaultsDeleteSnapshotRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDeleteSnapshotRequestPBImpl);
}

void InitDefaultsDeleteSnapshotResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsMasterErrorPB();
  {
    void* ptr = &::yb::master::_DeleteSnapshotResponsePB_default_instance_;
    new (ptr) ::yb::master::DeleteSnapshotResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::DeleteSnapshotResponsePB::InitAsDefaultInstance();
}

void InitDefaultsDeleteSnapshotResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDeleteSnapshotResponsePBImpl);
}

void InitDefaultsImportSnapshotMetaRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotInfoPB();
  {
    void* ptr = &::yb::master::_ImportSnapshotMetaRequestPB_default_instance_;
    new (ptr) ::yb::master::ImportSnapshotMetaRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::ImportSnapshotMetaRequestPB::InitAsDefaultInstance();
}

void InitDefaultsImportSnapshotMetaRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsImportSnapshotMetaRequestPBImpl);
}

void InitDefaultsListSnapshotRestorationsRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::master::_ListSnapshotRestorationsRequestPB_default_instance_;
    new (ptr) ::yb::master::ListSnapshotRestorationsRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::ListSnapshotRestorationsRequestPB::InitAsDefaultInstance();
}

void InitDefaultsListSnapshotRestorationsRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsListSnapshotRestorationsRequestPBImpl);
}

void InitDefaultsListSnapshotRestorationsResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fcommon_2fwire_5fprotocol_2eproto::InitDefaultsAppStatusPB();
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsRestorationInfoPB();
  {
    void* ptr = &::yb::master::_ListSnapshotRestorationsResponsePB_default_instance_;
    new (ptr) ::yb::master::ListSnapshotRestorationsResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::ListSnapshotRestorationsResponsePB::InitAsDefaultInstance();
}

void InitDefaultsListSnapshotRestorationsResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsListSnapshotRestorationsResponsePBImpl);
}

void InitDefaultsIdPairPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::master::_IdPairPB_default_instance_;
    new (ptr) ::yb::master::IdPairPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::IdPairPB::InitAsDefaultInstance();
}

void InitDefaultsIdPairPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsIdPairPBImpl);
}

void InitDefaultsImportSnapshotMetaResponsePB_TableMetaPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsIdPairPB();
  {
    void* ptr = &::yb::master::_ImportSnapshotMetaResponsePB_TableMetaPB_default_instance_;
    new (ptr) ::yb::master::ImportSnapshotMetaResponsePB_TableMetaPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::ImportSnapshotMetaResponsePB_TableMetaPB::InitAsDefaultInstance();
}

void InitDefaultsImportSnapshotMetaResponsePB_TableMetaPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsImportSnapshotMetaResponsePB_TableMetaPBImpl);
}

void InitDefaultsImportSnapshotMetaResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsMasterErrorPB();
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsImportSnapshotMetaResponsePB_TableMetaPB();
  {
    void* ptr = &::yb::master::_ImportSnapshotMetaResponsePB_default_instance_;
    new (ptr) ::yb::master::ImportSnapshotMetaResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::ImportSnapshotMetaResponsePB::InitAsDefaultInstance();
}

void InitDefaultsImportSnapshotMetaResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsImportSnapshotMetaResponsePBImpl);
}

void InitDefaultsTableIdentifiersPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsTableIdentifierPB();
  {
    void* ptr = &::yb::master::_TableIdentifiersPB_default_instance_;
    new (ptr) ::yb::master::TableIdentifiersPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::TableIdentifiersPB::InitAsDefaultInstance();
}

void InitDefaultsTableIdentifiersPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTableIdentifiersPBImpl);
}

void InitDefaultsSnapshotScheduleFilterPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsTableIdentifiersPB();
  {
    void* ptr = &::yb::master::_SnapshotScheduleFilterPB_default_instance_;
    new (ptr) ::yb::master::SnapshotScheduleFilterPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::SnapshotScheduleFilterPB::InitAsDefaultInstance();
}

void InitDefaultsSnapshotScheduleFilterPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSnapshotScheduleFilterPBImpl);
}

void InitDefaultsSnapshotScheduleOptionsPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleFilterPB();
  {
    void* ptr = &::yb::master::_SnapshotScheduleOptionsPB_default_instance_;
    new (ptr) ::yb::master::SnapshotScheduleOptionsPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::SnapshotScheduleOptionsPB::InitAsDefaultInstance();
}

void InitDefaultsSnapshotScheduleOptionsPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSnapshotScheduleOptionsPBImpl);
}

void InitDefaultsCreateSnapshotScheduleRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleOptionsPB();
  {
    void* ptr = &::yb::master::_CreateSnapshotScheduleRequestPB_default_instance_;
    new (ptr) ::yb::master::CreateSnapshotScheduleRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::CreateSnapshotScheduleRequestPB::InitAsDefaultInstance();
}

void InitDefaultsCreateSnapshotScheduleRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsCreateSnapshotScheduleRequestPBImpl);
}

void InitDefaultsCreateSnapshotScheduleResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsMasterErrorPB();
  {
    void* ptr = &::yb::master::_CreateSnapshotScheduleResponsePB_default_instance_;
    new (ptr) ::yb::master::CreateSnapshotScheduleResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::CreateSnapshotScheduleResponsePB::InitAsDefaultInstance();
}

void InitDefaultsCreateSnapshotScheduleResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsCreateSnapshotScheduleResponsePBImpl);
}

void InitDefaultsListSnapshotSchedulesRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::master::_ListSnapshotSchedulesRequestPB_default_instance_;
    new (ptr) ::yb::master::ListSnapshotSchedulesRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::ListSnapshotSchedulesRequestPB::InitAsDefaultInstance();
}

void InitDefaultsListSnapshotSchedulesRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsListSnapshotSchedulesRequestPBImpl);
}

void InitDefaultsSnapshotScheduleInfoPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleOptionsPB();
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotInfoPB();
  {
    void* ptr = &::yb::master::_SnapshotScheduleInfoPB_default_instance_;
    new (ptr) ::yb::master::SnapshotScheduleInfoPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::SnapshotScheduleInfoPB::InitAsDefaultInstance();
}

void InitDefaultsSnapshotScheduleInfoPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSnapshotScheduleInfoPBImpl);
}

void InitDefaultsListSnapshotSchedulesResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsMasterErrorPB();
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleInfoPB();
  {
    void* ptr = &::yb::master::_ListSnapshotSchedulesResponsePB_default_instance_;
    new (ptr) ::yb::master::ListSnapshotSchedulesResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::ListSnapshotSchedulesResponsePB::InitAsDefaultInstance();
}

void InitDefaultsListSnapshotSchedulesResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsListSnapshotSchedulesResponsePBImpl);
}

void InitDefaultsDeleteSnapshotScheduleRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::master::_DeleteSnapshotScheduleRequestPB_default_instance_;
    new (ptr) ::yb::master::DeleteSnapshotScheduleRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::DeleteSnapshotScheduleRequestPB::InitAsDefaultInstance();
}

void InitDefaultsDeleteSnapshotScheduleRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDeleteSnapshotScheduleRequestPBImpl);
}

void InitDefaultsDeleteSnapshotScheduleResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::InitDefaultsMasterErrorPB();
  {
    void* ptr = &::yb::master::_DeleteSnapshotScheduleResponsePB_default_instance_;
    new (ptr) ::yb::master::DeleteSnapshotScheduleResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::master::DeleteSnapshotScheduleResponsePB::InitAsDefaultInstance();
}

void InitDefaultsDeleteSnapshotScheduleResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDeleteSnapshotScheduleResponsePBImpl);
}

::google::protobuf::Metadata file_level_metadata[29];
const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[1];

const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::BackupRowEntryPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::BackupRowEntryPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::BackupRowEntryPB, entry_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::BackupRowEntryPB, pg_schema_name_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotRequestPB, tables_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotRequestPB, transaction_aware_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotRequestPB, add_indexes_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotRequestPB, imported_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotRequestPB, schedule_id_),
  ~0u,
  1,
  2,
  3,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotResponsePB, error_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotResponsePB, snapshot_id_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotInfoPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotInfoPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotInfoPB, id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotInfoPB, entry_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotInfoPB, format_version_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotInfoPB, backup_entries_),
  0,
  1,
  2,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::TabletRestorationPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::TabletRestorationPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::TabletRestorationPB, id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::TabletRestorationPB, state_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SysRestorationEntryPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SysRestorationEntryPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SysRestorationEntryPB, state_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SysRestorationEntryPB, tablet_restorations_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SysRestorationEntryPB, snapshot_id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SysRestorationEntryPB, complete_time_ht_),
  2,
  ~0u,
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestorationInfoPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestorationInfoPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestorationInfoPB, id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestorationInfoPB, entry_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsRequestPB, snapshot_id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsRequestPB, list_deleted_snapshots_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsRequestPB, prepare_for_backup_),
  0,
  1,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsResponsePB, error_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsResponsePB, current_snapshot_id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotsResponsePB, snapshots_),
  1,
  0,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestoreSnapshotRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestoreSnapshotRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestoreSnapshotRequestPB, snapshot_id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestoreSnapshotRequestPB, restore_ht_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestoreSnapshotResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestoreSnapshotResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestoreSnapshotResponsePB, error_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::RestoreSnapshotResponsePB, restoration_id_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotRequestPB, snapshot_id_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotResponsePB, error_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaRequestPB, snapshot_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotRestorationsRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotRestorationsRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotRestorationsRequestPB, snapshot_id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotRestorationsRequestPB, restoration_id_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotRestorationsResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotRestorationsResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotRestorationsResponsePB, status_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotRestorationsResponsePB, restorations_),
  0,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::IdPairPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::IdPairPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::IdPairPB, old_id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::IdPairPB, new_id_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB_TableMetaPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB_TableMetaPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB_TableMetaPB, namespace_ids_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB_TableMetaPB, table_ids_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB_TableMetaPB, tablets_ids_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB_TableMetaPB, table_type_),
  0,
  1,
  ~0u,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB, error_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ImportSnapshotMetaResponsePB, tables_meta_),
  0,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::TableIdentifiersPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::TableIdentifiersPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::TableIdentifiersPB, tables_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleFilterPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleFilterPB, _internal_metadata_),
  ~0u,  // no _extensions_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleFilterPB, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::yb::master::SnapshotScheduleFilterPBDefaultTypeInternal, tables_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleFilterPB, filter_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleOptionsPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleOptionsPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleOptionsPB, filter_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleOptionsPB, interval_sec_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleOptionsPB, retention_duration_sec_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleOptionsPB, delete_time_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleOptionsPB, restoration_times_),
  0,
  1,
  2,
  3,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotScheduleRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotScheduleRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotScheduleRequestPB, options_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotScheduleResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotScheduleResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotScheduleResponsePB, error_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::CreateSnapshotScheduleResponsePB, snapshot_schedule_id_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotSchedulesRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotSchedulesRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotSchedulesRequestPB, snapshot_schedule_id_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleInfoPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleInfoPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleInfoPB, id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleInfoPB, options_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::SnapshotScheduleInfoPB, snapshots_),
  0,
  1,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotSchedulesResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotSchedulesResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotSchedulesResponsePB, error_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::ListSnapshotSchedulesResponsePB, schedules_),
  0,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotScheduleRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotScheduleRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotScheduleRequestPB, snapshot_schedule_id_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotScheduleResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotScheduleResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::master::DeleteSnapshotScheduleResponsePB, error_),
  0,
};
static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 7, sizeof(::yb::master::BackupRowEntryPB)},
  { 9, 19, sizeof(::yb::master::CreateSnapshotRequestPB)},
  { 24, 31, sizeof(::yb::master::CreateSnapshotResponsePB)},
  { 33, 42, sizeof(::yb::master::SnapshotInfoPB)},
  { 46, 53, sizeof(::yb::master::TabletRestorationPB)},
  { 55, 64, sizeof(::yb::master::SysRestorationEntryPB)},
  { 68, 75, sizeof(::yb::master::RestorationInfoPB)},
  { 77, 85, sizeof(::yb::master::ListSnapshotsRequestPB)},
  { 88, 96, sizeof(::yb::master::ListSnapshotsResponsePB)},
  { 99, 106, sizeof(::yb::master::RestoreSnapshotRequestPB)},
  { 108, 115, sizeof(::yb::master::RestoreSnapshotResponsePB)},
  { 117, 123, sizeof(::yb::master::DeleteSnapshotRequestPB)},
  { 124, 130, sizeof(::yb::master::DeleteSnapshotResponsePB)},
  { 131, 137, sizeof(::yb::master::ImportSnapshotMetaRequestPB)},
  { 138, 145, sizeof(::yb::master::ListSnapshotRestorationsRequestPB)},
  { 147, 154, sizeof(::yb::master::ListSnapshotRestorationsResponsePB)},
  { 156, 163, sizeof(::yb::master::IdPairPB)},
  { 165, 174, sizeof(::yb::master::ImportSnapshotMetaResponsePB_TableMetaPB)},
  { 178, 185, sizeof(::yb::master::ImportSnapshotMetaResponsePB)},
  { 187, 193, sizeof(::yb::master::TableIdentifiersPB)},
  { 194, 201, sizeof(::yb::master::SnapshotScheduleFilterPB)},
  { 202, 212, sizeof(::yb::master::SnapshotScheduleOptionsPB)},
  { 217, 223, sizeof(::yb::master::CreateSnapshotScheduleRequestPB)},
  { 224, 231, sizeof(::yb::master::CreateSnapshotScheduleResponsePB)},
  { 233, 239, sizeof(::yb::master::ListSnapshotSchedulesRequestPB)},
  { 240, 248, sizeof(::yb::master::SnapshotScheduleInfoPB)},
  { 251, 258, sizeof(::yb::master::ListSnapshotSchedulesResponsePB)},
  { 260, 266, sizeof(::yb::master::DeleteSnapshotScheduleRequestPB)},
  { 267, 273, sizeof(::yb::master::DeleteSnapshotScheduleResponsePB)},
};

static ::google::protobuf::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_BackupRowEntryPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_CreateSnapshotRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_CreateSnapshotResponsePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_SnapshotInfoPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_TabletRestorationPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_SysRestorationEntryPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_RestorationInfoPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_ListSnapshotsRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_ListSnapshotsResponsePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_RestoreSnapshotRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_RestoreSnapshotResponsePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_DeleteSnapshotRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_DeleteSnapshotResponsePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_ImportSnapshotMetaRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_ListSnapshotRestorationsRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_ListSnapshotRestorationsResponsePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_IdPairPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_ImportSnapshotMetaResponsePB_TableMetaPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_ImportSnapshotMetaResponsePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_TableIdentifiersPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_SnapshotScheduleFilterPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_SnapshotScheduleOptionsPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_CreateSnapshotScheduleRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_CreateSnapshotScheduleResponsePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_ListSnapshotSchedulesRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_SnapshotScheduleInfoPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_ListSnapshotSchedulesResponsePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_DeleteSnapshotScheduleRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::master::_DeleteSnapshotScheduleResponsePB_default_instance_),
};

void protobuf_AssignDescriptors() {
  AddDescriptors();
  ::google::protobuf::MessageFactory* factory = NULL;
  AssignDescriptors(
      "yb/master/master_backup.proto", schemas, file_default_instances, TableStruct::offsets, factory,
      file_level_metadata, file_level_enum_descriptors, NULL);
}

void protobuf_AssignDescriptorsOnce() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors);
}

void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 29);
}

void AddDescriptorsImpl() {
  InitDefaults();
  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
      "\n\035yb/master/master_backup.proto\022\tyb.mast"
      "er\032\035yb/common/wire_protocol.proto\032#yb/ma"
      "ster/catalog_entity_info.proto\032\034yb/maste"
      "r/master_types.proto\"Q\n\020BackupRowEntryPB"
      "\022%\n\005entry\030\001 \001(\0132\026.yb.master.SysRowEntry\022"
      "\026\n\016pg_schema_name\030\002 \001(\014\"\245\001\n\027CreateSnapsh"
      "otRequestPB\022,\n\006tables\030\001 \003(\0132\034.yb.master."
      "TableIdentifierPB\022\031\n\021transaction_aware\030\002"
      " \001(\010\022\032\n\013add_indexes\030\003 \001(\010:\005false\022\020\n\010impo"
      "rted\030\004 \001(\010\022\023\n\013schedule_id\030\005 \001(\014\"X\n\030Creat"
      "eSnapshotResponsePB\022\'\n\005error\030\001 \001(\0132\030.yb."
      "master.MasterErrorPB\022\023\n\013snapshot_id\030\002 \001("
      "\014\"\232\001\n\016SnapshotInfoPB\022\n\n\002id\030\001 \001(\014\022,\n\005entr"
      "y\030\002 \001(\0132\035.yb.master.SysSnapshotEntryPB\022\031"
      "\n\016format_version\030\003 \001(\003:\0011\0223\n\016backup_entr"
      "ies\030\004 \003(\0132\033.yb.master.BackupRowEntryPB\"U"
      "\n\023TabletRestorationPB\022\n\n\002id\030\001 \001(\014\0222\n\005sta"
      "te\030\002 \001(\0162#.yb.master.SysSnapshotEntryPB."
      "State\"\300\001\n\025SysRestorationEntryPB\022;\n\005state"
      "\030\001 \001(\0162#.yb.master.SysSnapshotEntryPB.St"
      "ate:\007UNKNOWN\022;\n\023tablet_restorations\030\002 \003("
      "\0132\036.yb.master.TabletRestorationPB\022\023\n\013sna"
      "pshot_id\030\010 \001(\014\022\030\n\020complete_time_ht\030\003 \001(\006"
      "\"P\n\021RestorationInfoPB\022\n\n\002id\030\001 \001(\014\022/\n\005ent"
      "ry\030\002 \001(\0132 .yb.master.SysRestorationEntry"
      "PB\"i\n\026ListSnapshotsRequestPB\022\023\n\013snapshot"
      "_id\030\002 \001(\014\022\036\n\026list_deleted_snapshots\030\003 \001("
      "\010\022\032\n\022prepare_for_backup\030\004 \001(\010\"\215\001\n\027ListSn"
      "apshotsResponsePB\022\'\n\005error\030\001 \001(\0132\030.yb.ma"
      "ster.MasterErrorPB\022\033\n\023current_snapshot_i"
      "d\030\002 \001(\014\022,\n\tsnapshots\030\003 \003(\0132\031.yb.master.S"
      "napshotInfoPB\"C\n\030RestoreSnapshotRequestP"
      "B\022\023\n\013snapshot_id\030\002 \001(\014\022\022\n\nrestore_ht\030\003 \001"
      "(\006\"\\\n\031RestoreSnapshotResponsePB\022\'\n\005error"
      "\030\001 \001(\0132\030.yb.master.MasterErrorPB\022\026\n\016rest"
      "oration_id\030\002 \001(\014\".\n\027DeleteSnapshotReques"
      "tPB\022\023\n\013snapshot_id\030\002 \001(\014\"C\n\030DeleteSnapsh"
      "otResponsePB\022\'\n\005error\030\001 \001(\0132\030.yb.master."
      "MasterErrorPB\"J\n\033ImportSnapshotMetaReque"
      "stPB\022+\n\010snapshot\030\001 \001(\0132\031.yb.master.Snaps"
      "hotInfoPB\"P\n!ListSnapshotRestorationsReq"
      "uestPB\022\023\n\013snapshot_id\030\001 \001(\014\022\026\n\016restorati"
      "on_id\030\002 \001(\014\"y\n\"ListSnapshotRestorationsR"
      "esponsePB\022\037\n\006status\030\001 \001(\0132\017.yb.AppStatus"
      "PB\0222\n\014restorations\030\002 \003(\0132\034.yb.master.Res"
      "torationInfoPB\"*\n\010IdPairPB\022\016\n\006old_id\030\001 \001"
      "(\014\022\016\n\006new_id\030\002 \001(\014\"\266\003\n\034ImportSnapshotMet"
      "aResponsePB\022\'\n\005error\030\001 \001(\0132\030.yb.master.M"
      "asterErrorPB\022H\n\013tables_meta\030\003 \003(\01323.yb.m"
      "aster.ImportSnapshotMetaResponsePB.Table"
      "MetaPB\032\331\001\n\013TableMetaPB\022*\n\rnamespace_ids\030"
      "\001 \001(\0132\023.yb.master.IdPairPB\022&\n\ttable_ids\030"
      "\002 \001(\0132\023.yb.master.IdPairPB\022(\n\013tablets_id"
      "s\030\003 \003(\0132\023.yb.master.IdPairPB\022L\n\ntable_ty"
      "pe\030\004 \001(\01621.yb.master.ImportSnapshotMetaR"
      "esponsePB.TableType:\005TABLE\"G\n\tTableType\022"
      "\t\n\005TABLE\020\000\022\023\n\017COLOCATED_TABLE\020\001\022\032\n\026PAREN"
      "T_COLOCATED_TABLE\020\002\"B\n\022TableIdentifiersP"
      "B\022,\n\006tables\030\001 \003(\0132\034.yb.master.TableIdent"
      "ifierPB\"U\n\030SnapshotScheduleFilterPB\022/\n\006t"
      "ables\030\001 \001(\0132\035.yb.master.TableIdentifiers"
      "PBH\000B\010\n\006filter\"\266\001\n\031SnapshotScheduleOptio"
      "nsPB\0223\n\006filter\030\001 \001(\0132#.yb.master.Snapsho"
      "tScheduleFilterPB\022\024\n\014interval_sec\030\002 \001(\004\022"
      "\036\n\026retention_duration_sec\030\003 \001(\004\022\023\n\013delet"
      "e_time\030\004 \001(\006\022\031\n\021restoration_times\030\005 \003(\006\""
      "X\n\037CreateSnapshotScheduleRequestPB\0225\n\007op"
      "tions\030\001 \001(\0132$.yb.master.SnapshotSchedule"
      "OptionsPB\"i\n CreateSnapshotScheduleRespo"
      "nsePB\022\'\n\005error\030\001 \001(\0132\030.yb.master.MasterE"
      "rrorPB\022\034\n\024snapshot_schedule_id\030\002 \001(\014\">\n\036"
      "ListSnapshotSchedulesRequestPB\022\034\n\024snapsh"
      "ot_schedule_id\030\001 \001(\014\"\211\001\n\026SnapshotSchedul"
      "eInfoPB\022\n\n\002id\030\001 \001(\014\0225\n\007options\030\002 \001(\0132$.y"
      "b.master.SnapshotScheduleOptionsPB\022,\n\tsn"
      "apshots\030\003 \003(\0132\031.yb.master.SnapshotInfoPB"
      "\"\200\001\n\037ListSnapshotSchedulesResponsePB\022\'\n\005"
      "error\030\001 \001(\0132\030.yb.master.MasterErrorPB\0224\n"
      "\tschedules\030\002 \003(\0132!.yb.master.SnapshotSch"
      "eduleInfoPB\"\?\n\037DeleteSnapshotScheduleReq"
      "uestPB\022\034\n\024snapshot_schedule_id\030\001 \001(\014\"K\n "
      "DeleteSnapshotScheduleResponsePB\022\'\n\005erro"
      "r\030\001 \001(\0132\030.yb.master.MasterErrorPB2\260\007\n\014Ma"
      "sterBackup\022Y\n\016CreateSnapshot\022\".yb.master"
      ".CreateSnapshotRequestPB\032#.yb.master.Cre"
      "ateSnapshotResponsePB\022V\n\rListSnapshots\022!"
      ".yb.master.ListSnapshotsRequestPB\032\".yb.m"
      "aster.ListSnapshotsResponsePB\022w\n\030ListSna"
      "pshotRestorations\022,.yb.master.ListSnapsh"
      "otRestorationsRequestPB\032-.yb.master.List"
      "SnapshotRestorationsResponsePB\022\\\n\017Restor"
      "eSnapshot\022#.yb.master.RestoreSnapshotReq"
      "uestPB\032$.yb.master.RestoreSnapshotRespon"
      "sePB\022Y\n\016DeleteSnapshot\022\".yb.master.Delet"
      "eSnapshotRequestPB\032#.yb.master.DeleteSna"
      "pshotResponsePB\022e\n\022ImportSnapshotMeta\022&."
      "yb.master.ImportSnapshotMetaRequestPB\032\'."
      "yb.master.ImportSnapshotMetaResponsePB\022q"
      "\n\026CreateSnapshotSchedule\022*.yb.master.Cre"
      "ateSnapshotScheduleRequestPB\032+.yb.master"
      ".CreateSnapshotScheduleResponsePB\022n\n\025Lis"
      "tSnapshotSchedules\022).yb.master.ListSnaps"
      "hotSchedulesRequestPB\032*.yb.master.ListSn"
      "apshotSchedulesResponsePB\022q\n\026DeleteSnaps"
      "hotSchedule\022*.yb.master.DeleteSnapshotSc"
      "heduleRequestPB\032+.yb.master.DeleteSnapsh"
      "otScheduleResponsePBB\017\n\rorg.yb.master"
  };
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      descriptor, 4277);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "yb/master/master_backup.proto", &protobuf_RegisterTypes);
  ::protobuf_yb_2fcommon_2fwire_5fprotocol_2eproto::AddDescriptors();
  ::protobuf_yb_2fmaster_2fcatalog_5fentity_5finfo_2eproto::AddDescriptors();
  ::protobuf_yb_2fmaster_2fmaster_5ftypes_2eproto::AddDescriptors();
}

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at dynamic initialization time.
struct StaticDescriptorInitializer {
  StaticDescriptorInitializer() {
    AddDescriptors();
  }
} static_descriptor_initializer;
}  // namespace protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto
namespace yb {
namespace master {
const ::google::protobuf::EnumDescriptor* ImportSnapshotMetaResponsePB_TableType_descriptor() {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_enum_descriptors[0];
}
bool ImportSnapshotMetaResponsePB_TableType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const ImportSnapshotMetaResponsePB_TableType ImportSnapshotMetaResponsePB::TABLE;
const ImportSnapshotMetaResponsePB_TableType ImportSnapshotMetaResponsePB::COLOCATED_TABLE;
const ImportSnapshotMetaResponsePB_TableType ImportSnapshotMetaResponsePB::PARENT_COLOCATED_TABLE;
const ImportSnapshotMetaResponsePB_TableType ImportSnapshotMetaResponsePB::TableType_MIN;
const ImportSnapshotMetaResponsePB_TableType ImportSnapshotMetaResponsePB::TableType_MAX;
const int ImportSnapshotMetaResponsePB::TableType_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

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

void BackupRowEntryPB::InitAsDefaultInstance() {
  ::yb::master::_BackupRowEntryPB_default_instance_._instance.get_mutable()->entry_ = const_cast< ::yb::master::SysRowEntry*>(
      ::yb::master::SysRowEntry::internal_default_instance());
}
void BackupRowEntryPB::clear_entry() {
  if (entry_ != NULL) entry_->Clear();
  clear_has_entry();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int BackupRowEntryPB::kEntryFieldNumber;
const int BackupRowEntryPB::kPgSchemaNameFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

BackupRowEntryPB::BackupRowEntryPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsBackupRowEntryPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.BackupRowEntryPB)
}
BackupRowEntryPB::BackupRowEntryPB(const BackupRowEntryPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  pg_schema_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_pg_schema_name()) {
    pg_schema_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.pg_schema_name_);
  }
  if (from.has_entry()) {
    entry_ = new ::yb::master::SysRowEntry(*from.entry_);
  } else {
    entry_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.BackupRowEntryPB)
}

void BackupRowEntryPB::SharedCtor() {
  _cached_size_ = 0;
  pg_schema_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  entry_ = NULL;
}

BackupRowEntryPB::~BackupRowEntryPB() {
  // @@protoc_insertion_point(destructor:yb.master.BackupRowEntryPB)
  SharedDtor();
}

void BackupRowEntryPB::SharedDtor() {
  pg_schema_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete entry_;
}

void BackupRowEntryPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* BackupRowEntryPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const BackupRowEntryPB& BackupRowEntryPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsBackupRowEntryPB();
  return *internal_default_instance();
}

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

void BackupRowEntryPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.BackupRowEntryPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!pg_schema_name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*pg_schema_name_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(entry_ != NULL);
      entry_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool BackupRowEntryPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.BackupRowEntryPB)
  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 .yb.master.SysRowEntry entry = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_entry()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.BackupRowEntryPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.BackupRowEntryPB)
  return false;
#undef DO_
}

void BackupRowEntryPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.BackupRowEntryPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SysRowEntry entry = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->entry_, output);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.BackupRowEntryPB)
}

::google::protobuf::uint8* BackupRowEntryPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.BackupRowEntryPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SysRowEntry entry = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->entry_, deterministic, target);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.BackupRowEntryPB)
  return target;
}

size_t BackupRowEntryPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.BackupRowEntryPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes pg_schema_name = 2;
    if (has_pg_schema_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->pg_schema_name());
    }

    // optional .yb.master.SysRowEntry entry = 1;
    if (has_entry()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->entry_);
    }

  }
  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 BackupRowEntryPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.BackupRowEntryPB)
  GOOGLE_DCHECK_NE(&from, this);
  const BackupRowEntryPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const BackupRowEntryPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.BackupRowEntryPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.BackupRowEntryPB)
    MergeFrom(*source);
  }
}

void BackupRowEntryPB::MergeFrom(const BackupRowEntryPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.BackupRowEntryPB)
  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_pg_schema_name();
      pg_schema_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.pg_schema_name_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_entry()->::yb::master::SysRowEntry::MergeFrom(from.entry());
    }
  }
}

void BackupRowEntryPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.BackupRowEntryPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BackupRowEntryPB::CopyFrom(const BackupRowEntryPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.BackupRowEntryPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata BackupRowEntryPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void CreateSnapshotRequestPB::InitAsDefaultInstance() {
}
void CreateSnapshotRequestPB::clear_tables() {
  tables_.Clear();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CreateSnapshotRequestPB::kTablesFieldNumber;
const int CreateSnapshotRequestPB::kTransactionAwareFieldNumber;
const int CreateSnapshotRequestPB::kAddIndexesFieldNumber;
const int CreateSnapshotRequestPB::kImportedFieldNumber;
const int CreateSnapshotRequestPB::kScheduleIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CreateSnapshotRequestPB::CreateSnapshotRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsCreateSnapshotRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.CreateSnapshotRequestPB)
}
CreateSnapshotRequestPB::CreateSnapshotRequestPB(const CreateSnapshotRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      tables_(from.tables_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  schedule_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_schedule_id()) {
    schedule_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.schedule_id_);
  }
  ::memcpy(&transaction_aware_, &from.transaction_aware_,
    static_cast<size_t>(reinterpret_cast<char*>(&imported_) -
    reinterpret_cast<char*>(&transaction_aware_)) + sizeof(imported_));
  // @@protoc_insertion_point(copy_constructor:yb.master.CreateSnapshotRequestPB)
}

void CreateSnapshotRequestPB::SharedCtor() {
  _cached_size_ = 0;
  schedule_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&transaction_aware_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&imported_) -
      reinterpret_cast<char*>(&transaction_aware_)) + sizeof(imported_));
}

CreateSnapshotRequestPB::~CreateSnapshotRequestPB() {
  // @@protoc_insertion_point(destructor:yb.master.CreateSnapshotRequestPB)
  SharedDtor();
}

void CreateSnapshotRequestPB::SharedDtor() {
  schedule_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CreateSnapshotRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CreateSnapshotRequestPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const CreateSnapshotRequestPB& CreateSnapshotRequestPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsCreateSnapshotRequestPB();
  return *internal_default_instance();
}

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

void CreateSnapshotRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.CreateSnapshotRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  tables_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!schedule_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*schedule_id_.UnsafeRawStringPointer())->clear();
  }
  ::memset(&transaction_aware_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&imported_) -
      reinterpret_cast<char*>(&transaction_aware_)) + sizeof(imported_));
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CreateSnapshotRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.CreateSnapshotRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual3;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .yb.master.TableIdentifierPB tables = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_tables()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool transaction_aware = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_transaction_aware();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &transaction_aware_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool add_indexes = 3 [default = false];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_add_indexes();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &add_indexes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool imported = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_imported();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &imported_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes schedule_id = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_schedule_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.CreateSnapshotRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.CreateSnapshotRequestPB)
  return false;
#undef DO_
}

void CreateSnapshotRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.CreateSnapshotRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .yb.master.TableIdentifierPB tables = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tables_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->tables(static_cast<int>(i)), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional bool transaction_aware = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->transaction_aware(), output);
  }

  // optional bool add_indexes = 3 [default = false];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->add_indexes(), output);
  }

  // optional bool imported = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->imported(), output);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.CreateSnapshotRequestPB)
}

::google::protobuf::uint8* CreateSnapshotRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.CreateSnapshotRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .yb.master.TableIdentifierPB tables = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tables_size()); i < n; i++3) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, this->tables(static_cast<int>(i)), deterministic, target);
  }

  cached_has_bits = _has_bits_[0];
  // optional bool transaction_aware = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->transaction_aware(), target);
  }

  // optional bool add_indexes = 3 [default = false];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->add_indexes(), target);
  }

  // optional bool imported = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->imported(), target);
  }

  // optional bytes schedule_id = 5;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        5, this->schedule_id(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.CreateSnapshotRequestPB)
  return target;
}

size_t CreateSnapshotRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.CreateSnapshotRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.TableIdentifierPB tables = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->tables_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++6) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->tables(static_cast<int>(i)));
    }
  }

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

    // optional bool transaction_aware = 2;
    if (has_transaction_aware()) {
      total_size += 1 + 1;
    }

    // optional bool add_indexes = 3 [default = false];
    if (has_add_indexes()) {
      total_size += 1 + 1;
    }

    // optional bool imported = 4;
    if (has_imported()) {
      total_size += 1 + 1;
    }

  }
  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 CreateSnapshotRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.CreateSnapshotRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const CreateSnapshotRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const CreateSnapshotRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.CreateSnapshotRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.CreateSnapshotRequestPB)
    MergeFrom(*source);
  }
}

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

  tables_.MergeFrom(from.tables_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_schedule_id();
      schedule_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.schedule_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      transaction_aware_ = from.transaction_aware_;
    }
    if (cached_has_bits & 0x00000004u) {
      add_indexes_ = from.add_indexes_;
    }
    if (cached_has_bits & 0x00000008u) {
      imported_ = from.imported_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CreateSnapshotRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.CreateSnapshotRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void CreateSnapshotRequestPB::CopyFrom(const CreateSnapshotRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.CreateSnapshotRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void CreateSnapshotRequestPB::Swap(CreateSnapshotRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CreateSnapshotRequestPB::InternalSwap(CreateSnapshotRequestPB* other) {
  using std::swap;
  tables_.InternalSwap(&other->tables_);
  schedule_id_.Swap(&other->schedule_id_);
  swap(transaction_aware_, other->transaction_aware_);
  swap(add_indexes_, other->add_indexes_);
  swap(imported_, other->imported_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata CreateSnapshotRequestPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void CreateSnapshotResponsePB::InitAsDefaultInstance() {
  ::yb::master::_CreateSnapshotResponsePB_default_instance_._instance.get_mutable()->error_ = const_cast< ::yb::master::MasterErrorPB*>(
      ::yb::master::MasterErrorPB::internal_default_instance());
}
void CreateSnapshotResponsePB::clear_error() {
  if (error_ != NULL) error_->Clear();
  clear_has_error();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CreateSnapshotResponsePB::kErrorFieldNumber;
const int CreateSnapshotResponsePB::kSnapshotIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CreateSnapshotResponsePB::CreateSnapshotResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsCreateSnapshotResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.CreateSnapshotResponsePB)
}
CreateSnapshotResponsePB::CreateSnapshotResponsePB(const CreateSnapshotResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_id()) {
    snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
  }
  if (from.has_error()) {
    error_ = new ::yb::master::MasterErrorPB(*from.error_);
  } else {
    error_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.CreateSnapshotResponsePB)
}

void CreateSnapshotResponsePB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  error_ = NULL;
}

CreateSnapshotResponsePB::~CreateSnapshotResponsePB() {
  // @@protoc_insertion_point(destructor:yb.master.CreateSnapshotResponsePB)
  SharedDtor();
}

void CreateSnapshotResponsePB::SharedDtor() {
  snapshot_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete error_;
}

void CreateSnapshotResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CreateSnapshotResponsePB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const CreateSnapshotResponsePB& CreateSnapshotResponsePB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsCreateSnapshotResponsePB();
  return *internal_default_instance();
}

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

void CreateSnapshotResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.CreateSnapshotResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!snapshot_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*snapshot_id_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(error_ != NULL);
      error_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CreateSnapshotResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.CreateSnapshotResponsePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual3;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.master.MasterErrorPB error = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.CreateSnapshotResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.CreateSnapshotResponsePB)
  return false;
#undef DO_
}

void CreateSnapshotResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.CreateSnapshotResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->error_, output);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.CreateSnapshotResponsePB)
}

::google::protobuf::uint8* CreateSnapshotResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.CreateSnapshotResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->error_, deterministic, target);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.CreateSnapshotResponsePB)
  return target;
}

size_t CreateSnapshotResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.CreateSnapshotResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes snapshot_id = 2;
    if (has_snapshot_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->snapshot_id());
    }

    // optional .yb.master.MasterErrorPB error = 1;
    if (has_error()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->error_);
    }

  }
  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 CreateSnapshotResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.CreateSnapshotResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const CreateSnapshotResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const CreateSnapshotResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.CreateSnapshotResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.CreateSnapshotResponsePB)
    MergeFrom(*source);
  }
}

void CreateSnapshotResponsePB::MergeFrom(const CreateSnapshotResponsePB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.CreateSnapshotResponsePB)
  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_snapshot_id();
      snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_error()->::yb::master::MasterErrorPB::MergeFrom(from.error());
    }
  }
}

void CreateSnapshotResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.CreateSnapshotResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void CreateSnapshotResponsePB::CopyFrom(const CreateSnapshotResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.CreateSnapshotResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CreateSnapshotResponsePB::IsInitialized() const {
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata CreateSnapshotResponsePB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SnapshotInfoPB::InitAsDefaultInstance() {
  ::yb::master::_SnapshotInfoPB_default_instance_._instance.get_mutable()->entry_ = const_cast< ::yb::master::SysSnapshotEntryPB*>(
      ::yb::master::SysSnapshotEntryPB::internal_default_instance());
}
void SnapshotInfoPB::clear_entry() {
  if (entry_ != NULL) entry_->Clear();
  clear_has_entry();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SnapshotInfoPB::kIdFieldNumber;
const int SnapshotInfoPB::kEntryFieldNumber;
const int SnapshotInfoPB::kFormatVersionFieldNumber;
const int SnapshotInfoPB::kBackupEntriesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SnapshotInfoPB::SnapshotInfoPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotInfoPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.SnapshotInfoPB)
}
SnapshotInfoPB::SnapshotInfoPB(const SnapshotInfoPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      backup_entries_(from.backup_entries_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_id()) {
    id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
  }
  if (from.has_entry()) {
    entry_ = new ::yb::master::SysSnapshotEntryPB(*from.entry_);
  } else {
    entry_ = NULL;
  }
  format_version_ = from.format_version_;
  // @@protoc_insertion_point(copy_constructor:yb.master.SnapshotInfoPB)
}

void SnapshotInfoPB::SharedCtor() {
  _cached_size_ = 0;
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  entry_ = NULL;
  format_version_ = GOOGLE_LONGLONG(1);
}

SnapshotInfoPB::~SnapshotInfoPB() {
  // @@protoc_insertion_point(destructor:yb.master.SnapshotInfoPB)
  SharedDtor();
}

void SnapshotInfoPB::SharedDtor() {
  id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete entry_;
}

void SnapshotInfoPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SnapshotInfoPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SnapshotInfoPB& SnapshotInfoPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotInfoPB();
  return *internal_default_instance();
}

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

void SnapshotInfoPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.SnapshotInfoPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  backup_entries_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*id_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(entry_ != NULL);
      entry_->Clear();
    }
    format_version_ = GOOGLE_LONGLONG(1);
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SnapshotInfoPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.SnapshotInfoPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual25;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.master.SysSnapshotEntryPB entry = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_entry()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 format_version = 3 [default = 1];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_format_version();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &format_version_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .yb.master.BackupRowEntryPB backup_entries = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_backup_entries()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.SnapshotInfoPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.SnapshotInfoPB)
  return false;
#undef DO_
}

void SnapshotInfoPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.SnapshotInfoPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .yb.master.SysSnapshotEntryPB entry = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->entry_, output);
  }

  // optional int64 format_version = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->format_version(), output);
  }

  // repeated .yb.master.BackupRowEntryPB backup_entries = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->backup_entries_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->backup_entries(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.SnapshotInfoPB)
}

::google::protobuf::uint8* SnapshotInfoPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.SnapshotInfoPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .yb.master.SysSnapshotEntryPB entry = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, *this->entry_, deterministic, target);
  }

  // optional int64 format_version = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->format_version(), target);
  }

  // repeated .yb.master.BackupRowEntryPB backup_entries = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->backup_entries_size()); i < n; i++0) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        4, this->backup_entries(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.SnapshotInfoPB)
  return target;
}

size_t SnapshotInfoPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.SnapshotInfoPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.BackupRowEntryPB backup_entries = 4;
  {
    unsigned int count = static_cast<unsigned int>(this->backup_entries_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++0) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->backup_entries(static_cast<int>(i)));
    }
  }

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

    // optional .yb.master.SysSnapshotEntryPB entry = 2;
    if (has_entry()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->entry_);
    }

    // optional int64 format_version = 3 [default = 1];
    if (has_format_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->format_version());
    }

  }
  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 SnapshotInfoPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.SnapshotInfoPB)
  GOOGLE_DCHECK_NE(&from, this);
  const SnapshotInfoPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SnapshotInfoPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.SnapshotInfoPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.SnapshotInfoPB)
    MergeFrom(*source);
  }
}

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

  backup_entries_.MergeFrom(from.backup_entries_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_id();
      id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_entry()->::yb::master::SysSnapshotEntryPB::MergeFrom(from.entry());
    }
    if (cached_has_bits & 0x00000004u) {
      format_version_ = from.format_version_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SnapshotInfoPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.SnapshotInfoPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SnapshotInfoPB::CopyFrom(const SnapshotInfoPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.SnapshotInfoPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void SnapshotInfoPB::Swap(SnapshotInfoPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SnapshotInfoPB::InternalSwap(SnapshotInfoPB* other) {
  using std::swap;
  backup_entries_.InternalSwap(&other->backup_entries_);
  id_.Swap(&other->id_);
  swap(entry_, other->entry_);
  swap(format_version_, other->format_version_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SnapshotInfoPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TabletRestorationPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TabletRestorationPB::kIdFieldNumber;
const int TabletRestorationPB::kStateFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TabletRestorationPB::TabletRestorationPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsTabletRestorationPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.TabletRestorationPB)
}
TabletRestorationPB::TabletRestorationPB(const TabletRestorationPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_id()) {
    id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
  }
  state_ = from.state_;
  // @@protoc_insertion_point(copy_constructor:yb.master.TabletRestorationPB)
}

void TabletRestorationPB::SharedCtor() {
  _cached_size_ = 0;
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  state_ = 0;
}

TabletRestorationPB::~TabletRestorationPB() {
  // @@protoc_insertion_point(destructor:yb.master.TabletRestorationPB)
  SharedDtor();
}

void TabletRestorationPB::SharedDtor() {
  id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void TabletRestorationPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TabletRestorationPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TabletRestorationPB& TabletRestorationPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsTabletRestorationPB();
  return *internal_default_instance();
}

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

void TabletRestorationPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.TabletRestorationPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*id_.UnsafeRawStringPointer())->clear();
  }
  state_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TabletRestorationPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.TabletRestorationPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual22;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.master.SysSnapshotEntryPB.State state = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::master::SysSnapshotEntryPB_State_IsValid(value)) {
            set_state(static_cast< ::yb::master::SysSnapshotEntryPB_State >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                2, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.TabletRestorationPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.TabletRestorationPB)
  return false;
#undef DO_
}

void TabletRestorationPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.TabletRestorationPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .yb.master.SysSnapshotEntryPB.State state = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->state(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.TabletRestorationPB)
}

::google::protobuf::uint8* TabletRestorationPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.TabletRestorationPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .yb.master.SysSnapshotEntryPB.State state = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->state(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.TabletRestorationPB)
  return target;
}

size_t TabletRestorationPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.TabletRestorationPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes id = 1;
    if (has_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->id());
    }

    // optional .yb.master.SysSnapshotEntryPB.State state = 2;
    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 TabletRestorationPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.TabletRestorationPB)
  GOOGLE_DCHECK_NE(&from, this);
  const TabletRestorationPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TabletRestorationPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.TabletRestorationPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.TabletRestorationPB)
    MergeFrom(*source);
  }
}

void TabletRestorationPB::MergeFrom(const TabletRestorationPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.TabletRestorationPB)
  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_id();
      id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
    }
    if (cached_has_bits & 0x00000002u) {
      state_ = from.state_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void TabletRestorationPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.TabletRestorationPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TabletRestorationPB::CopyFrom(const TabletRestorationPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.TabletRestorationPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata TabletRestorationPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SysRestorationEntryPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SysRestorationEntryPB::kStateFieldNumber;
const int SysRestorationEntryPB::kTabletRestorationsFieldNumber;
const int SysRestorationEntryPB::kSnapshotIdFieldNumber;
const int SysRestorationEntryPB::kCompleteTimeHtFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SysRestorationEntryPB::SysRestorationEntryPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSysRestorationEntryPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.SysRestorationEntryPB)
}
SysRestorationEntryPB::SysRestorationEntryPB(const SysRestorationEntryPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      tablet_restorations_(from.tablet_restorations_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_id()) {
    snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
  }
  ::memcpy(&complete_time_ht_, &from.complete_time_ht_,
    static_cast<size_t>(reinterpret_cast<char*>(&state_) -
    reinterpret_cast<char*>(&complete_time_ht_)) + sizeof(state_));
  // @@protoc_insertion_point(copy_constructor:yb.master.SysRestorationEntryPB)
}

void SysRestorationEntryPB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&complete_time_ht_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&state_) -
      reinterpret_cast<char*>(&complete_time_ht_)) + sizeof(state_));
}

SysRestorationEntryPB::~SysRestorationEntryPB() {
  // @@protoc_insertion_point(destructor:yb.master.SysRestorationEntryPB)
  SharedDtor();
}

void SysRestorationEntryPB::SharedDtor() {
  snapshot_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void SysRestorationEntryPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SysRestorationEntryPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SysRestorationEntryPB& SysRestorationEntryPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSysRestorationEntryPB();
  return *internal_default_instance();
}

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

void SysRestorationEntryPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.SysRestorationEntryPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  tablet_restorations_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!snapshot_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*snapshot_id_.UnsafeRawStringPointer())->clear();
  }
  if (cached_has_bits & 6u) {
    ::memset(&complete_time_ht_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&state_) -
        reinterpret_cast<char*>(&complete_time_ht_)) + sizeof(state_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SysRestorationEntryPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.SysRestorationEntryPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual5;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.master.SysSnapshotEntryPB.State state = 1 [default = UNKNOWN];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::master::SysSnapshotEntryPB_State_IsValid(value)) {
            set_state(static_cast< ::yb::master::SysSnapshotEntryPB_State >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .yb.master.TabletRestorationPB tablet_restorations = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_tablet_restorations()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional fixed64 complete_time_ht = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(25u /* 25 & 0xFF */)) {
          set_has_complete_time_ht();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &complete_time_ht_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes snapshot_id = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_snapshot_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.SysRestorationEntryPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.SysRestorationEntryPB)
  return false;
#undef DO_
}

void SysRestorationEntryPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.SysRestorationEntryPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SysSnapshotEntryPB.State state = 1 [default = UNKNOWN];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->state(), output);
  }

  // repeated .yb.master.TabletRestorationPB tablet_restorations = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tablet_restorations_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->tablet_restorations(static_cast<int>(i)), output);
  }

  // optional fixed64 complete_time_ht = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->complete_time_ht(), output);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.SysRestorationEntryPB)
}

::google::protobuf::uint8* SysRestorationEntryPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.SysRestorationEntryPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SysSnapshotEntryPB.State state = 1 [default = UNKNOWN];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->state(), target);
  }

  // repeated .yb.master.TabletRestorationPB tablet_restorations = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tablet_restorations_size()); i < n; i++22) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, this->tablet_restorations(static_cast<int>(i)), deterministic, target);
  }

  // optional fixed64 complete_time_ht = 3;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->complete_time_ht(), target);
  }

  // optional bytes snapshot_id = 8;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        8, this->snapshot_id(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.SysRestorationEntryPB)
  return target;
}

size_t SysRestorationEntryPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.SysRestorationEntryPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.TabletRestorationPB tablet_restorations = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->tablet_restorations_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++44) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->tablet_restorations(static_cast<int>(i)));
    }
  }

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

    // optional fixed64 complete_time_ht = 3;
    if (has_complete_time_ht()) {
      total_size += 1 + 8;
    }

    // optional .yb.master.SysSnapshotEntryPB.State state = 1 [default = UNKNOWN];
    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 SysRestorationEntryPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.SysRestorationEntryPB)
  GOOGLE_DCHECK_NE(&from, this);
  const SysRestorationEntryPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SysRestorationEntryPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.SysRestorationEntryPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.SysRestorationEntryPB)
    MergeFrom(*source);
  }
}

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

  tablet_restorations_.MergeFrom(from.tablet_restorations_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_snapshot_id();
      snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      complete_time_ht_ = from.complete_time_ht_;
    }
    if (cached_has_bits & 0x00000004u) {
      state_ = from.state_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SysRestorationEntryPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.SysRestorationEntryPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SysRestorationEntryPB::CopyFrom(const SysRestorationEntryPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.SysRestorationEntryPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata SysRestorationEntryPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RestorationInfoPB::InitAsDefaultInstance() {
  ::yb::master::_RestorationInfoPB_default_instance_._instance.get_mutable()->entry_ = const_cast< ::yb::master::SysRestorationEntryPB*>(
      ::yb::master::SysRestorationEntryPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RestorationInfoPB::kIdFieldNumber;
const int RestorationInfoPB::kEntryFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RestorationInfoPB::RestorationInfoPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsRestorationInfoPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.RestorationInfoPB)
}
RestorationInfoPB::RestorationInfoPB(const RestorationInfoPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_id()) {
    id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
  }
  if (from.has_entry()) {
    entry_ = new ::yb::master::SysRestorationEntryPB(*from.entry_);
  } else {
    entry_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.RestorationInfoPB)
}

void RestorationInfoPB::SharedCtor() {
  _cached_size_ = 0;
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  entry_ = NULL;
}

RestorationInfoPB::~RestorationInfoPB() {
  // @@protoc_insertion_point(destructor:yb.master.RestorationInfoPB)
  SharedDtor();
}

void RestorationInfoPB::SharedDtor() {
  id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete entry_;
}

void RestorationInfoPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RestorationInfoPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RestorationInfoPB& RestorationInfoPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsRestorationInfoPB();
  return *internal_default_instance();
}

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

void RestorationInfoPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.RestorationInfoPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*id_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(entry_ != NULL);
      entry_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RestorationInfoPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.RestorationInfoPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual5;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.master.SysRestorationEntryPB entry = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_entry()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.RestorationInfoPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.RestorationInfoPB)
  return false;
#undef DO_
}

void RestorationInfoPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.RestorationInfoPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .yb.master.SysRestorationEntryPB entry = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->entry_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.RestorationInfoPB)
}

::google::protobuf::uint8* RestorationInfoPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.RestorationInfoPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .yb.master.SysRestorationEntryPB entry = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, *this->entry_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.RestorationInfoPB)
  return target;
}

size_t RestorationInfoPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.RestorationInfoPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes id = 1;
    if (has_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->id());
    }

    // optional .yb.master.SysRestorationEntryPB entry = 2;
    if (has_entry()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->entry_);
    }

  }
  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 RestorationInfoPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.RestorationInfoPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RestorationInfoPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RestorationInfoPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.RestorationInfoPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.RestorationInfoPB)
    MergeFrom(*source);
  }
}

void RestorationInfoPB::MergeFrom(const RestorationInfoPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.RestorationInfoPB)
  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_id();
      id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_entry()->::yb::master::SysRestorationEntryPB::MergeFrom(from.entry());
    }
  }
}

void RestorationInfoPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.RestorationInfoPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RestorationInfoPB::CopyFrom(const RestorationInfoPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.RestorationInfoPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata RestorationInfoPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ListSnapshotsRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ListSnapshotsRequestPB::kSnapshotIdFieldNumber;
const int ListSnapshotsRequestPB::kListDeletedSnapshotsFieldNumber;
const int ListSnapshotsRequestPB::kPrepareForBackupFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ListSnapshotsRequestPB::ListSnapshotsRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotsRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.ListSnapshotsRequestPB)
}
ListSnapshotsRequestPB::ListSnapshotsRequestPB(const ListSnapshotsRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_id()) {
    snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
  }
  ::memcpy(&list_deleted_snapshots_, &from.list_deleted_snapshots_,
    static_cast<size_t>(reinterpret_cast<char*>(&prepare_for_backup_) -
    reinterpret_cast<char*>(&list_deleted_snapshots_)) + sizeof(prepare_for_backup_));
  // @@protoc_insertion_point(copy_constructor:yb.master.ListSnapshotsRequestPB)
}

void ListSnapshotsRequestPB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&list_deleted_snapshots_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&prepare_for_backup_) -
      reinterpret_cast<char*>(&list_deleted_snapshots_)) + sizeof(prepare_for_backup_));
}

ListSnapshotsRequestPB::~ListSnapshotsRequestPB() {
  // @@protoc_insertion_point(destructor:yb.master.ListSnapshotsRequestPB)
  SharedDtor();
}

void ListSnapshotsRequestPB::SharedDtor() {
  snapshot_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void ListSnapshotsRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ListSnapshotsRequestPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ListSnapshotsRequestPB& ListSnapshotsRequestPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotsRequestPB();
  return *internal_default_instance();
}

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

void ListSnapshotsRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.ListSnapshotsRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!snapshot_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*snapshot_id_.UnsafeRawStringPointer())->clear();
  }
  ::memset(&list_deleted_snapshots_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&prepare_for_backup_) -
      reinterpret_cast<char*>(&list_deleted_snapshots_)) + sizeof(prepare_for_backup_));
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ListSnapshotsRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.ListSnapshotsRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual9;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes snapshot_id = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_snapshot_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool list_deleted_snapshots = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_list_deleted_snapshots();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &list_deleted_snapshots_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool prepare_for_backup = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_prepare_for_backup();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &prepare_for_backup_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.ListSnapshotsRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.ListSnapshotsRequestPB)
  return false;
#undef DO_
}

void ListSnapshotsRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.ListSnapshotsRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional bool list_deleted_snapshots = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->list_deleted_snapshots(), output);
  }

  // optional bool prepare_for_backup = 4;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->prepare_for_backup(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.ListSnapshotsRequestPB)
}

::google::protobuf::uint8* ListSnapshotsRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.ListSnapshotsRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes snapshot_id = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->snapshot_id(), target);
  }

  // optional bool list_deleted_snapshots = 3;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->list_deleted_snapshots(), target);
  }

  // optional bool prepare_for_backup = 4;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->prepare_for_backup(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.ListSnapshotsRequestPB)
  return target;
}

size_t ListSnapshotsRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.ListSnapshotsRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional bytes snapshot_id = 2;
    if (has_snapshot_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->snapshot_id());
    }

    // optional bool list_deleted_snapshots = 3;
    if (has_list_deleted_snapshots()) {
      total_size += 1 + 1;
    }

    // optional bool prepare_for_backup = 4;
    if (has_prepare_for_backup()) {
      total_size += 1 + 1;
    }

  }
  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 ListSnapshotsRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.ListSnapshotsRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const ListSnapshotsRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ListSnapshotsRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.ListSnapshotsRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.ListSnapshotsRequestPB)
    MergeFrom(*source);
  }
}

void ListSnapshotsRequestPB::MergeFrom(const ListSnapshotsRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.ListSnapshotsRequestPB)
  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 & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_snapshot_id();
      snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      list_deleted_snapshots_ = from.list_deleted_snapshots_;
    }
    if (cached_has_bits & 0x00000004u) {
      prepare_for_backup_ = from.prepare_for_backup_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ListSnapshotsRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.ListSnapshotsRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ListSnapshotsRequestPB::CopyFrom(const ListSnapshotsRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.ListSnapshotsRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata ListSnapshotsRequestPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ListSnapshotsResponsePB::InitAsDefaultInstance() {
  ::yb::master::_ListSnapshotsResponsePB_default_instance_._instance.get_mutable()->error_ = const_cast< ::yb::master::MasterErrorPB*>(
      ::yb::master::MasterErrorPB::internal_default_instance());
}
void ListSnapshotsResponsePB::clear_error() {
  if (error_ != NULL) error_->Clear();
  clear_has_error();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ListSnapshotsResponsePB::kErrorFieldNumber;
const int ListSnapshotsResponsePB::kCurrentSnapshotIdFieldNumber;
const int ListSnapshotsResponsePB::kSnapshotsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ListSnapshotsResponsePB::ListSnapshotsResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotsResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.ListSnapshotsResponsePB)
}
ListSnapshotsResponsePB::ListSnapshotsResponsePB(const ListSnapshotsResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      snapshots_(from.snapshots_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  current_snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_current_snapshot_id()) {
    current_snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.current_snapshot_id_);
  }
  if (from.has_error()) {
    error_ = new ::yb::master::MasterErrorPB(*from.error_);
  } else {
    error_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.ListSnapshotsResponsePB)
}

void ListSnapshotsResponsePB::SharedCtor() {
  _cached_size_ = 0;
  current_snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  error_ = NULL;
}

ListSnapshotsResponsePB::~ListSnapshotsResponsePB() {
  // @@protoc_insertion_point(destructor:yb.master.ListSnapshotsResponsePB)
  SharedDtor();
}

void ListSnapshotsResponsePB::SharedDtor() {
  current_snapshot_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete error_;
}

void ListSnapshotsResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ListSnapshotsResponsePB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ListSnapshotsResponsePB& ListSnapshotsResponsePB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotsResponsePB();
  return *internal_default_instance();
}

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

void ListSnapshotsResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.ListSnapshotsResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  snapshots_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!current_snapshot_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*current_snapshot_id_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(error_ != NULL);
      error_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ListSnapshotsResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.ListSnapshotsResponsePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual9;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.master.MasterErrorPB error = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      // repeated .yb.master.SnapshotInfoPB snapshots = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_snapshots()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.ListSnapshotsResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.ListSnapshotsResponsePB)
  return false;
#undef DO_
}

void ListSnapshotsResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.ListSnapshotsResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->error_, output);
  }

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

  // repeated .yb.master.SnapshotInfoPB snapshots = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->snapshots_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->snapshots(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.ListSnapshotsResponsePB)
}

::google::protobuf::uint8* ListSnapshotsResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.ListSnapshotsResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->error_, deterministic, target);
  }

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

  // repeated .yb.master.SnapshotInfoPB snapshots = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->snapshots_size()); i < n; i++9) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, this->snapshots(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.ListSnapshotsResponsePB)
  return target;
}

size_t ListSnapshotsResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.ListSnapshotsResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.SnapshotInfoPB snapshots = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->snapshots_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++18) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->snapshots(static_cast<int>(i)));
    }
  }

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

    // optional .yb.master.MasterErrorPB error = 1;
    if (has_error()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->error_);
    }

  }
  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 ListSnapshotsResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.ListSnapshotsResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const ListSnapshotsResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ListSnapshotsResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.ListSnapshotsResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.ListSnapshotsResponsePB)
    MergeFrom(*source);
  }
}

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

  snapshots_.MergeFrom(from.snapshots_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_current_snapshot_id();
      current_snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.current_snapshot_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_error()->::yb::master::MasterErrorPB::MergeFrom(from.error());
    }
  }
}

void ListSnapshotsResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.ListSnapshotsResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ListSnapshotsResponsePB::CopyFrom(const ListSnapshotsResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.ListSnapshotsResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ListSnapshotsResponsePB::IsInitialized() const {
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata ListSnapshotsResponsePB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RestoreSnapshotRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RestoreSnapshotRequestPB::kSnapshotIdFieldNumber;
const int RestoreSnapshotRequestPB::kRestoreHtFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RestoreSnapshotRequestPB::RestoreSnapshotRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsRestoreSnapshotRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.RestoreSnapshotRequestPB)
}
RestoreSnapshotRequestPB::RestoreSnapshotRequestPB(const RestoreSnapshotRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_id()) {
    snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
  }
  restore_ht_ = from.restore_ht_;
  // @@protoc_insertion_point(copy_constructor:yb.master.RestoreSnapshotRequestPB)
}

void RestoreSnapshotRequestPB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  restore_ht_ = GOOGLE_ULONGLONG(0);
}

RestoreSnapshotRequestPB::~RestoreSnapshotRequestPB() {
  // @@protoc_insertion_point(destructor:yb.master.RestoreSnapshotRequestPB)
  SharedDtor();
}

void RestoreSnapshotRequestPB::SharedDtor() {
  snapshot_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void RestoreSnapshotRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RestoreSnapshotRequestPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RestoreSnapshotRequestPB& RestoreSnapshotRequestPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsRestoreSnapshotRequestPB();
  return *internal_default_instance();
}

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

void RestoreSnapshotRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.RestoreSnapshotRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!snapshot_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*snapshot_id_.UnsafeRawStringPointer())->clear();
  }
  restore_ht_ = GOOGLE_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RestoreSnapshotRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.RestoreSnapshotRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual3;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes snapshot_id = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_snapshot_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional fixed64 restore_ht = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(25u /* 25 & 0xFF */)) {
          set_has_restore_ht();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &restore_ht_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.RestoreSnapshotRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.RestoreSnapshotRequestPB)
  return false;
#undef DO_
}

void RestoreSnapshotRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.RestoreSnapshotRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional fixed64 restore_ht = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->restore_ht(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.RestoreSnapshotRequestPB)
}

::google::protobuf::uint8* RestoreSnapshotRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.RestoreSnapshotRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes snapshot_id = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->snapshot_id(), target);
  }

  // optional fixed64 restore_ht = 3;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->restore_ht(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.RestoreSnapshotRequestPB)
  return target;
}

size_t RestoreSnapshotRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.RestoreSnapshotRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes snapshot_id = 2;
    if (has_snapshot_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->snapshot_id());
    }

    // optional fixed64 restore_ht = 3;
    if (has_restore_ht()) {
      total_size += 1 + 8;
    }

  }
  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 RestoreSnapshotRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.RestoreSnapshotRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RestoreSnapshotRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RestoreSnapshotRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.RestoreSnapshotRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.RestoreSnapshotRequestPB)
    MergeFrom(*source);
  }
}

void RestoreSnapshotRequestPB::MergeFrom(const RestoreSnapshotRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.RestoreSnapshotRequestPB)
  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_snapshot_id();
      snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      restore_ht_ = from.restore_ht_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RestoreSnapshotRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.RestoreSnapshotRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RestoreSnapshotRequestPB::CopyFrom(const RestoreSnapshotRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.RestoreSnapshotRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata RestoreSnapshotRequestPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RestoreSnapshotResponsePB::InitAsDefaultInstance() {
  ::yb::master::_RestoreSnapshotResponsePB_default_instance_._instance.get_mutable()->error_ = const_cast< ::yb::master::MasterErrorPB*>(
      ::yb::master::MasterErrorPB::internal_default_instance());
}
void RestoreSnapshotResponsePB::clear_error() {
  if (error_ != NULL) error_->Clear();
  clear_has_error();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RestoreSnapshotResponsePB::kErrorFieldNumber;
const int RestoreSnapshotResponsePB::kRestorationIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RestoreSnapshotResponsePB::RestoreSnapshotResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsRestoreSnapshotResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.RestoreSnapshotResponsePB)
}
RestoreSnapshotResponsePB::RestoreSnapshotResponsePB(const RestoreSnapshotResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  restoration_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_restoration_id()) {
    restoration_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.restoration_id_);
  }
  if (from.has_error()) {
    error_ = new ::yb::master::MasterErrorPB(*from.error_);
  } else {
    error_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.RestoreSnapshotResponsePB)
}

void RestoreSnapshotResponsePB::SharedCtor() {
  _cached_size_ = 0;
  restoration_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  error_ = NULL;
}

RestoreSnapshotResponsePB::~RestoreSnapshotResponsePB() {
  // @@protoc_insertion_point(destructor:yb.master.RestoreSnapshotResponsePB)
  SharedDtor();
}

void RestoreSnapshotResponsePB::SharedDtor() {
  restoration_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete error_;
}

void RestoreSnapshotResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RestoreSnapshotResponsePB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RestoreSnapshotResponsePB& RestoreSnapshotResponsePB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsRestoreSnapshotResponsePB();
  return *internal_default_instance();
}

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

void RestoreSnapshotResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.RestoreSnapshotResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!restoration_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*restoration_id_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(error_ != NULL);
      error_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RestoreSnapshotResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.RestoreSnapshotResponsePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual3;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.master.MasterErrorPB error = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.RestoreSnapshotResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.RestoreSnapshotResponsePB)
  return false;
#undef DO_
}

void RestoreSnapshotResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.RestoreSnapshotResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->error_, output);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.RestoreSnapshotResponsePB)
}

::google::protobuf::uint8* RestoreSnapshotResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.RestoreSnapshotResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->error_, deterministic, target);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.RestoreSnapshotResponsePB)
  return target;
}

size_t RestoreSnapshotResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.RestoreSnapshotResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes restoration_id = 2;
    if (has_restoration_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->restoration_id());
    }

    // optional .yb.master.MasterErrorPB error = 1;
    if (has_error()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->error_);
    }

  }
  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 RestoreSnapshotResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.RestoreSnapshotResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const RestoreSnapshotResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RestoreSnapshotResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.RestoreSnapshotResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.RestoreSnapshotResponsePB)
    MergeFrom(*source);
  }
}

void RestoreSnapshotResponsePB::MergeFrom(const RestoreSnapshotResponsePB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.RestoreSnapshotResponsePB)
  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_restoration_id();
      restoration_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.restoration_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_error()->::yb::master::MasterErrorPB::MergeFrom(from.error());
    }
  }
}

void RestoreSnapshotResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.RestoreSnapshotResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RestoreSnapshotResponsePB::CopyFrom(const RestoreSnapshotResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.RestoreSnapshotResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RestoreSnapshotResponsePB::IsInitialized() const {
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata RestoreSnapshotResponsePB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void DeleteSnapshotRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DeleteSnapshotRequestPB::kSnapshotIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DeleteSnapshotRequestPB::DeleteSnapshotRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsDeleteSnapshotRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.DeleteSnapshotRequestPB)
}
DeleteSnapshotRequestPB::DeleteSnapshotRequestPB(const DeleteSnapshotRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_id()) {
    snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.DeleteSnapshotRequestPB)
}

void DeleteSnapshotRequestPB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

DeleteSnapshotRequestPB::~DeleteSnapshotRequestPB() {
  // @@protoc_insertion_point(destructor:yb.master.DeleteSnapshotRequestPB)
  SharedDtor();
}

void DeleteSnapshotRequestPB::SharedDtor() {
  snapshot_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void DeleteSnapshotRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DeleteSnapshotRequestPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const DeleteSnapshotRequestPB& DeleteSnapshotRequestPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsDeleteSnapshotRequestPB();
  return *internal_default_instance();
}

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

void DeleteSnapshotRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.DeleteSnapshotRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!snapshot_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*snapshot_id_.UnsafeRawStringPointer())->clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DeleteSnapshotRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.DeleteSnapshotRequestPB)
  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 snapshot_id = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_snapshot_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.DeleteSnapshotRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.DeleteSnapshotRequestPB)
  return false;
#undef DO_
}

void DeleteSnapshotRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.DeleteSnapshotRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.DeleteSnapshotRequestPB)
}

::google::protobuf::uint8* DeleteSnapshotRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.DeleteSnapshotRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes snapshot_id = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->snapshot_id(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.DeleteSnapshotRequestPB)
  return target;
}

size_t DeleteSnapshotRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.DeleteSnapshotRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional bytes snapshot_id = 2;
  if (has_snapshot_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->snapshot_id());
  }

  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 DeleteSnapshotRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.DeleteSnapshotRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const DeleteSnapshotRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DeleteSnapshotRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.DeleteSnapshotRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.DeleteSnapshotRequestPB)
    MergeFrom(*source);
  }
}

void DeleteSnapshotRequestPB::MergeFrom(const DeleteSnapshotRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.DeleteSnapshotRequestPB)
  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_snapshot_id()) {
    set_has_snapshot_id();
    snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
  }
}

void DeleteSnapshotRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.DeleteSnapshotRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DeleteSnapshotRequestPB::CopyFrom(const DeleteSnapshotRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.DeleteSnapshotRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata DeleteSnapshotRequestPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void DeleteSnapshotResponsePB::InitAsDefaultInstance() {
  ::yb::master::_DeleteSnapshotResponsePB_default_instance_._instance.get_mutable()->error_ = const_cast< ::yb::master::MasterErrorPB*>(
      ::yb::master::MasterErrorPB::internal_default_instance());
}
void DeleteSnapshotResponsePB::clear_error() {
  if (error_ != NULL) error_->Clear();
  clear_has_error();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DeleteSnapshotResponsePB::kErrorFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DeleteSnapshotResponsePB::DeleteSnapshotResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsDeleteSnapshotResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.DeleteSnapshotResponsePB)
}
DeleteSnapshotResponsePB::DeleteSnapshotResponsePB(const DeleteSnapshotResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_error()) {
    error_ = new ::yb::master::MasterErrorPB(*from.error_);
  } else {
    error_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.DeleteSnapshotResponsePB)
}

void DeleteSnapshotResponsePB::SharedCtor() {
  _cached_size_ = 0;
  error_ = NULL;
}

DeleteSnapshotResponsePB::~DeleteSnapshotResponsePB() {
  // @@protoc_insertion_point(destructor:yb.master.DeleteSnapshotResponsePB)
  SharedDtor();
}

void DeleteSnapshotResponsePB::SharedDtor() {
  if (this != internal_default_instance()) delete error_;
}

void DeleteSnapshotResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DeleteSnapshotResponsePB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const DeleteSnapshotResponsePB& DeleteSnapshotResponsePB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsDeleteSnapshotResponsePB();
  return *internal_default_instance();
}

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

void DeleteSnapshotResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.DeleteSnapshotResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(error_ != NULL);
    error_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DeleteSnapshotResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.DeleteSnapshotResponsePB)
  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 .yb.master.MasterErrorPB error = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.DeleteSnapshotResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.DeleteSnapshotResponsePB)
  return false;
#undef DO_
}

void DeleteSnapshotResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.DeleteSnapshotResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->error_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.DeleteSnapshotResponsePB)
}

::google::protobuf::uint8* DeleteSnapshotResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.DeleteSnapshotResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->error_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.DeleteSnapshotResponsePB)
  return target;
}

size_t DeleteSnapshotResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.DeleteSnapshotResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .yb.master.MasterErrorPB error = 1;
  if (has_error()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSize(
        *this->error_);
  }

  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 DeleteSnapshotResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.DeleteSnapshotResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const DeleteSnapshotResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DeleteSnapshotResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.DeleteSnapshotResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.DeleteSnapshotResponsePB)
    MergeFrom(*source);
  }
}

void DeleteSnapshotResponsePB::MergeFrom(const DeleteSnapshotResponsePB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.DeleteSnapshotResponsePB)
  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_error()) {
    mutable_error()->::yb::master::MasterErrorPB::MergeFrom(from.error());
  }
}

void DeleteSnapshotResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.DeleteSnapshotResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DeleteSnapshotResponsePB::CopyFrom(const DeleteSnapshotResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.DeleteSnapshotResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DeleteSnapshotResponsePB::IsInitialized() const {
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata DeleteSnapshotResponsePB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ImportSnapshotMetaRequestPB::InitAsDefaultInstance() {
  ::yb::master::_ImportSnapshotMetaRequestPB_default_instance_._instance.get_mutable()->snapshot_ = const_cast< ::yb::master::SnapshotInfoPB*>(
      ::yb::master::SnapshotInfoPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ImportSnapshotMetaRequestPB::kSnapshotFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ImportSnapshotMetaRequestPB::ImportSnapshotMetaRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsImportSnapshotMetaRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.ImportSnapshotMetaRequestPB)
}
ImportSnapshotMetaRequestPB::ImportSnapshotMetaRequestPB(const ImportSnapshotMetaRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_snapshot()) {
    snapshot_ = new ::yb::master::SnapshotInfoPB(*from.snapshot_);
  } else {
    snapshot_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.ImportSnapshotMetaRequestPB)
}

void ImportSnapshotMetaRequestPB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_ = NULL;
}

ImportSnapshotMetaRequestPB::~ImportSnapshotMetaRequestPB() {
  // @@protoc_insertion_point(destructor:yb.master.ImportSnapshotMetaRequestPB)
  SharedDtor();
}

void ImportSnapshotMetaRequestPB::SharedDtor() {
  if (this != internal_default_instance()) delete snapshot_;
}

void ImportSnapshotMetaRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ImportSnapshotMetaRequestPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ImportSnapshotMetaRequestPB& ImportSnapshotMetaRequestPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsImportSnapshotMetaRequestPB();
  return *internal_default_instance();
}

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

void ImportSnapshotMetaRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.ImportSnapshotMetaRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(snapshot_ != NULL);
    snapshot_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ImportSnapshotMetaRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.ImportSnapshotMetaRequestPB)
  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 .yb.master.SnapshotInfoPB snapshot = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_snapshot()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.ImportSnapshotMetaRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.ImportSnapshotMetaRequestPB)
  return false;
#undef DO_
}

void ImportSnapshotMetaRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.ImportSnapshotMetaRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SnapshotInfoPB snapshot = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->snapshot_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.ImportSnapshotMetaRequestPB)
}

::google::protobuf::uint8* ImportSnapshotMetaRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.ImportSnapshotMetaRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SnapshotInfoPB snapshot = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->snapshot_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.ImportSnapshotMetaRequestPB)
  return target;
}

size_t ImportSnapshotMetaRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.ImportSnapshotMetaRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .yb.master.SnapshotInfoPB snapshot = 1;
  if (has_snapshot()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSize(
        *this->snapshot_);
  }

  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 ImportSnapshotMetaRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.ImportSnapshotMetaRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const ImportSnapshotMetaRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ImportSnapshotMetaRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.ImportSnapshotMetaRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.ImportSnapshotMetaRequestPB)
    MergeFrom(*source);
  }
}

void ImportSnapshotMetaRequestPB::MergeFrom(const ImportSnapshotMetaRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.ImportSnapshotMetaRequestPB)
  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_snapshot()) {
    mutable_snapshot()->::yb::master::SnapshotInfoPB::MergeFrom(from.snapshot());
  }
}

void ImportSnapshotMetaRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.ImportSnapshotMetaRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ImportSnapshotMetaRequestPB::CopyFrom(const ImportSnapshotMetaRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.ImportSnapshotMetaRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata ImportSnapshotMetaRequestPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ListSnapshotRestorationsRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ListSnapshotRestorationsRequestPB::kSnapshotIdFieldNumber;
const int ListSnapshotRestorationsRequestPB::kRestorationIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ListSnapshotRestorationsRequestPB::ListSnapshotRestorationsRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotRestorationsRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.ListSnapshotRestorationsRequestPB)
}
ListSnapshotRestorationsRequestPB::ListSnapshotRestorationsRequestPB(const ListSnapshotRestorationsRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_id()) {
    snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
  }
  restoration_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_restoration_id()) {
    restoration_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.restoration_id_);
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.ListSnapshotRestorationsRequestPB)
}

void ListSnapshotRestorationsRequestPB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  restoration_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

ListSnapshotRestorationsRequestPB::~ListSnapshotRestorationsRequestPB() {
  // @@protoc_insertion_point(destructor:yb.master.ListSnapshotRestorationsRequestPB)
  SharedDtor();
}

void ListSnapshotRestorationsRequestPB::SharedDtor() {
  snapshot_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  restoration_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void ListSnapshotRestorationsRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ListSnapshotRestorationsRequestPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ListSnapshotRestorationsRequestPB& ListSnapshotRestorationsRequestPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotRestorationsRequestPB();
  return *internal_default_instance();
}

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

void ListSnapshotRestorationsRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.ListSnapshotRestorationsRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!snapshot_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*snapshot_id_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!restoration_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*restoration_id_.UnsafeRawStringPointer())->clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ListSnapshotRestorationsRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (5!GOOGLE_PREDICT_TRUE5(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.ListSnapshotRestorationsRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual6;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes snapshot_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_snapshot_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.ListSnapshotRestorationsRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.ListSnapshotRestorationsRequestPB)
  return false;
#undef DO_
}

void ListSnapshotRestorationsRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.ListSnapshotRestorationsRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.ListSnapshotRestorationsRequestPB)
}

::google::protobuf::uint8* ListSnapshotRestorationsRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.ListSnapshotRestorationsRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional bytes restoration_id = 2;
  if (cached_has_bits & 0x00000002u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->restoration_id(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.ListSnapshotRestorationsRequestPB)
  return target;
}

size_t ListSnapshotRestorationsRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.ListSnapshotRestorationsRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes snapshot_id = 1;
    if (has_snapshot_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->snapshot_id());
    }

    // optional bytes restoration_id = 2;
    if (has_restoration_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->restoration_id());
    }

  }
  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 ListSnapshotRestorationsRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.ListSnapshotRestorationsRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const ListSnapshotRestorationsRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ListSnapshotRestorationsRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.ListSnapshotRestorationsRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.ListSnapshotRestorationsRequestPB)
    MergeFrom(*source);
  }
}

void ListSnapshotRestorationsRequestPB::MergeFrom(const ListSnapshotRestorationsRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.ListSnapshotRestorationsRequestPB)
  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_snapshot_id();
      snapshot_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_restoration_id();
      restoration_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.restoration_id_);
    }
  }
}

void ListSnapshotRestorationsRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.ListSnapshotRestorationsRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ListSnapshotRestorationsRequestPB::CopyFrom(const ListSnapshotRestorationsRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.ListSnapshotRestorationsRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata ListSnapshotRestorationsRequestPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ListSnapshotRestorationsResponsePB::InitAsDefaultInstance() {
  ::yb::master::_ListSnapshotRestorationsResponsePB_default_instance_._instance.get_mutable()->status_ = const_cast< ::yb::AppStatusPB*>(
      ::yb::AppStatusPB::internal_default_instance());
}
void ListSnapshotRestorationsResponsePB::clear_status() {
  if (status_ != NULL) status_->Clear();
  clear_has_status();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ListSnapshotRestorationsResponsePB::kStatusFieldNumber;
const int ListSnapshotRestorationsResponsePB::kRestorationsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ListSnapshotRestorationsResponsePB::ListSnapshotRestorationsResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotRestorationsResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.ListSnapshotRestorationsResponsePB)
}
ListSnapshotRestorationsResponsePB::ListSnapshotRestorationsResponsePB(const ListSnapshotRestorationsResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      restorations_(from.restorations_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_status()) {
    status_ = new ::yb::AppStatusPB(*from.status_);
  } else {
    status_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.ListSnapshotRestorationsResponsePB)
}

void ListSnapshotRestorationsResponsePB::SharedCtor() {
  _cached_size_ = 0;
  status_ = NULL;
}

ListSnapshotRestorationsResponsePB::~ListSnapshotRestorationsResponsePB() {
  // @@protoc_insertion_point(destructor:yb.master.ListSnapshotRestorationsResponsePB)
  SharedDtor();
}

void ListSnapshotRestorationsResponsePB::SharedDtor() {
  if (this != internal_default_instance()) delete status_;
}

void ListSnapshotRestorationsResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ListSnapshotRestorationsResponsePB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ListSnapshotRestorationsResponsePB& ListSnapshotRestorationsResponsePB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotRestorationsResponsePB();
  return *internal_default_instance();
}

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

void ListSnapshotRestorationsResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.ListSnapshotRestorationsResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  restorations_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(status_ != NULL);
    status_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ListSnapshotRestorationsResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (5!GOOGLE_PREDICT_TRUE5(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.ListSnapshotRestorationsResponsePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual6;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.AppStatusPB status = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_status()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .yb.master.RestorationInfoPB restorations = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_restorations()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.ListSnapshotRestorationsResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.ListSnapshotRestorationsResponsePB)
  return false;
#undef DO_
}

void ListSnapshotRestorationsResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.ListSnapshotRestorationsResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.AppStatusPB status = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->status_, output);
  }

  // repeated .yb.master.RestorationInfoPB restorations = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->restorations_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->restorations(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.ListSnapshotRestorationsResponsePB)
}

::google::protobuf::uint8* ListSnapshotRestorationsResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.ListSnapshotRestorationsResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.AppStatusPB status = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->status_, deterministic, target);
  }

  // repeated .yb.master.RestorationInfoPB restorations = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->restorations_size()); i < n; i++5) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, this->restorations(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.ListSnapshotRestorationsResponsePB)
  return target;
}

size_t ListSnapshotRestorationsResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.ListSnapshotRestorationsResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.RestorationInfoPB restorations = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->restorations_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++10) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->restorations(static_cast<int>(i)));
    }
  }

  // optional .yb.AppStatusPB status = 1;
  if (has_status()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSize(
        *this->status_);
  }

  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 ListSnapshotRestorationsResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.ListSnapshotRestorationsResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const ListSnapshotRestorationsResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ListSnapshotRestorationsResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.ListSnapshotRestorationsResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.ListSnapshotRestorationsResponsePB)
    MergeFrom(*source);
  }
}

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

  restorations_.MergeFrom(from.restorations_);
  if (from.has_status()) {
    mutable_status()->::yb::AppStatusPB::MergeFrom(from.status());
  }
}

void ListSnapshotRestorationsResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.ListSnapshotRestorationsResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ListSnapshotRestorationsResponsePB::CopyFrom(const ListSnapshotRestorationsResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.ListSnapshotRestorationsResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ListSnapshotRestorationsResponsePB::IsInitialized() const {
  if (has_status()) {
    if (!this->status_->IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata ListSnapshotRestorationsResponsePB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void IdPairPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int IdPairPB::kOldIdFieldNumber;
const int IdPairPB::kNewIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

IdPairPB::IdPairPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsIdPairPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.IdPairPB)
}
IdPairPB::IdPairPB(const IdPairPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  old_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_old_id()) {
    old_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.old_id_);
  }
  new_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_new_id()) {
    new_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.new_id_);
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.IdPairPB)
}

void IdPairPB::SharedCtor() {
  _cached_size_ = 0;
  old_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  new_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

IdPairPB::~IdPairPB() {
  // @@protoc_insertion_point(destructor:yb.master.IdPairPB)
  SharedDtor();
}

void IdPairPB::SharedDtor() {
  old_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  new_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void IdPairPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* IdPairPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const IdPairPB& IdPairPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsIdPairPB();
  return *internal_default_instance();
}

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

void IdPairPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.IdPairPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!old_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*old_id_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!new_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*new_id_.UnsafeRawStringPointer())->clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool IdPairPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.IdPairPB)
  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 old_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_old_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.IdPairPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.IdPairPB)
  return false;
#undef DO_
}

void IdPairPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.IdPairPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.IdPairPB)
}

::google::protobuf::uint8* IdPairPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.IdPairPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional bytes new_id = 2;
  if (cached_has_bits & 0x00000002u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->new_id(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.IdPairPB)
  return target;
}

size_t IdPairPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.IdPairPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes old_id = 1;
    if (has_old_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->old_id());
    }

    // optional bytes new_id = 2;
    if (has_new_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->new_id());
    }

  }
  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 IdPairPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.IdPairPB)
  GOOGLE_DCHECK_NE(&from, this);
  const IdPairPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const IdPairPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.IdPairPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.IdPairPB)
    MergeFrom(*source);
  }
}

void IdPairPB::MergeFrom(const IdPairPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.IdPairPB)
  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_old_id();
      old_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.old_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_new_id();
      new_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.new_id_);
    }
  }
}

void IdPairPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.IdPairPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void IdPairPB::CopyFrom(const IdPairPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.IdPairPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata IdPairPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ImportSnapshotMetaResponsePB_TableMetaPB::InitAsDefaultInstance() {
  ::yb::master::_ImportSnapshotMetaResponsePB_TableMetaPB_default_instance_._instance.get_mutable()->namespace_ids_ = const_cast< ::yb::master::IdPairPB*>(
      ::yb::master::IdPairPB::internal_default_instance());
  ::yb::master::_ImportSnapshotMetaResponsePB_TableMetaPB_default_instance_._instance.get_mutable()->table_ids_ = const_cast< ::yb::master::IdPairPB*>(
      ::yb::master::IdPairPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ImportSnapshotMetaResponsePB_TableMetaPB::kNamespaceIdsFieldNumber;
const int ImportSnapshotMetaResponsePB_TableMetaPB::kTableIdsFieldNumber;
const int ImportSnapshotMetaResponsePB_TableMetaPB::kTabletsIdsFieldNumber;
const int ImportSnapshotMetaResponsePB_TableMetaPB::kTableTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ImportSnapshotMetaResponsePB_TableMetaPB::ImportSnapshotMetaResponsePB_TableMetaPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsImportSnapshotMetaResponsePB_TableMetaPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
}
ImportSnapshotMetaResponsePB_TableMetaPB::ImportSnapshotMetaResponsePB_TableMetaPB(const ImportSnapshotMetaResponsePB_TableMetaPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      tablets_ids_(from.tablets_ids_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_namespace_ids()) {
    namespace_ids_ = new ::yb::master::IdPairPB(*from.namespace_ids_);
  } else {
    namespace_ids_ = NULL;
  }
  if (from.has_table_ids()) {
    table_ids_ = new ::yb::master::IdPairPB(*from.table_ids_);
  } else {
    table_ids_ = NULL;
  }
  table_type_ = from.table_type_;
  // @@protoc_insertion_point(copy_constructor:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
}

void ImportSnapshotMetaResponsePB_TableMetaPB::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&namespace_ids_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&table_type_) -
      reinterpret_cast<char*>(&namespace_ids_)) + sizeof(table_type_));
}

ImportSnapshotMetaResponsePB_TableMetaPB::~ImportSnapshotMetaResponsePB_TableMetaPB() {
  // @@protoc_insertion_point(destructor:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  SharedDtor();
}

void ImportSnapshotMetaResponsePB_TableMetaPB::SharedDtor() {
  if (this != internal_default_instance()) delete namespace_ids_;
  if (this != internal_default_instance()) delete table_ids_;
}

void ImportSnapshotMetaResponsePB_TableMetaPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ImportSnapshotMetaResponsePB_TableMetaPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ImportSnapshotMetaResponsePB_TableMetaPB& ImportSnapshotMetaResponsePB_TableMetaPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsImportSnapshotMetaResponsePB_TableMetaPB();
  return *internal_default_instance();
}

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

void ImportSnapshotMetaResponsePB_TableMetaPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  tablets_ids_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(namespace_ids_ != NULL);
      namespace_ids_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(table_ids_ != NULL);
      table_ids_->Clear();
    }
  }
  table_type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ImportSnapshotMetaResponsePB_TableMetaPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  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 .yb.master.IdPairPB namespace_ids = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_namespace_ids()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.master.IdPairPB table_ids = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_table_ids()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .yb.master.IdPairPB tablets_ids = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_tablets_ids()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.master.ImportSnapshotMetaResponsePB.TableType table_type = 4 [default = TABLE];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::master::ImportSnapshotMetaResponsePB_TableType_IsValid(value)) {
            set_table_type(static_cast< ::yb::master::ImportSnapshotMetaResponsePB_TableType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                4, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  return false;
#undef DO_
}

void ImportSnapshotMetaResponsePB_TableMetaPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.IdPairPB namespace_ids = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->namespace_ids_, output);
  }

  // optional .yb.master.IdPairPB table_ids = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->table_ids_, output);
  }

  // repeated .yb.master.IdPairPB tablets_ids = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tablets_ids_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->tablets_ids(static_cast<int>(i)), output);
  }

  // optional .yb.master.ImportSnapshotMetaResponsePB.TableType table_type = 4 [default = TABLE];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->table_type(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
}

::google::protobuf::uint8* ImportSnapshotMetaResponsePB_TableMetaPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.IdPairPB namespace_ids = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->namespace_ids_, deterministic, target);
  }

  // optional .yb.master.IdPairPB table_ids = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, *this->table_ids_, deterministic, target);
  }

  // repeated .yb.master.IdPairPB tablets_ids = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tablets_ids_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, this->tablets_ids(static_cast<int>(i)), deterministic, target);
  }

  // optional .yb.master.ImportSnapshotMetaResponsePB.TableType table_type = 4 [default = TABLE];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->table_type(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  return target;
}

size_t ImportSnapshotMetaResponsePB_TableMetaPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.IdPairPB tablets_ids = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->tablets_ids_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->tablets_ids(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 7u) {
    // optional .yb.master.IdPairPB namespace_ids = 1;
    if (has_namespace_ids()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->namespace_ids_);
    }

    // optional .yb.master.IdPairPB table_ids = 2;
    if (has_table_ids()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->table_ids_);
    }

    // optional .yb.master.ImportSnapshotMetaResponsePB.TableType table_type = 4 [default = TABLE];
    if (has_table_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->table_type());
    }

  }
  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 ImportSnapshotMetaResponsePB_TableMetaPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  GOOGLE_DCHECK_NE(&from, this);
  const ImportSnapshotMetaResponsePB_TableMetaPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ImportSnapshotMetaResponsePB_TableMetaPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
    MergeFrom(*source);
  }
}

void ImportSnapshotMetaResponsePB_TableMetaPB::MergeFrom(const ImportSnapshotMetaResponsePB_TableMetaPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  tablets_ids_.MergeFrom(from.tablets_ids_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_namespace_ids()->::yb::master::IdPairPB::MergeFrom(from.namespace_ids());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_table_ids()->::yb::master::IdPairPB::MergeFrom(from.table_ids());
    }
    if (cached_has_bits & 0x00000004u) {
      table_type_ = from.table_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ImportSnapshotMetaResponsePB_TableMetaPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ImportSnapshotMetaResponsePB_TableMetaPB::CopyFrom(const ImportSnapshotMetaResponsePB_TableMetaPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.ImportSnapshotMetaResponsePB.TableMetaPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void ImportSnapshotMetaResponsePB_TableMetaPB::Swap(ImportSnapshotMetaResponsePB_TableMetaPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ImportSnapshotMetaResponsePB_TableMetaPB::InternalSwap(ImportSnapshotMetaResponsePB_TableMetaPB* other) {
  using std::swap;
  tablets_ids_.InternalSwap(&other->tablets_ids_);
  swap(namespace_ids_, other->namespace_ids_);
  swap(table_ids_, other->table_ids_);
  swap(table_type_, other->table_type_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ImportSnapshotMetaResponsePB_TableMetaPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ImportSnapshotMetaResponsePB::InitAsDefaultInstance() {
  ::yb::master::_ImportSnapshotMetaResponsePB_default_instance_._instance.get_mutable()->error_ = const_cast< ::yb::master::MasterErrorPB*>(
      ::yb::master::MasterErrorPB::internal_default_instance());
}
void ImportSnapshotMetaResponsePB::clear_error() {
  if (error_ != NULL) error_->Clear();
  clear_has_error();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ImportSnapshotMetaResponsePB::kErrorFieldNumber;
const int ImportSnapshotMetaResponsePB::kTablesMetaFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ImportSnapshotMetaResponsePB::ImportSnapshotMetaResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsImportSnapshotMetaResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.ImportSnapshotMetaResponsePB)
}
ImportSnapshotMetaResponsePB::ImportSnapshotMetaResponsePB(const ImportSnapshotMetaResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      tables_meta_(from.tables_meta_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_error()) {
    error_ = new ::yb::master::MasterErrorPB(*from.error_);
  } else {
    error_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.ImportSnapshotMetaResponsePB)
}

void ImportSnapshotMetaResponsePB::SharedCtor() {
  _cached_size_ = 0;
  error_ = NULL;
}

ImportSnapshotMetaResponsePB::~ImportSnapshotMetaResponsePB() {
  // @@protoc_insertion_point(destructor:yb.master.ImportSnapshotMetaResponsePB)
  SharedDtor();
}

void ImportSnapshotMetaResponsePB::SharedDtor() {
  if (this != internal_default_instance()) delete error_;
}

void ImportSnapshotMetaResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ImportSnapshotMetaResponsePB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ImportSnapshotMetaResponsePB& ImportSnapshotMetaResponsePB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsImportSnapshotMetaResponsePB();
  return *internal_default_instance();
}

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

void ImportSnapshotMetaResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.ImportSnapshotMetaResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  tables_meta_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(error_ != NULL);
    error_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ImportSnapshotMetaResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.ImportSnapshotMetaResponsePB)
  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 .yb.master.MasterErrorPB error = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .yb.master.ImportSnapshotMetaResponsePB.TableMetaPB tables_meta = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_tables_meta()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.ImportSnapshotMetaResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.ImportSnapshotMetaResponsePB)
  return false;
#undef DO_
}

void ImportSnapshotMetaResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.ImportSnapshotMetaResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->error_, output);
  }

  // repeated .yb.master.ImportSnapshotMetaResponsePB.TableMetaPB tables_meta = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tables_meta_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->tables_meta(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.ImportSnapshotMetaResponsePB)
}

::google::protobuf::uint8* ImportSnapshotMetaResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.ImportSnapshotMetaResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->error_, deterministic, target);
  }

  // repeated .yb.master.ImportSnapshotMetaResponsePB.TableMetaPB tables_meta = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tables_meta_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, this->tables_meta(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.ImportSnapshotMetaResponsePB)
  return target;
}

size_t ImportSnapshotMetaResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.ImportSnapshotMetaResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.ImportSnapshotMetaResponsePB.TableMetaPB tables_meta = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->tables_meta_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->tables_meta(static_cast<int>(i)));
    }
  }

  // optional .yb.master.MasterErrorPB error = 1;
  if (has_error()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSize(
        *this->error_);
  }

  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 ImportSnapshotMetaResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.ImportSnapshotMetaResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const ImportSnapshotMetaResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ImportSnapshotMetaResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.ImportSnapshotMetaResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.ImportSnapshotMetaResponsePB)
    MergeFrom(*source);
  }
}

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

  tables_meta_.MergeFrom(from.tables_meta_);
  if (from.has_error()) {
    mutable_error()->::yb::master::MasterErrorPB::MergeFrom(from.error());
  }
}

void ImportSnapshotMetaResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.ImportSnapshotMetaResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ImportSnapshotMetaResponsePB::CopyFrom(const ImportSnapshotMetaResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.ImportSnapshotMetaResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ImportSnapshotMetaResponsePB::IsInitialized() const {
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata ImportSnapshotMetaResponsePB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TableIdentifiersPB::InitAsDefaultInstance() {
}
void TableIdentifiersPB::clear_tables() {
  tables_.Clear();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TableIdentifiersPB::kTablesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TableIdentifiersPB::TableIdentifiersPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsTableIdentifiersPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.TableIdentifiersPB)
}
TableIdentifiersPB::TableIdentifiersPB(const TableIdentifiersPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      tables_(from.tables_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:yb.master.TableIdentifiersPB)
}

void TableIdentifiersPB::SharedCtor() {
  _cached_size_ = 0;
}

TableIdentifiersPB::~TableIdentifiersPB() {
  // @@protoc_insertion_point(destructor:yb.master.TableIdentifiersPB)
  SharedDtor();
}

void TableIdentifiersPB::SharedDtor() {
}

void TableIdentifiersPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TableIdentifiersPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TableIdentifiersPB& TableIdentifiersPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsTableIdentifiersPB();
  return *internal_default_instance();
}

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

void TableIdentifiersPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.TableIdentifiersPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  tables_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TableIdentifiersPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.TableIdentifiersPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual52;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .yb.master.TableIdentifierPB tables = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_tables()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.TableIdentifiersPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.TableIdentifiersPB)
  return false;
#undef DO_
}

void TableIdentifiersPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.TableIdentifiersPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .yb.master.TableIdentifierPB tables = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tables_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->tables(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.TableIdentifiersPB)
}

::google::protobuf::uint8* TableIdentifiersPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.TableIdentifiersPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .yb.master.TableIdentifierPB tables = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tables_size()); i < n; i++30) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, this->tables(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.TableIdentifiersPB)
  return target;
}

size_t TableIdentifiersPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.TableIdentifiersPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.TableIdentifierPB tables = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->tables_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++49) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->tables(static_cast<int>(i)));
    }
  }

  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 TableIdentifiersPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.TableIdentifiersPB)
  GOOGLE_DCHECK_NE(&from, this);
  const TableIdentifiersPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TableIdentifiersPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.TableIdentifiersPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.TableIdentifiersPB)
    MergeFrom(*source);
  }
}

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

  tables_.MergeFrom(from.tables_);
}

void TableIdentifiersPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.TableIdentifiersPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TableIdentifiersPB::CopyFrom(const TableIdentifiersPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.TableIdentifiersPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata TableIdentifiersPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SnapshotScheduleFilterPB::InitAsDefaultInstance() {
  ::yb::master::_SnapshotScheduleFilterPB_default_instance_.tables_ = const_cast< ::yb::master::TableIdentifiersPB*>(
      ::yb::master::TableIdentifiersPB::internal_default_instance());
}
void SnapshotScheduleFilterPB::set_allocated_tables(::yb::master::TableIdentifiersPB* tables) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_filter();
  if (tables) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      tables = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, tables, submessage_arena);
    }
    set_has_tables();
    filter_.tables_ = tables;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.master.SnapshotScheduleFilterPB.tables)
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SnapshotScheduleFilterPB::kTablesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SnapshotScheduleFilterPB::SnapshotScheduleFilterPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleFilterPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.SnapshotScheduleFilterPB)
}
SnapshotScheduleFilterPB::SnapshotScheduleFilterPB(const SnapshotScheduleFilterPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_filter();
  switch (from.filter_case()) {
    case kTables: {
      mutable_tables()->::yb::master::TableIdentifiersPB::MergeFrom(from.tables());
      break;
    }
    case FILTER_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.SnapshotScheduleFilterPB)
}

void SnapshotScheduleFilterPB::SharedCtor() {
  _cached_size_ = 0;
  clear_has_filter();
}

SnapshotScheduleFilterPB::~SnapshotScheduleFilterPB() {
  // @@protoc_insertion_point(destructor:yb.master.SnapshotScheduleFilterPB)
  SharedDtor();
}

void SnapshotScheduleFilterPB::SharedDtor() {
  if (has_filter()) {
    clear_filter();
  }
}

void SnapshotScheduleFilterPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SnapshotScheduleFilterPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SnapshotScheduleFilterPB& SnapshotScheduleFilterPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleFilterPB();
  return *internal_default_instance();
}

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

void SnapshotScheduleFilterPB::clear_filter() {
// @@protoc_insertion_point(one_of_clear_start:yb.master.SnapshotScheduleFilterPB)
  switch (filter_case()) {
    case kTables: {
      delete filter_.tables_;
      break;
    }
    case FILTER_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = FILTER_NOT_SET;
}


void SnapshotScheduleFilterPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.SnapshotScheduleFilterPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_filter();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SnapshotScheduleFilterPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.SnapshotScheduleFilterPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual52;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.master.TableIdentifiersPB tables = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_tables()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.SnapshotScheduleFilterPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.SnapshotScheduleFilterPB)
  return false;
#undef DO_
}

void SnapshotScheduleFilterPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.SnapshotScheduleFilterPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // optional .yb.master.TableIdentifiersPB tables = 1;
  if (has_tables()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *filter_.tables_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.SnapshotScheduleFilterPB)
}

::google::protobuf::uint8* SnapshotScheduleFilterPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.SnapshotScheduleFilterPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // optional .yb.master.TableIdentifiersPB tables = 1;
  if (has_tables()) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *filter_.tables_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.SnapshotScheduleFilterPB)
  return target;
}

size_t SnapshotScheduleFilterPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.SnapshotScheduleFilterPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  switch (filter_case()) {
    // optional .yb.master.TableIdentifiersPB tables = 1;
    case kTables: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *filter_.tables_);
      break;
    }
    case FILTER_NOT_SET: {
      break;
    }
  }
  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 SnapshotScheduleFilterPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.SnapshotScheduleFilterPB)
  GOOGLE_DCHECK_NE(&from, this);
  const SnapshotScheduleFilterPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SnapshotScheduleFilterPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.SnapshotScheduleFilterPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.SnapshotScheduleFilterPB)
    MergeFrom(*source);
  }
}

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

  switch (from.filter_case()) {
    case kTables: {
      mutable_tables()->::yb::master::TableIdentifiersPB::MergeFrom(from.tables());
      break;
    }
    case FILTER_NOT_SET: {
      break;
    }
  }
}

void SnapshotScheduleFilterPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.SnapshotScheduleFilterPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SnapshotScheduleFilterPB::CopyFrom(const SnapshotScheduleFilterPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.SnapshotScheduleFilterPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata SnapshotScheduleFilterPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SnapshotScheduleOptionsPB::InitAsDefaultInstance() {
  ::yb::master::_SnapshotScheduleOptionsPB_default_instance_._instance.get_mutable()->filter_ = const_cast< ::yb::master::SnapshotScheduleFilterPB*>(
      ::yb::master::SnapshotScheduleFilterPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SnapshotScheduleOptionsPB::kFilterFieldNumber;
const int SnapshotScheduleOptionsPB::kIntervalSecFieldNumber;
const int SnapshotScheduleOptionsPB::kRetentionDurationSecFieldNumber;
const int SnapshotScheduleOptionsPB::kDeleteTimeFieldNumber;
const int SnapshotScheduleOptionsPB::kRestorationTimesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SnapshotScheduleOptionsPB::SnapshotScheduleOptionsPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleOptionsPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.SnapshotScheduleOptionsPB)
}
SnapshotScheduleOptionsPB::SnapshotScheduleOptionsPB(const SnapshotScheduleOptionsPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      restoration_times_(from.restoration_times_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_filter()) {
    filter_ = new ::yb::master::SnapshotScheduleFilterPB(*from.filter_);
  } else {
    filter_ = NULL;
  }
  ::memcpy(&interval_sec_, &from.interval_sec_,
    static_cast<size_t>(reinterpret_cast<char*>(&delete_time_) -
    reinterpret_cast<char*>(&interval_sec_)) + sizeof(delete_time_));
  // @@protoc_insertion_point(copy_constructor:yb.master.SnapshotScheduleOptionsPB)
}

void SnapshotScheduleOptionsPB::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&filter_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&delete_time_) -
      reinterpret_cast<char*>(&filter_)) + sizeof(delete_time_));
}

SnapshotScheduleOptionsPB::~SnapshotScheduleOptionsPB() {
  // @@protoc_insertion_point(destructor:yb.master.SnapshotScheduleOptionsPB)
  SharedDtor();
}

void SnapshotScheduleOptionsPB::SharedDtor() {
  if (this != internal_default_instance()) delete filter_;
}

void SnapshotScheduleOptionsPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SnapshotScheduleOptionsPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SnapshotScheduleOptionsPB& SnapshotScheduleOptionsPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleOptionsPB();
  return *internal_default_instance();
}

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

void SnapshotScheduleOptionsPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.SnapshotScheduleOptionsPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  restoration_times_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(filter_ != NULL);
    filter_->Clear();
  }
  if (cached_has_bits & 14u) {
    ::memset(&interval_sec_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&delete_time_) -
        reinterpret_cast<char*>(&interval_sec_)) + sizeof(delete_time_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SnapshotScheduleOptionsPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.SnapshotScheduleOptionsPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual52;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.master.SnapshotScheduleFilterPB filter = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_filter()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 interval_sec = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_interval_sec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &interval_sec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 retention_duration_sec = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_retention_duration_sec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &retention_duration_sec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional fixed64 delete_time = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(33u /* 33 & 0xFF */)) {
          set_has_delete_time();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &delete_time_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated fixed64 restoration_times = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(41u /* 41 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 1, 41u, input, this->mutable_restoration_times())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, this->mutable_restoration_times())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.SnapshotScheduleOptionsPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.SnapshotScheduleOptionsPB)
  return false;
#undef DO_
}

void SnapshotScheduleOptionsPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.SnapshotScheduleOptionsPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SnapshotScheduleFilterPB filter = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->filter_, output);
  }

  // optional uint64 interval_sec = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->interval_sec(), output);
  }

  // optional uint64 retention_duration_sec = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->retention_duration_sec(), output);
  }

  // optional fixed64 delete_time = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->delete_time(), output);
  }

  // repeated fixed64 restoration_times = 5;
  for (int i = 0, n = this->restoration_times_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(
      5, this->restoration_times(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.SnapshotScheduleOptionsPB)
}

::google::protobuf::uint8* SnapshotScheduleOptionsPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.SnapshotScheduleOptionsPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SnapshotScheduleFilterPB filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->filter_, deterministic, target);
  }

  // optional uint64 interval_sec = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->interval_sec(), target);
  }

  // optional uint64 retention_duration_sec = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->retention_duration_sec(), target);
  }

  // optional fixed64 delete_time = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->delete_time(), target);
  }

  // repeated fixed64 restoration_times = 5;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFixed64ToArray(5, this->restoration_times_, target);

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.SnapshotScheduleOptionsPB)
  return target;
}

size_t SnapshotScheduleOptionsPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.SnapshotScheduleOptionsPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated fixed64 restoration_times = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->restoration_times_size());
    size_t data_size = 8UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->restoration_times_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 15u) {
    // optional .yb.master.SnapshotScheduleFilterPB filter = 1;
    if (has_filter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->filter_);
    }

    // optional uint64 interval_sec = 2;
    if (has_interval_sec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->interval_sec());
    }

    // optional uint64 retention_duration_sec = 3;
    if (has_retention_duration_sec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->retention_duration_sec());
    }

    // optional fixed64 delete_time = 4;
    if (has_delete_time()) {
      total_size += 1 + 8;
    }

  }
  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 SnapshotScheduleOptionsPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.SnapshotScheduleOptionsPB)
  GOOGLE_DCHECK_NE(&from, this);
  const SnapshotScheduleOptionsPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SnapshotScheduleOptionsPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.SnapshotScheduleOptionsPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.SnapshotScheduleOptionsPB)
    MergeFrom(*source);
  }
}

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

  restoration_times_.MergeFrom(from.restoration_times_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_filter()->::yb::master::SnapshotScheduleFilterPB::MergeFrom(from.filter());
    }
    if (cached_has_bits & 0x00000002u) {
      interval_sec_ = from.interval_sec_;
    }
    if (cached_has_bits & 0x00000004u) {
      retention_duration_sec_ = from.retention_duration_sec_;
    }
    if (cached_has_bits & 0x00000008u) {
      delete_time_ = from.delete_time_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SnapshotScheduleOptionsPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.SnapshotScheduleOptionsPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SnapshotScheduleOptionsPB::CopyFrom(const SnapshotScheduleOptionsPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.SnapshotScheduleOptionsPB)
  if (&from == this) return0;
  Clear();
  MergeFrom(from);
}

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

void SnapshotScheduleOptionsPB::Swap(SnapshotScheduleOptionsPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SnapshotScheduleOptionsPB::InternalSwap(SnapshotScheduleOptionsPB* other) {
  using std::swap;
  restoration_times_.InternalSwap(&other->restoration_times_);
  swap(filter_, other->filter_);
  swap(interval_sec_, other->interval_sec_);
  swap(retention_duration_sec_, other->retention_duration_sec_);
  swap(delete_time_, other->delete_time_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SnapshotScheduleOptionsPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void CreateSnapshotScheduleRequestPB::InitAsDefaultInstance() {
  ::yb::master::_CreateSnapshotScheduleRequestPB_default_instance_._instance.get_mutable()->options_ = const_cast< ::yb::master::SnapshotScheduleOptionsPB*>(
      ::yb::master::SnapshotScheduleOptionsPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CreateSnapshotScheduleRequestPB::kOptionsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CreateSnapshotScheduleRequestPB::CreateSnapshotScheduleRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsCreateSnapshotScheduleRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.CreateSnapshotScheduleRequestPB)
}
CreateSnapshotScheduleRequestPB::CreateSnapshotScheduleRequestPB(const CreateSnapshotScheduleRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_options()) {
    options_ = new ::yb::master::SnapshotScheduleOptionsPB(*from.options_);
  } else {
    options_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.CreateSnapshotScheduleRequestPB)
}

void CreateSnapshotScheduleRequestPB::SharedCtor() {
  _cached_size_ = 0;
  options_ = NULL;
}

CreateSnapshotScheduleRequestPB::~CreateSnapshotScheduleRequestPB() {
  // @@protoc_insertion_point(destructor:yb.master.CreateSnapshotScheduleRequestPB)
  SharedDtor();
}

void CreateSnapshotScheduleRequestPB::SharedDtor() {
  if (this != internal_default_instance()) delete options_;
}

void CreateSnapshotScheduleRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CreateSnapshotScheduleRequestPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const CreateSnapshotScheduleRequestPB& CreateSnapshotScheduleRequestPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsCreateSnapshotScheduleRequestPB();
  return *internal_default_instance();
}

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

void CreateSnapshotScheduleRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.CreateSnapshotScheduleRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(options_ != NULL);
    options_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CreateSnapshotScheduleRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.CreateSnapshotScheduleRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual8;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.master.SnapshotScheduleOptionsPB options = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_options()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.CreateSnapshotScheduleRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.CreateSnapshotScheduleRequestPB)
  return false;
#undef DO_
}

void CreateSnapshotScheduleRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.CreateSnapshotScheduleRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SnapshotScheduleOptionsPB options = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->options_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.CreateSnapshotScheduleRequestPB)
}

::google::protobuf::uint8* CreateSnapshotScheduleRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.CreateSnapshotScheduleRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.SnapshotScheduleOptionsPB options = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->options_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.CreateSnapshotScheduleRequestPB)
  return target;
}

size_t CreateSnapshotScheduleRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.CreateSnapshotScheduleRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .yb.master.SnapshotScheduleOptionsPB options = 1;
  if (has_options()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSize(
        *this->options_);
  }

  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 CreateSnapshotScheduleRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.CreateSnapshotScheduleRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const CreateSnapshotScheduleRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const CreateSnapshotScheduleRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.CreateSnapshotScheduleRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.CreateSnapshotScheduleRequestPB)
    MergeFrom(*source);
  }
}

void CreateSnapshotScheduleRequestPB::MergeFrom(const CreateSnapshotScheduleRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.CreateSnapshotScheduleRequestPB)
  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_options()) {
    mutable_options()->::yb::master::SnapshotScheduleOptionsPB::MergeFrom(from.options());
  }
}

void CreateSnapshotScheduleRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.CreateSnapshotScheduleRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void CreateSnapshotScheduleRequestPB::CopyFrom(const CreateSnapshotScheduleRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.CreateSnapshotScheduleRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata CreateSnapshotScheduleRequestPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void CreateSnapshotScheduleResponsePB::InitAsDefaultInstance() {
  ::yb::master::_CreateSnapshotScheduleResponsePB_default_instance_._instance.get_mutable()->error_ = const_cast< ::yb::master::MasterErrorPB*>(
      ::yb::master::MasterErrorPB::internal_default_instance());
}
void CreateSnapshotScheduleResponsePB::clear_error() {
  if (error_ != NULL) error_->Clear();
  clear_has_error();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CreateSnapshotScheduleResponsePB::kErrorFieldNumber;
const int CreateSnapshotScheduleResponsePB::kSnapshotScheduleIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CreateSnapshotScheduleResponsePB::CreateSnapshotScheduleResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsCreateSnapshotScheduleResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.CreateSnapshotScheduleResponsePB)
}
CreateSnapshotScheduleResponsePB::CreateSnapshotScheduleResponsePB(const CreateSnapshotScheduleResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  snapshot_schedule_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_schedule_id()) {
    snapshot_schedule_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_schedule_id_);
  }
  if (from.has_error()) {
    error_ = new ::yb::master::MasterErrorPB(*from.error_);
  } else {
    error_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.CreateSnapshotScheduleResponsePB)
}

void CreateSnapshotScheduleResponsePB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_schedule_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  error_ = NULL;
}

CreateSnapshotScheduleResponsePB::~CreateSnapshotScheduleResponsePB() {
  // @@protoc_insertion_point(destructor:yb.master.CreateSnapshotScheduleResponsePB)
  SharedDtor();
}

void CreateSnapshotScheduleResponsePB::SharedDtor() {
  snapshot_schedule_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete error_;
}

void CreateSnapshotScheduleResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CreateSnapshotScheduleResponsePB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const CreateSnapshotScheduleResponsePB& CreateSnapshotScheduleResponsePB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsCreateSnapshotScheduleResponsePB();
  return *internal_default_instance();
}

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

void CreateSnapshotScheduleResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.CreateSnapshotScheduleResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!snapshot_schedule_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*snapshot_schedule_id_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(error_ != NULL);
      error_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CreateSnapshotScheduleResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.CreateSnapshotScheduleResponsePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual8;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.master.MasterErrorPB error = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.CreateSnapshotScheduleResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.CreateSnapshotScheduleResponsePB)
  return false;
#undef DO_
}

void CreateSnapshotScheduleResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.CreateSnapshotScheduleResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->error_, output);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.CreateSnapshotScheduleResponsePB)
}

::google::protobuf::uint8* CreateSnapshotScheduleResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.CreateSnapshotScheduleResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->error_, deterministic, target);
  }

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

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.CreateSnapshotScheduleResponsePB)
  return target;
}

size_t CreateSnapshotScheduleResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.CreateSnapshotScheduleResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes snapshot_schedule_id = 2;
    if (has_snapshot_schedule_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->snapshot_schedule_id());
    }

    // optional .yb.master.MasterErrorPB error = 1;
    if (has_error()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->error_);
    }

  }
  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 CreateSnapshotScheduleResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.CreateSnapshotScheduleResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const CreateSnapshotScheduleResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const CreateSnapshotScheduleResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.CreateSnapshotScheduleResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.CreateSnapshotScheduleResponsePB)
    MergeFrom(*source);
  }
}

void CreateSnapshotScheduleResponsePB::MergeFrom(const CreateSnapshotScheduleResponsePB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.CreateSnapshotScheduleResponsePB)
  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_snapshot_schedule_id();
      snapshot_schedule_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_schedule_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_error()->::yb::master::MasterErrorPB::MergeFrom(from.error());
    }
  }
}

void CreateSnapshotScheduleResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.CreateSnapshotScheduleResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void CreateSnapshotScheduleResponsePB::CopyFrom(const CreateSnapshotScheduleResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.CreateSnapshotScheduleResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CreateSnapshotScheduleResponsePB::IsInitialized() const {
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata CreateSnapshotScheduleResponsePB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ListSnapshotSchedulesRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ListSnapshotSchedulesRequestPB::kSnapshotScheduleIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ListSnapshotSchedulesRequestPB::ListSnapshotSchedulesRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotSchedulesRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.ListSnapshotSchedulesRequestPB)
}
ListSnapshotSchedulesRequestPB::ListSnapshotSchedulesRequestPB(const ListSnapshotSchedulesRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  snapshot_schedule_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_schedule_id()) {
    snapshot_schedule_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_schedule_id_);
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.ListSnapshotSchedulesRequestPB)
}

void ListSnapshotSchedulesRequestPB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_schedule_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

ListSnapshotSchedulesRequestPB::~ListSnapshotSchedulesRequestPB() {
  // @@protoc_insertion_point(destructor:yb.master.ListSnapshotSchedulesRequestPB)
  SharedDtor();
}

void ListSnapshotSchedulesRequestPB::SharedDtor() {
  snapshot_schedule_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void ListSnapshotSchedulesRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ListSnapshotSchedulesRequestPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ListSnapshotSchedulesRequestPB& ListSnapshotSchedulesRequestPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotSchedulesRequestPB();
  return *internal_default_instance();
}

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

void ListSnapshotSchedulesRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.ListSnapshotSchedulesRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!snapshot_schedule_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*snapshot_schedule_id_.UnsafeRawStringPointer())->clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ListSnapshotSchedulesRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (10!GOOGLE_PREDICT_TRUE10(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.ListSnapshotSchedulesRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual11;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes snapshot_schedule_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_snapshot_schedule_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.ListSnapshotSchedulesRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.ListSnapshotSchedulesRequestPB)
  return false;
#undef DO_
}

void ListSnapshotSchedulesRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.ListSnapshotSchedulesRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.ListSnapshotSchedulesRequestPB)
}

::google::protobuf::uint8* ListSnapshotSchedulesRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.ListSnapshotSchedulesRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.ListSnapshotSchedulesRequestPB)
  return target;
}

size_t ListSnapshotSchedulesRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.ListSnapshotSchedulesRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional bytes snapshot_schedule_id = 1;
  if (has_snapshot_schedule_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->snapshot_schedule_id());
  }

  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 ListSnapshotSchedulesRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.ListSnapshotSchedulesRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const ListSnapshotSchedulesRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ListSnapshotSchedulesRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.ListSnapshotSchedulesRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.ListSnapshotSchedulesRequestPB)
    MergeFrom(*source);
  }
}

void ListSnapshotSchedulesRequestPB::MergeFrom(const ListSnapshotSchedulesRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.ListSnapshotSchedulesRequestPB)
  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_snapshot_schedule_id()) {
    set_has_snapshot_schedule_id();
    snapshot_schedule_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_schedule_id_);
  }
}

void ListSnapshotSchedulesRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.ListSnapshotSchedulesRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ListSnapshotSchedulesRequestPB::CopyFrom(const ListSnapshotSchedulesRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.ListSnapshotSchedulesRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata ListSnapshotSchedulesRequestPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SnapshotScheduleInfoPB::InitAsDefaultInstance() {
  ::yb::master::_SnapshotScheduleInfoPB_default_instance_._instance.get_mutable()->options_ = const_cast< ::yb::master::SnapshotScheduleOptionsPB*>(
      ::yb::master::SnapshotScheduleOptionsPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SnapshotScheduleInfoPB::kIdFieldNumber;
const int SnapshotScheduleInfoPB::kOptionsFieldNumber;
const int SnapshotScheduleInfoPB::kSnapshotsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SnapshotScheduleInfoPB::SnapshotScheduleInfoPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleInfoPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.SnapshotScheduleInfoPB)
}
SnapshotScheduleInfoPB::SnapshotScheduleInfoPB(const SnapshotScheduleInfoPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      snapshots_(from.snapshots_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_id()) {
    id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
  }
  if (from.has_options()) {
    options_ = new ::yb::master::SnapshotScheduleOptionsPB(*from.options_);
  } else {
    options_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.SnapshotScheduleInfoPB)
}

void SnapshotScheduleInfoPB::SharedCtor() {
  _cached_size_ = 0;
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  options_ = NULL;
}

SnapshotScheduleInfoPB::~SnapshotScheduleInfoPB() {
  // @@protoc_insertion_point(destructor:yb.master.SnapshotScheduleInfoPB)
  SharedDtor();
}

void SnapshotScheduleInfoPB::SharedDtor() {
  id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete options_;
}

void SnapshotScheduleInfoPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SnapshotScheduleInfoPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SnapshotScheduleInfoPB& SnapshotScheduleInfoPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsSnapshotScheduleInfoPB();
  return *internal_default_instance();
}

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

void SnapshotScheduleInfoPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.SnapshotScheduleInfoPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  snapshots_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*id_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(options_ != NULL);
      options_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SnapshotScheduleInfoPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.SnapshotScheduleInfoPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual11;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.master.SnapshotScheduleOptionsPB options = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_options()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .yb.master.SnapshotInfoPB snapshots = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_snapshots()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.SnapshotScheduleInfoPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.SnapshotScheduleInfoPB)
  return false;
#undef DO_
}

void SnapshotScheduleInfoPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.SnapshotScheduleInfoPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .yb.master.SnapshotScheduleOptionsPB options = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->options_, output);
  }

  // repeated .yb.master.SnapshotInfoPB snapshots = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->snapshots_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->snapshots(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.SnapshotScheduleInfoPB)
}

::google::protobuf::uint8* SnapshotScheduleInfoPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.SnapshotScheduleInfoPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .yb.master.SnapshotScheduleOptionsPB options = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, *this->options_, deterministic, target);
  }

  // repeated .yb.master.SnapshotInfoPB snapshots = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->snapshots_size()); i < n; i++16) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, this->snapshots(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.SnapshotScheduleInfoPB)
  return target;
}

size_t SnapshotScheduleInfoPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.SnapshotScheduleInfoPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.SnapshotInfoPB snapshots = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->snapshots_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++32) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->snapshots(static_cast<int>(i)));
    }
  }

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

    // optional .yb.master.SnapshotScheduleOptionsPB options = 2;
    if (has_options()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->options_);
    }

  }
  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 SnapshotScheduleInfoPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.SnapshotScheduleInfoPB)
  GOOGLE_DCHECK_NE(&from, this);
  const SnapshotScheduleInfoPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SnapshotScheduleInfoPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.SnapshotScheduleInfoPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.SnapshotScheduleInfoPB)
    MergeFrom(*source);
  }
}

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

  snapshots_.MergeFrom(from.snapshots_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_id();
      id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_options()->::yb::master::SnapshotScheduleOptionsPB::MergeFrom(from.options());
    }
  }
}

void SnapshotScheduleInfoPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.SnapshotScheduleInfoPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SnapshotScheduleInfoPB::CopyFrom(const SnapshotScheduleInfoPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.SnapshotScheduleInfoPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata SnapshotScheduleInfoPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ListSnapshotSchedulesResponsePB::InitAsDefaultInstance() {
  ::yb::master::_ListSnapshotSchedulesResponsePB_default_instance_._instance.get_mutable()->error_ = const_cast< ::yb::master::MasterErrorPB*>(
      ::yb::master::MasterErrorPB::internal_default_instance());
}
void ListSnapshotSchedulesResponsePB::clear_error() {
  if (error_ != NULL) error_->Clear();
  clear_has_error();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ListSnapshotSchedulesResponsePB::kErrorFieldNumber;
const int ListSnapshotSchedulesResponsePB::kSchedulesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ListSnapshotSchedulesResponsePB::ListSnapshotSchedulesResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotSchedulesResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.ListSnapshotSchedulesResponsePB)
}
ListSnapshotSchedulesResponsePB::ListSnapshotSchedulesResponsePB(const ListSnapshotSchedulesResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      schedules_(from.schedules_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_error()) {
    error_ = new ::yb::master::MasterErrorPB(*from.error_);
  } else {
    error_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.ListSnapshotSchedulesResponsePB)
}

void ListSnapshotSchedulesResponsePB::SharedCtor() {
  _cached_size_ = 0;
  error_ = NULL;
}

ListSnapshotSchedulesResponsePB::~ListSnapshotSchedulesResponsePB() {
  // @@protoc_insertion_point(destructor:yb.master.ListSnapshotSchedulesResponsePB)
  SharedDtor();
}

void ListSnapshotSchedulesResponsePB::SharedDtor() {
  if (this != internal_default_instance()) delete error_;
}

void ListSnapshotSchedulesResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ListSnapshotSchedulesResponsePB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ListSnapshotSchedulesResponsePB& ListSnapshotSchedulesResponsePB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsListSnapshotSchedulesResponsePB();
  return *internal_default_instance();
}

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

void ListSnapshotSchedulesResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.ListSnapshotSchedulesResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  schedules_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(error_ != NULL);
    error_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ListSnapshotSchedulesResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure0
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.ListSnapshotSchedulesResponsePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual11;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.master.MasterErrorPB error = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .yb.master.SnapshotScheduleInfoPB schedules = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_schedules()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.ListSnapshotSchedulesResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.ListSnapshotSchedulesResponsePB)
  return false;
#undef DO_
}

void ListSnapshotSchedulesResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.ListSnapshotSchedulesResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->error_, output);
  }

  // repeated .yb.master.SnapshotScheduleInfoPB schedules = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->schedules_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->schedules(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.ListSnapshotSchedulesResponsePB)
}

::google::protobuf::uint8* ListSnapshotSchedulesResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.ListSnapshotSchedulesResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->error_, deterministic, target);
  }

  // repeated .yb.master.SnapshotScheduleInfoPB schedules = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->schedules_size()); i < n; i++11) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, this->schedules(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.ListSnapshotSchedulesResponsePB)
  return target;
}

size_t ListSnapshotSchedulesResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.ListSnapshotSchedulesResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.master.SnapshotScheduleInfoPB schedules = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->schedules_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++22) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->schedules(static_cast<int>(i)));
    }
  }

  // optional .yb.master.MasterErrorPB error = 1;
  if (has_error()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSize(
        *this->error_);
  }

  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 ListSnapshotSchedulesResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.ListSnapshotSchedulesResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const ListSnapshotSchedulesResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ListSnapshotSchedulesResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.ListSnapshotSchedulesResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.ListSnapshotSchedulesResponsePB)
    MergeFrom(*source);
  }
}

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

  schedules_.MergeFrom(from.schedules_);
  if (from.has_error()) {
    mutable_error()->::yb::master::MasterErrorPB::MergeFrom(from.error());
  }
}

void ListSnapshotSchedulesResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.ListSnapshotSchedulesResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ListSnapshotSchedulesResponsePB::CopyFrom(const ListSnapshotSchedulesResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.ListSnapshotSchedulesResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ListSnapshotSchedulesResponsePB::IsInitialized() const {
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata ListSnapshotSchedulesResponsePB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void DeleteSnapshotScheduleRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DeleteSnapshotScheduleRequestPB::kSnapshotScheduleIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DeleteSnapshotScheduleRequestPB::DeleteSnapshotScheduleRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsDeleteSnapshotScheduleRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.DeleteSnapshotScheduleRequestPB)
}
DeleteSnapshotScheduleRequestPB::DeleteSnapshotScheduleRequestPB(const DeleteSnapshotScheduleRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  snapshot_schedule_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_schedule_id()) {
    snapshot_schedule_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_schedule_id_);
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.DeleteSnapshotScheduleRequestPB)
}

void DeleteSnapshotScheduleRequestPB::SharedCtor() {
  _cached_size_ = 0;
  snapshot_schedule_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

DeleteSnapshotScheduleRequestPB::~DeleteSnapshotScheduleRequestPB() {
  // @@protoc_insertion_point(destructor:yb.master.DeleteSnapshotScheduleRequestPB)
  SharedDtor();
}

void DeleteSnapshotScheduleRequestPB::SharedDtor() {
  snapshot_schedule_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void DeleteSnapshotScheduleRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DeleteSnapshotScheduleRequestPB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const DeleteSnapshotScheduleRequestPB& DeleteSnapshotScheduleRequestPB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsDeleteSnapshotScheduleRequestPB();
  return *internal_default_instance();
}

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

void DeleteSnapshotScheduleRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.DeleteSnapshotScheduleRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!snapshot_schedule_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*snapshot_schedule_id_.UnsafeRawStringPointer())->clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DeleteSnapshotScheduleRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.DeleteSnapshotScheduleRequestPB)
  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 snapshot_schedule_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_snapshot_schedule_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.DeleteSnapshotScheduleRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.DeleteSnapshotScheduleRequestPB)
  return false;
#undef DO_
}

void DeleteSnapshotScheduleRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.DeleteSnapshotScheduleRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.DeleteSnapshotScheduleRequestPB)
}

::google::protobuf::uint8* DeleteSnapshotScheduleRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.DeleteSnapshotScheduleRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.DeleteSnapshotScheduleRequestPB)
  return target;
}

size_t DeleteSnapshotScheduleRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.DeleteSnapshotScheduleRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional bytes snapshot_schedule_id = 1;
  if (has_snapshot_schedule_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->snapshot_schedule_id());
  }

  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 DeleteSnapshotScheduleRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.DeleteSnapshotScheduleRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const DeleteSnapshotScheduleRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DeleteSnapshotScheduleRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.DeleteSnapshotScheduleRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.DeleteSnapshotScheduleRequestPB)
    MergeFrom(*source);
  }
}

void DeleteSnapshotScheduleRequestPB::MergeFrom(const DeleteSnapshotScheduleRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.DeleteSnapshotScheduleRequestPB)
  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_snapshot_schedule_id()) {
    set_has_snapshot_schedule_id();
    snapshot_schedule_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_schedule_id_);
  }
}

void DeleteSnapshotScheduleRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.DeleteSnapshotScheduleRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DeleteSnapshotScheduleRequestPB::CopyFrom(const DeleteSnapshotScheduleRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.DeleteSnapshotScheduleRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::google::protobuf::Metadata DeleteSnapshotScheduleRequestPB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void DeleteSnapshotScheduleResponsePB::InitAsDefaultInstance() {
  ::yb::master::_DeleteSnapshotScheduleResponsePB_default_instance_._instance.get_mutable()->error_ = const_cast< ::yb::master::MasterErrorPB*>(
      ::yb::master::MasterErrorPB::internal_default_instance());
}
void DeleteSnapshotScheduleResponsePB::clear_error() {
  if (error_ != NULL) error_->Clear();
  clear_has_error();
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DeleteSnapshotScheduleResponsePB::kErrorFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DeleteSnapshotScheduleResponsePB::DeleteSnapshotScheduleResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsDeleteSnapshotScheduleResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.master.DeleteSnapshotScheduleResponsePB)
}
DeleteSnapshotScheduleResponsePB::DeleteSnapshotScheduleResponsePB(const DeleteSnapshotScheduleResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_error()) {
    error_ = new ::yb::master::MasterErrorPB(*from.error_);
  } else {
    error_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.master.DeleteSnapshotScheduleResponsePB)
}

void DeleteSnapshotScheduleResponsePB::SharedCtor() {
  _cached_size_ = 0;
  error_ = NULL;
}

DeleteSnapshotScheduleResponsePB::~DeleteSnapshotScheduleResponsePB() {
  // @@protoc_insertion_point(destructor:yb.master.DeleteSnapshotScheduleResponsePB)
  SharedDtor();
}

void DeleteSnapshotScheduleResponsePB::SharedDtor() {
  if (this != internal_default_instance()) delete error_;
}

void DeleteSnapshotScheduleResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DeleteSnapshotScheduleResponsePB::descriptor() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const DeleteSnapshotScheduleResponsePB& DeleteSnapshotScheduleResponsePB::default_instance() {
  ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::InitDefaultsDeleteSnapshotScheduleResponsePB();
  return *internal_default_instance();
}

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

void DeleteSnapshotScheduleResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.master.DeleteSnapshotScheduleResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(error_ != NULL);
    error_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DeleteSnapshotScheduleResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.master.DeleteSnapshotScheduleResponsePB)
  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 .yb.master.MasterErrorPB error = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.master.DeleteSnapshotScheduleResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.master.DeleteSnapshotScheduleResponsePB)
  return false;
#undef DO_
}

void DeleteSnapshotScheduleResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.master.DeleteSnapshotScheduleResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->error_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.master.DeleteSnapshotScheduleResponsePB)
}

::google::protobuf::uint8* DeleteSnapshotScheduleResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.master.DeleteSnapshotScheduleResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.master.MasterErrorPB error = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->error_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.master.DeleteSnapshotScheduleResponsePB)
  return target;
}

size_t DeleteSnapshotScheduleResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.master.DeleteSnapshotScheduleResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .yb.master.MasterErrorPB error = 1;
  if (has_error()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSize(
        *this->error_);
  }

  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 DeleteSnapshotScheduleResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.master.DeleteSnapshotScheduleResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const DeleteSnapshotScheduleResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DeleteSnapshotScheduleResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.master.DeleteSnapshotScheduleResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.master.DeleteSnapshotScheduleResponsePB)
    MergeFrom(*source);
  }
}

void DeleteSnapshotScheduleResponsePB::MergeFrom(const DeleteSnapshotScheduleResponsePB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.master.DeleteSnapshotScheduleResponsePB)
  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_error()) {
    mutable_error()->::yb::master::MasterErrorPB::MergeFrom(from.error());
  }
}

void DeleteSnapshotScheduleResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.master.DeleteSnapshotScheduleResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DeleteSnapshotScheduleResponsePB::CopyFrom(const DeleteSnapshotScheduleResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.master.DeleteSnapshotScheduleResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DeleteSnapshotScheduleResponsePB::IsInitialized() const {
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata DeleteSnapshotScheduleResponsePB::GetMetadata() const {
  protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fmaster_2fmaster_5fbackup_2eproto::file_level_metadata[kIndexInFileMessages];
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace master
}  // namespace yb

// @@protoc_insertion_point(global_scope)

YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

Coverage Report

Created: 2022-03-22 16:43