zhuyujia-webhopper/collector/adg-linux/gen/components/drive/drive.pb.cc

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

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

#include <algorithm>

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

namespace drive {
class PlatformFileInfoProtoDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<PlatformFileInfoProto> {
} _PlatformFileInfoProto_default_instance_;
class PropertyDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Property> {
} _Property_default_instance_;
class CapabilitiesInfoDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CapabilitiesInfo> {
} _CapabilitiesInfo_default_instance_;
class FileSpecificInfoDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FileSpecificInfo> {
} _FileSpecificInfo_default_instance_;
class TeamDriveRootSpecificInfoDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<TeamDriveRootSpecificInfo> {
} _TeamDriveRootSpecificInfo_default_instance_;
class DirectorySpecificInfoDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<DirectorySpecificInfo> {
} _DirectorySpecificInfo_default_instance_;
class ResourceEntryDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ResourceEntry> {
} _ResourceEntry_default_instance_;
class ResourceMetadataHeaderDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ResourceMetadataHeader> {
} _ResourceMetadataHeader_default_instance_;
class FileCacheEntryDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FileCacheEntry> {
} _FileCacheEntry_default_instance_;

namespace protobuf_drive_2eproto {

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

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


void TableStruct::Shutdown() {
  _PlatformFileInfoProto_default_instance_.Shutdown();
  _Property_default_instance_.Shutdown();
  _CapabilitiesInfo_default_instance_.Shutdown();
  _FileSpecificInfo_default_instance_.Shutdown();
  _TeamDriveRootSpecificInfo_default_instance_.Shutdown();
  _DirectorySpecificInfo_default_instance_.Shutdown();
  _ResourceEntry_default_instance_.Shutdown();
  _ResourceMetadataHeader_default_instance_.Shutdown();
  _FileCacheEntry_default_instance_.Shutdown();
}

void TableStruct::InitDefaultsImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::internal::InitProtobufDefaults();
  _PlatformFileInfoProto_default_instance_.DefaultConstruct();
  _Property_default_instance_.DefaultConstruct();
  _CapabilitiesInfo_default_instance_.DefaultConstruct();
  _FileSpecificInfo_default_instance_.DefaultConstruct();
  _TeamDriveRootSpecificInfo_default_instance_.DefaultConstruct();
  _DirectorySpecificInfo_default_instance_.DefaultConstruct();
  _ResourceEntry_default_instance_.DefaultConstruct();
  _ResourceMetadataHeader_default_instance_.DefaultConstruct();
  _FileCacheEntry_default_instance_.DefaultConstruct();
  _FileSpecificInfo_default_instance_.get_mutable()->cache_state_ = const_cast< ::drive::FileCacheEntry*>(
      ::drive::FileCacheEntry::internal_default_instance());
  _ResourceEntry_default_instance_.get_mutable()->file_info_ = const_cast< ::drive::PlatformFileInfoProto*>(
      ::drive::PlatformFileInfoProto::internal_default_instance());
  _ResourceEntry_default_instance_.get_mutable()->capabilities_info_ = const_cast< ::drive::CapabilitiesInfo*>(
      ::drive::CapabilitiesInfo::internal_default_instance());
  _ResourceEntry_default_instance_.get_mutable()->file_specific_info_ = const_cast< ::drive::FileSpecificInfo*>(
      ::drive::FileSpecificInfo::internal_default_instance());
  _ResourceEntry_default_instance_.get_mutable()->directory_specific_info_ = const_cast< ::drive::DirectorySpecificInfo*>(
      ::drive::DirectorySpecificInfo::internal_default_instance());
  _ResourceEntry_default_instance_.get_mutable()->team_drive_root_specific_info_ = const_cast< ::drive::TeamDriveRootSpecificInfo*>(
      ::drive::TeamDriveRootSpecificInfo::internal_default_instance());
}

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

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

}  // namespace protobuf_drive_2eproto

bool Property_Visibility_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const Property_Visibility Property::PRIVATE;
const Property_Visibility Property::PUBLIC;
const Property_Visibility Property::Visibility_MIN;
const Property_Visibility Property::Visibility_MAX;
const int Property::Visibility_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool ResourceEntry_EditState_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const ResourceEntry_EditState ResourceEntry::CLEAN;
const ResourceEntry_EditState ResourceEntry::DIRTY;
const ResourceEntry_EditState ResourceEntry::SYNCING;
const ResourceEntry_EditState ResourceEntry::EditState_MIN;
const ResourceEntry_EditState ResourceEntry::EditState_MAX;
const int ResourceEntry::EditState_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PlatformFileInfoProto::kSizeFieldNumber;
const int PlatformFileInfoProto::kIsDirectoryFieldNumber;
const int PlatformFileInfoProto::kIsSymbolicLinkFieldNumber;
const int PlatformFileInfoProto::kLastModifiedFieldNumber;
const int PlatformFileInfoProto::kLastAccessedFieldNumber;
const int PlatformFileInfoProto::kCreationTimeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PlatformFileInfoProto::PlatformFileInfoProto()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_drive_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:drive.PlatformFileInfoProto)
}
PlatformFileInfoProto::PlatformFileInfoProto(const PlatformFileInfoProto& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&size_, &from.size_,
    static_cast<size_t>(reinterpret_cast<char*>(&is_symbolic_link_) -
    reinterpret_cast<char*>(&size_)) + sizeof(is_symbolic_link_));
  // @@protoc_insertion_point(copy_constructor:drive.PlatformFileInfoProto)
}

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

PlatformFileInfoProto::~PlatformFileInfoProto() {
  // @@protoc_insertion_point(destructor:drive.PlatformFileInfoProto)
  SharedDtor();
}

void PlatformFileInfoProto::SharedDtor() {
}

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

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

void PlatformFileInfoProto::Clear() {
// @@protoc_insertion_point(message_clear_start:drive.PlatformFileInfoProto)
  if (_has_bits_[0 / 32] & 63u) {
    ::memset(&size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&is_symbolic_link_) -
        reinterpret_cast<char*>(&size_)) + sizeof(is_symbolic_link_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PlatformFileInfoProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:drive.PlatformFileInfoProto)
  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 int64 size = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_directory = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_is_directory();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_directory_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_symbolic_link = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_is_symbolic_link();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_symbolic_link_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 last_modified = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_last_modified();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &last_modified_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 last_accessed = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_last_accessed();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &last_accessed_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 creation_time = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_creation_time();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &creation_time_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

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

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

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

  // optional int64 last_modified = 4;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->last_modified(), output);
  }

  // optional int64 last_accessed = 5;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->last_accessed(), output);
  }

  // optional int64 creation_time = 6;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->creation_time(), output);
  }

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

size_t PlatformFileInfoProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:drive.PlatformFileInfoProto)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 63u) {
    // optional int64 size = 1;
    if (has_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->size());
    }

    // optional int64 last_modified = 4;
    if (has_last_modified()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->last_modified());
    }

    // optional int64 last_accessed = 5;
    if (has_last_accessed()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->last_accessed());
    }

    // optional int64 creation_time = 6;
    if (has_creation_time()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->creation_time());
    }

    // optional bool is_directory = 2;
    if (has_is_directory()) {
      total_size += 1 + 1;
    }

    // optional bool is_symbolic_link = 3;
    if (has_is_symbolic_link()) {
      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 PlatformFileInfoProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlatformFileInfoProto*>(&from));
}

void PlatformFileInfoProto::MergeFrom(const PlatformFileInfoProto& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:drive.PlatformFileInfoProto)
  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 & 63u) {
    if (cached_has_bits & 0x00000001u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000002u) {
      last_modified_ = from.last_modified_;
    }
    if (cached_has_bits & 0x00000004u) {
      last_accessed_ = from.last_accessed_;
    }
    if (cached_has_bits & 0x00000008u) {
      creation_time_ = from.creation_time_;
    }
    if (cached_has_bits & 0x00000010u) {
      is_directory_ = from.is_directory_;
    }
    if (cached_has_bits & 0x00000020u) {
      is_symbolic_link_ = from.is_symbolic_link_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void PlatformFileInfoProto::Swap(PlatformFileInfoProto* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PlatformFileInfoProto::InternalSwap(PlatformFileInfoProto* other) {
  std::swap(size_, other->size_);
  std::swap(last_modified_, other->last_modified_);
  std::swap(last_accessed_, other->last_accessed_);
  std::swap(creation_time_, other->creation_time_);
  std::swap(is_directory_, other->is_directory_);
  std::swap(is_symbolic_link_, other->is_symbolic_link_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string PlatformFileInfoProto::GetTypeName() const {
  return "drive.PlatformFileInfoProto";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// PlatformFileInfoProto

// optional int64 size = 1;
bool PlatformFileInfoProto::has_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void PlatformFileInfoProto::set_has_size() {
  _has_bits_[0] |= 0x00000001u;
}
void PlatformFileInfoProto::clear_has_size() {
  _has_bits_[0] &= ~0x00000001u;
}
void PlatformFileInfoProto::clear_size() {
  size_ = GOOGLE_LONGLONG(0);
  clear_has_size();
}
::google::protobuf::int64 PlatformFileInfoProto::size() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.size)
  return size_;
}
void PlatformFileInfoProto::set_size(::google::protobuf::int64 value) {
  set_has_size();
  size_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.size)
}

// optional bool is_directory = 2;
bool PlatformFileInfoProto::has_is_directory() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void PlatformFileInfoProto::set_has_is_directory() {
  _has_bits_[0] |= 0x00000010u;
}
void PlatformFileInfoProto::clear_has_is_directory() {
  _has_bits_[0] &= ~0x00000010u;
}
void PlatformFileInfoProto::clear_is_directory() {
  is_directory_ = false;
  clear_has_is_directory();
}
bool PlatformFileInfoProto::is_directory() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.is_directory)
  return is_directory_;
}
void PlatformFileInfoProto::set_is_directory(bool value) {
  set_has_is_directory();
  is_directory_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.is_directory)
}

// optional bool is_symbolic_link = 3;
bool PlatformFileInfoProto::has_is_symbolic_link() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void PlatformFileInfoProto::set_has_is_symbolic_link() {
  _has_bits_[0] |= 0x00000020u;
}
void PlatformFileInfoProto::clear_has_is_symbolic_link() {
  _has_bits_[0] &= ~0x00000020u;
}
void PlatformFileInfoProto::clear_is_symbolic_link() {
  is_symbolic_link_ = false;
  clear_has_is_symbolic_link();
}
bool PlatformFileInfoProto::is_symbolic_link() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.is_symbolic_link)
  return is_symbolic_link_;
}
void PlatformFileInfoProto::set_is_symbolic_link(bool value) {
  set_has_is_symbolic_link();
  is_symbolic_link_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.is_symbolic_link)
}

// optional int64 last_modified = 4;
bool PlatformFileInfoProto::has_last_modified() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void PlatformFileInfoProto::set_has_last_modified() {
  _has_bits_[0] |= 0x00000002u;
}
void PlatformFileInfoProto::clear_has_last_modified() {
  _has_bits_[0] &= ~0x00000002u;
}
void PlatformFileInfoProto::clear_last_modified() {
  last_modified_ = GOOGLE_LONGLONG(0);
  clear_has_last_modified();
}
::google::protobuf::int64 PlatformFileInfoProto::last_modified() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.last_modified)
  return last_modified_;
}
void PlatformFileInfoProto::set_last_modified(::google::protobuf::int64 value) {
  set_has_last_modified();
  last_modified_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.last_modified)
}

// optional int64 last_accessed = 5;
bool PlatformFileInfoProto::has_last_accessed() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void PlatformFileInfoProto::set_has_last_accessed() {
  _has_bits_[0] |= 0x00000004u;
}
void PlatformFileInfoProto::clear_has_last_accessed() {
  _has_bits_[0] &= ~0x00000004u;
}
void PlatformFileInfoProto::clear_last_accessed() {
  last_accessed_ = GOOGLE_LONGLONG(0);
  clear_has_last_accessed();
}
::google::protobuf::int64 PlatformFileInfoProto::last_accessed() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.last_accessed)
  return last_accessed_;
}
void PlatformFileInfoProto::set_last_accessed(::google::protobuf::int64 value) {
  set_has_last_accessed();
  last_accessed_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.last_accessed)
}

// optional int64 creation_time = 6;
bool PlatformFileInfoProto::has_creation_time() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void PlatformFileInfoProto::set_has_creation_time() {
  _has_bits_[0] |= 0x00000008u;
}
void PlatformFileInfoProto::clear_has_creation_time() {
  _has_bits_[0] &= ~0x00000008u;
}
void PlatformFileInfoProto::clear_creation_time() {
  creation_time_ = GOOGLE_LONGLONG(0);
  clear_has_creation_time();
}
::google::protobuf::int64 PlatformFileInfoProto::creation_time() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.creation_time)
  return creation_time_;
}
void PlatformFileInfoProto::set_creation_time(::google::protobuf::int64 value) {
  set_has_creation_time();
  creation_time_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.creation_time)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Property::kKeyFieldNumber;
const int Property::kValueFieldNumber;
const int Property::kVisibilityFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Property::Property()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_drive_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:drive.Property)
}
Property::Property(const Property& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_key()) {
    key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_);
  }
  value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_value()) {
    value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.value_);
  }
  visibility_ = from.visibility_;
  // @@protoc_insertion_point(copy_constructor:drive.Property)
}

void Property::SharedCtor() {
  _cached_size_ = 0;
  key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  visibility_ = 0;
}

Property::~Property() {
  // @@protoc_insertion_point(destructor:drive.Property)
  SharedDtor();
}

void Property::SharedDtor() {
  key_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

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

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

void Property::Clear() {
// @@protoc_insertion_point(message_clear_start:drive.Property)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_key()) {
      GOOGLE_DCHECK(!key_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*key_.UnsafeRawStringPointer())->clear();
    }
    if (has_value()) {
      GOOGLE_DCHECK(!value_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*value_.UnsafeRawStringPointer())->clear();
    }
  }
  visibility_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Property::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:drive.Property)
  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 string key = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_key()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      // optional .drive.Property.Visibility visibility = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::drive::Property_Visibility_IsValid(value)) {
            set_visibility(static_cast< ::drive::Property_Visibility >(value));
          } else {
            unknown_fields_stream.WriteVarint32(24u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

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

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

  // optional .drive.Property.Visibility visibility = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->visibility(), output);
  }

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

size_t Property::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:drive.Property)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional string key = 1;
    if (has_key()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->key());
    }

    // optional string value = 2;
    if (has_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->value());
    }

    // optional .drive.Property.Visibility visibility = 3;
    if (has_visibility()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->visibility());
    }

  }
  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 Property::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Property*>(&from));
}

void Property::MergeFrom(const Property& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:drive.Property)
  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_key();
      key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_value();
      value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.value_);
    }
    if (cached_has_bits & 0x00000004u) {
      visibility_ = from.visibility_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

::std::string Property::GetTypeName() const {
  return "drive.Property";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Property

// optional string key = 1;
bool Property::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Property::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
void Property::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
void Property::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key();
}
const ::std::string& Property::key() const {
  // @@protoc_insertion_point(field_get:drive.Property.key)
  return key_.GetNoArena();
}
void Property::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.Property.key)
}
#if LANG_CXX11
void Property::set_key(::std::string&& value) {
  set_has_key();
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.Property.key)
}
#endif
void Property::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.Property.key)
}
void Property::set_key(const char* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.Property.key)
}
::std::string* Property::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:drive.Property.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Property::release_key() {
  // @@protoc_insertion_point(field_release:drive.Property.key)
  clear_has_key();
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void Property::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:drive.Property.key)
}

// optional string value = 2;
bool Property::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Property::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
void Property::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
void Property::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_value();
}
const ::std::string& Property::value() const {
  // @@protoc_insertion_point(field_get:drive.Property.value)
  return value_.GetNoArena();
}
void Property::set_value(const ::std::string& value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.Property.value)
}
#if LANG_CXX11
void Property::set_value(::std::string&& value) {
  set_has_value();
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.Property.value)
}
#endif
void Property::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.Property.value)
}
void Property::set_value(const char* value, size_t size) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.Property.value)
}
::std::string* Property::mutable_value() {
  set_has_value();
  // @@protoc_insertion_point(field_mutable:drive.Property.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Property::release_value() {
  // @@protoc_insertion_point(field_release:drive.Property.value)
  clear_has_value();
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void Property::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    set_has_value();
  } else {
    clear_has_value();
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:drive.Property.value)
}

// optional .drive.Property.Visibility visibility = 3;
bool Property::has_visibility() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void Property::set_has_visibility() {
  _has_bits_[0] |= 0x00000004u;
}
void Property::clear_has_visibility() {
  _has_bits_[0] &= ~0x00000004u;
}
void Property::clear_visibility() {
  visibility_ = 0;
  clear_has_visibility();
}
::drive::Property_Visibility Property::visibility() const {
  // @@protoc_insertion_point(field_get:drive.Property.visibility)
  return static_cast< ::drive::Property_Visibility >(visibility_);
}
void Property::set_visibility(::drive::Property_Visibility value) {
  assert(::drive::Property_Visibility_IsValid(value));
  set_has_visibility();
  visibility_ = value;
  // @@protoc_insertion_point(field_set:drive.Property.visibility)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CapabilitiesInfo::kCanCopyFieldNumber;
const int CapabilitiesInfo::kCanDeleteFieldNumber;
const int CapabilitiesInfo::kCanRenameFieldNumber;
const int CapabilitiesInfo::kCanAddChildrenFieldNumber;
const int CapabilitiesInfo::kCanShareFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CapabilitiesInfo::CapabilitiesInfo()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_drive_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:drive.CapabilitiesInfo)
}
CapabilitiesInfo::CapabilitiesInfo(const CapabilitiesInfo& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&can_copy_, &from.can_copy_,
    static_cast<size_t>(reinterpret_cast<char*>(&can_share_) -
    reinterpret_cast<char*>(&can_copy_)) + sizeof(can_share_));
  // @@protoc_insertion_point(copy_constructor:drive.CapabilitiesInfo)
}

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

CapabilitiesInfo::~CapabilitiesInfo() {
  // @@protoc_insertion_point(destructor:drive.CapabilitiesInfo)
  SharedDtor();
}

void CapabilitiesInfo::SharedDtor() {
}

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

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

void CapabilitiesInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:drive.CapabilitiesInfo)
  if (_has_bits_[0 / 32] & 31u) {
    ::memset(&can_copy_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&can_share_) -
        reinterpret_cast<char*>(&can_copy_)) + sizeof(can_share_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CapabilitiesInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:drive.CapabilitiesInfo)
  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 bool can_copy = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_can_copy();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &can_copy_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool can_delete = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_can_delete();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &can_delete_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool can_rename = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_can_rename();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &can_rename_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool can_add_children = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_can_add_children();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &can_add_children_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool can_share = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_can_share();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &can_share_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

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

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

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

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

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

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

size_t CapabilitiesInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:drive.CapabilitiesInfo)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 31u) {
    // optional bool can_copy = 1;
    if (has_can_copy()) {
      total_size += 1 + 1;
    }

    // optional bool can_delete = 2;
    if (has_can_delete()) {
      total_size += 1 + 1;
    }

    // optional bool can_rename = 3;
    if (has_can_rename()) {
      total_size += 1 + 1;
    }

    // optional bool can_add_children = 4;
    if (has_can_add_children()) {
      total_size += 1 + 1;
    }

    // optional bool can_share = 5;
    if (has_can_share()) {
      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 CapabilitiesInfo::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CapabilitiesInfo*>(&from));
}

void CapabilitiesInfo::MergeFrom(const CapabilitiesInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:drive.CapabilitiesInfo)
  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 & 31u) {
    if (cached_has_bits & 0x00000001u) {
      can_copy_ = from.can_copy_;
    }
    if (cached_has_bits & 0x00000002u) {
      can_delete_ = from.can_delete_;
    }
    if (cached_has_bits & 0x00000004u) {
      can_rename_ = from.can_rename_;
    }
    if (cached_has_bits & 0x00000008u) {
      can_add_children_ = from.can_add_children_;
    }
    if (cached_has_bits & 0x00000010u) {
      can_share_ = from.can_share_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void CapabilitiesInfo::Swap(CapabilitiesInfo* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CapabilitiesInfo::InternalSwap(CapabilitiesInfo* other) {
  std::swap(can_copy_, other->can_copy_);
  std::swap(can_delete_, other->can_delete_);
  std::swap(can_rename_, other->can_rename_);
  std::swap(can_add_children_, other->can_add_children_);
  std::swap(can_share_, other->can_share_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CapabilitiesInfo::GetTypeName() const {
  return "drive.CapabilitiesInfo";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CapabilitiesInfo

// optional bool can_copy = 1;
bool CapabilitiesInfo::has_can_copy() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CapabilitiesInfo::set_has_can_copy() {
  _has_bits_[0] |= 0x00000001u;
}
void CapabilitiesInfo::clear_has_can_copy() {
  _has_bits_[0] &= ~0x00000001u;
}
void CapabilitiesInfo::clear_can_copy() {
  can_copy_ = false;
  clear_has_can_copy();
}
bool CapabilitiesInfo::can_copy() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_copy)
  return can_copy_;
}
void CapabilitiesInfo::set_can_copy(bool value) {
  set_has_can_copy();
  can_copy_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_copy)
}

// optional bool can_delete = 2;
bool CapabilitiesInfo::has_can_delete() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CapabilitiesInfo::set_has_can_delete() {
  _has_bits_[0] |= 0x00000002u;
}
void CapabilitiesInfo::clear_has_can_delete() {
  _has_bits_[0] &= ~0x00000002u;
}
void CapabilitiesInfo::clear_can_delete() {
  can_delete_ = false;
  clear_has_can_delete();
}
bool CapabilitiesInfo::can_delete() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_delete)
  return can_delete_;
}
void CapabilitiesInfo::set_can_delete(bool value) {
  set_has_can_delete();
  can_delete_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_delete)
}

// optional bool can_rename = 3;
bool CapabilitiesInfo::has_can_rename() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void CapabilitiesInfo::set_has_can_rename() {
  _has_bits_[0] |= 0x00000004u;
}
void CapabilitiesInfo::clear_has_can_rename() {
  _has_bits_[0] &= ~0x00000004u;
}
void CapabilitiesInfo::clear_can_rename() {
  can_rename_ = false;
  clear_has_can_rename();
}
bool CapabilitiesInfo::can_rename() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_rename)
  return can_rename_;
}
void CapabilitiesInfo::set_can_rename(bool value) {
  set_has_can_rename();
  can_rename_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_rename)
}

// optional bool can_add_children = 4;
bool CapabilitiesInfo::has_can_add_children() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void CapabilitiesInfo::set_has_can_add_children() {
  _has_bits_[0] |= 0x00000008u;
}
void CapabilitiesInfo::clear_has_can_add_children() {
  _has_bits_[0] &= ~0x00000008u;
}
void CapabilitiesInfo::clear_can_add_children() {
  can_add_children_ = false;
  clear_has_can_add_children();
}
bool CapabilitiesInfo::can_add_children() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_add_children)
  return can_add_children_;
}
void CapabilitiesInfo::set_can_add_children(bool value) {
  set_has_can_add_children();
  can_add_children_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_add_children)
}

// optional bool can_share = 5;
bool CapabilitiesInfo::has_can_share() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void CapabilitiesInfo::set_has_can_share() {
  _has_bits_[0] |= 0x00000010u;
}
void CapabilitiesInfo::clear_has_can_share() {
  _has_bits_[0] &= ~0x00000010u;
}
void CapabilitiesInfo::clear_can_share() {
  can_share_ = false;
  clear_has_can_share();
}
bool CapabilitiesInfo::can_share() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_share)
  return can_share_;
}
void CapabilitiesInfo::set_can_share(bool value) {
  set_has_can_share();
  can_share_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_share)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FileSpecificInfo::kContentMimeTypeFieldNumber;
const int FileSpecificInfo::kMd5FieldNumber;
const int FileSpecificInfo::kDocumentExtensionFieldNumber;
const int FileSpecificInfo::kIsHostedDocumentFieldNumber;
const int FileSpecificInfo::kImageWidthFieldNumber;
const int FileSpecificInfo::kImageHeightFieldNumber;
const int FileSpecificInfo::kImageRotationFieldNumber;
const int FileSpecificInfo::kCacheStateFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FileSpecificInfo::FileSpecificInfo()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_drive_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:drive.FileSpecificInfo)
}
FileSpecificInfo::FileSpecificInfo(const FileSpecificInfo& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  content_mime_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_content_mime_type()) {
    content_mime_type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.content_mime_type_);
  }
  md5_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_md5()) {
    md5_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.md5_);
  }
  document_extension_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_document_extension()) {
    document_extension_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.document_extension_);
  }
  if (from.has_cache_state()) {
    cache_state_ = new ::drive::FileCacheEntry(*from.cache_state_);
  } else {
    cache_state_ = NULL;
  }
  ::memcpy(&image_width_, &from.image_width_,
    static_cast<size_t>(reinterpret_cast<char*>(&image_rotation_) -
    reinterpret_cast<char*>(&image_width_)) + sizeof(image_rotation_));
  // @@protoc_insertion_point(copy_constructor:drive.FileSpecificInfo)
}

void FileSpecificInfo::SharedCtor() {
  _cached_size_ = 0;
  content_mime_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  md5_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  document_extension_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&cache_state_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&image_rotation_) -
      reinterpret_cast<char*>(&cache_state_)) + sizeof(image_rotation_));
}

FileSpecificInfo::~FileSpecificInfo() {
  // @@protoc_insertion_point(destructor:drive.FileSpecificInfo)
  SharedDtor();
}

void FileSpecificInfo::SharedDtor() {
  content_mime_type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  md5_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  document_extension_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete cache_state_;
  }
}

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

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

void FileSpecificInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:drive.FileSpecificInfo)
  if (_has_bits_[0 / 32] & 15u) {
    if (has_content_mime_type()) {
      GOOGLE_DCHECK(!content_mime_type_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*content_mime_type_.UnsafeRawStringPointer())->clear();
    }
    if (has_md5()) {
      GOOGLE_DCHECK(!md5_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*md5_.UnsafeRawStringPointer())->clear();
    }
    if (has_document_extension()) {
      GOOGLE_DCHECK(!document_extension_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*document_extension_.UnsafeRawStringPointer())->clear();
    }
    if (has_cache_state()) {
      GOOGLE_DCHECK(cache_state_ != NULL);
      cache_state_->::drive::FileCacheEntry::Clear();
    }
  }
  if (_has_bits_[0 / 32] & 240u) {
    ::memset(&image_width_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&image_rotation_) -
        reinterpret_cast<char*>(&image_width_)) + sizeof(image_rotation_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FileSpecificInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:drive.FileSpecificInfo)
  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 string content_mime_type = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_content_mime_type()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string md5 = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_md5()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string document_extension = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_document_extension()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_hosted_document = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_is_hosted_document();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_hosted_document_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 image_width = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u)) {
          set_has_image_width();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &image_width_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 image_height = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u)) {
          set_has_image_height();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &image_height_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 image_rotation = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u)) {
          set_has_image_rotation();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &image_rotation_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .drive.FileCacheEntry cache_state = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(90u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cache_state()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

  cached_has_bits = _has_bits_[0];
  // optional string content_mime_type = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->content_mime_type(), output);
  }

  // optional string md5 = 4;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->md5(), output);
  }

  // optional string document_extension = 5;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->document_extension(), output);
  }

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

  // optional int64 image_width = 8;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(8, this->image_width(), output);
  }

  // optional int64 image_height = 9;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(9, this->image_height(), output);
  }

  // optional int64 image_rotation = 10;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(10, this->image_rotation(), output);
  }

  // optional .drive.FileCacheEntry cache_state = 11;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      11, *this->cache_state_, output);
  }

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

size_t FileSpecificInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:drive.FileSpecificInfo)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 255u) {
    // optional string content_mime_type = 3;
    if (has_content_mime_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->content_mime_type());
    }

    // optional string md5 = 4;
    if (has_md5()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->md5());
    }

    // optional string document_extension = 5;
    if (has_document_extension()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->document_extension());
    }

    // optional .drive.FileCacheEntry cache_state = 11;
    if (has_cache_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->cache_state_);
    }

    // optional int64 image_width = 8;
    if (has_image_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->image_width());
    }

    // optional int64 image_height = 9;
    if (has_image_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->image_height());
    }

    // optional bool is_hosted_document = 6;
    if (has_is_hosted_document()) {
      total_size += 1 + 1;
    }

    // optional int64 image_rotation = 10;
    if (has_image_rotation()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->image_rotation());
    }

  }
  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 FileSpecificInfo::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const FileSpecificInfo*>(&from));
}

void FileSpecificInfo::MergeFrom(const FileSpecificInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:drive.FileSpecificInfo)
  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 & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_content_mime_type();
      content_mime_type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.content_mime_type_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_md5();
      md5_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.md5_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_document_extension();
      document_extension_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.document_extension_);
    }
    if (cached_has_bits & 0x00000008u) {
      mutable_cache_state()->::drive::FileCacheEntry::MergeFrom(from.cache_state());
    }
    if (cached_has_bits & 0x00000010u) {
      image_width_ = from.image_width_;
    }
    if (cached_has_bits & 0x00000020u) {
      image_height_ = from.image_height_;
    }
    if (cached_has_bits & 0x00000040u) {
      is_hosted_document_ = from.is_hosted_document_;
    }
    if (cached_has_bits & 0x00000080u) {
      image_rotation_ = from.image_rotation_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void FileSpecificInfo::Swap(FileSpecificInfo* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FileSpecificInfo::InternalSwap(FileSpecificInfo* other) {
  content_mime_type_.Swap(&other->content_mime_type_);
  md5_.Swap(&other->md5_);
  document_extension_.Swap(&other->document_extension_);
  std::swap(cache_state_, other->cache_state_);
  std::swap(image_width_, other->image_width_);
  std::swap(image_height_, other->image_height_);
  std::swap(is_hosted_document_, other->is_hosted_document_);
  std::swap(image_rotation_, other->image_rotation_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string FileSpecificInfo::GetTypeName() const {
  return "drive.FileSpecificInfo";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// FileSpecificInfo

// optional string content_mime_type = 3;
bool FileSpecificInfo::has_content_mime_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void FileSpecificInfo::set_has_content_mime_type() {
  _has_bits_[0] |= 0x00000001u;
}
void FileSpecificInfo::clear_has_content_mime_type() {
  _has_bits_[0] &= ~0x00000001u;
}
void FileSpecificInfo::clear_content_mime_type() {
  content_mime_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_content_mime_type();
}
const ::std::string& FileSpecificInfo::content_mime_type() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.content_mime_type)
  return content_mime_type_.GetNoArena();
}
void FileSpecificInfo::set_content_mime_type(const ::std::string& value) {
  set_has_content_mime_type();
  content_mime_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.content_mime_type)
}
#if LANG_CXX11
void FileSpecificInfo::set_content_mime_type(::std::string&& value) {
  set_has_content_mime_type();
  content_mime_type_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.FileSpecificInfo.content_mime_type)
}
#endif
void FileSpecificInfo::set_content_mime_type(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_content_mime_type();
  content_mime_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.FileSpecificInfo.content_mime_type)
}
void FileSpecificInfo::set_content_mime_type(const char* value, size_t size) {
  set_has_content_mime_type();
  content_mime_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.FileSpecificInfo.content_mime_type)
}
::std::string* FileSpecificInfo::mutable_content_mime_type() {
  set_has_content_mime_type();
  // @@protoc_insertion_point(field_mutable:drive.FileSpecificInfo.content_mime_type)
  return content_mime_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* FileSpecificInfo::release_content_mime_type() {
  // @@protoc_insertion_point(field_release:drive.FileSpecificInfo.content_mime_type)
  clear_has_content_mime_type();
  return content_mime_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void FileSpecificInfo::set_allocated_content_mime_type(::std::string* content_mime_type) {
  if (content_mime_type != NULL) {
    set_has_content_mime_type();
  } else {
    clear_has_content_mime_type();
  }
  content_mime_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), content_mime_type);
  // @@protoc_insertion_point(field_set_allocated:drive.FileSpecificInfo.content_mime_type)
}

// optional string md5 = 4;
bool FileSpecificInfo::has_md5() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void FileSpecificInfo::set_has_md5() {
  _has_bits_[0] |= 0x00000002u;
}
void FileSpecificInfo::clear_has_md5() {
  _has_bits_[0] &= ~0x00000002u;
}
void FileSpecificInfo::clear_md5() {
  md5_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_md5();
}
const ::std::string& FileSpecificInfo::md5() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.md5)
  return md5_.GetNoArena();
}
void FileSpecificInfo::set_md5(const ::std::string& value) {
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.md5)
}
#if LANG_CXX11
void FileSpecificInfo::set_md5(::std::string&& value) {
  set_has_md5();
  md5_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.FileSpecificInfo.md5)
}
#endif
void FileSpecificInfo::set_md5(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.FileSpecificInfo.md5)
}
void FileSpecificInfo::set_md5(const char* value, size_t size) {
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.FileSpecificInfo.md5)
}
::std::string* FileSpecificInfo::mutable_md5() {
  set_has_md5();
  // @@protoc_insertion_point(field_mutable:drive.FileSpecificInfo.md5)
  return md5_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* FileSpecificInfo::release_md5() {
  // @@protoc_insertion_point(field_release:drive.FileSpecificInfo.md5)
  clear_has_md5();
  return md5_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void FileSpecificInfo::set_allocated_md5(::std::string* md5) {
  if (md5 != NULL) {
    set_has_md5();
  } else {
    clear_has_md5();
  }
  md5_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), md5);
  // @@protoc_insertion_point(field_set_allocated:drive.FileSpecificInfo.md5)
}

// optional string document_extension = 5;
bool FileSpecificInfo::has_document_extension() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void FileSpecificInfo::set_has_document_extension() {
  _has_bits_[0] |= 0x00000004u;
}
void FileSpecificInfo::clear_has_document_extension() {
  _has_bits_[0] &= ~0x00000004u;
}
void FileSpecificInfo::clear_document_extension() {
  document_extension_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_document_extension();
}
const ::std::string& FileSpecificInfo::document_extension() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.document_extension)
  return document_extension_.GetNoArena();
}
void FileSpecificInfo::set_document_extension(const ::std::string& value) {
  set_has_document_extension();
  document_extension_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.document_extension)
}
#if LANG_CXX11
void FileSpecificInfo::set_document_extension(::std::string&& value) {
  set_has_document_extension();
  document_extension_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.FileSpecificInfo.document_extension)
}
#endif
void FileSpecificInfo::set_document_extension(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_document_extension();
  document_extension_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.FileSpecificInfo.document_extension)
}
void FileSpecificInfo::set_document_extension(const char* value, size_t size) {
  set_has_document_extension();
  document_extension_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.FileSpecificInfo.document_extension)
}
::std::string* FileSpecificInfo::mutable_document_extension() {
  set_has_document_extension();
  // @@protoc_insertion_point(field_mutable:drive.FileSpecificInfo.document_extension)
  return document_extension_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* FileSpecificInfo::release_document_extension() {
  // @@protoc_insertion_point(field_release:drive.FileSpecificInfo.document_extension)
  clear_has_document_extension();
  return document_extension_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void FileSpecificInfo::set_allocated_document_extension(::std::string* document_extension) {
  if (document_extension != NULL) {
    set_has_document_extension();
  } else {
    clear_has_document_extension();
  }
  document_extension_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), document_extension);
  // @@protoc_insertion_point(field_set_allocated:drive.FileSpecificInfo.document_extension)
}

// optional bool is_hosted_document = 6;
bool FileSpecificInfo::has_is_hosted_document() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void FileSpecificInfo::set_has_is_hosted_document() {
  _has_bits_[0] |= 0x00000040u;
}
void FileSpecificInfo::clear_has_is_hosted_document() {
  _has_bits_[0] &= ~0x00000040u;
}
void FileSpecificInfo::clear_is_hosted_document() {
  is_hosted_document_ = false;
  clear_has_is_hosted_document();
}
bool FileSpecificInfo::is_hosted_document() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.is_hosted_document)
  return is_hosted_document_;
}
void FileSpecificInfo::set_is_hosted_document(bool value) {
  set_has_is_hosted_document();
  is_hosted_document_ = value;
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.is_hosted_document)
}

// optional int64 image_width = 8;
bool FileSpecificInfo::has_image_width() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void FileSpecificInfo::set_has_image_width() {
  _has_bits_[0] |= 0x00000010u;
}
void FileSpecificInfo::clear_has_image_width() {
  _has_bits_[0] &= ~0x00000010u;
}
void FileSpecificInfo::clear_image_width() {
  image_width_ = GOOGLE_LONGLONG(0);
  clear_has_image_width();
}
::google::protobuf::int64 FileSpecificInfo::image_width() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.image_width)
  return image_width_;
}
void FileSpecificInfo::set_image_width(::google::protobuf::int64 value) {
  set_has_image_width();
  image_width_ = value;
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.image_width)
}

// optional int64 image_height = 9;
bool FileSpecificInfo::has_image_height() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void FileSpecificInfo::set_has_image_height() {
  _has_bits_[0] |= 0x00000020u;
}
void FileSpecificInfo::clear_has_image_height() {
  _has_bits_[0] &= ~0x00000020u;
}
void FileSpecificInfo::clear_image_height() {
  image_height_ = GOOGLE_LONGLONG(0);
  clear_has_image_height();
}
::google::protobuf::int64 FileSpecificInfo::image_height() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.image_height)
  return image_height_;
}
void FileSpecificInfo::set_image_height(::google::protobuf::int64 value) {
  set_has_image_height();
  image_height_ = value;
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.image_height)
}

// optional int64 image_rotation = 10;
bool FileSpecificInfo::has_image_rotation() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void FileSpecificInfo::set_has_image_rotation() {
  _has_bits_[0] |= 0x00000080u;
}
void FileSpecificInfo::clear_has_image_rotation() {
  _has_bits_[0] &= ~0x00000080u;
}
void FileSpecificInfo::clear_image_rotation() {
  image_rotation_ = GOOGLE_LONGLONG(0);
  clear_has_image_rotation();
}
::google::protobuf::int64 FileSpecificInfo::image_rotation() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.image_rotation)
  return image_rotation_;
}
void FileSpecificInfo::set_image_rotation(::google::protobuf::int64 value) {
  set_has_image_rotation();
  image_rotation_ = value;
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.image_rotation)
}

// optional .drive.FileCacheEntry cache_state = 11;
bool FileSpecificInfo::has_cache_state() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void FileSpecificInfo::set_has_cache_state() {
  _has_bits_[0] |= 0x00000008u;
}
void FileSpecificInfo::clear_has_cache_state() {
  _has_bits_[0] &= ~0x00000008u;
}
void FileSpecificInfo::clear_cache_state() {
  if (cache_state_ != NULL) cache_state_->::drive::FileCacheEntry::Clear();
  clear_has_cache_state();
}
const ::drive::FileCacheEntry& FileSpecificInfo::cache_state() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.cache_state)
  return cache_state_ != NULL ? *cache_state_
                         : *::drive::FileCacheEntry::internal_default_instance();
}
::drive::FileCacheEntry* FileSpecificInfo::mutable_cache_state() {
  set_has_cache_state();
  if (cache_state_ == NULL) {
    cache_state_ = new ::drive::FileCacheEntry;
  }
  // @@protoc_insertion_point(field_mutable:drive.FileSpecificInfo.cache_state)
  return cache_state_;
}
::drive::FileCacheEntry* FileSpecificInfo::release_cache_state() {
  // @@protoc_insertion_point(field_release:drive.FileSpecificInfo.cache_state)
  clear_has_cache_state();
  ::drive::FileCacheEntry* temp = cache_state_;
  cache_state_ = NULL;
  return temp;
}
void FileSpecificInfo::set_allocated_cache_state(::drive::FileCacheEntry* cache_state) {
  delete cache_state_;
  cache_state_ = cache_state;
  if (cache_state) {
    set_has_cache_state();
  } else {
    clear_has_cache_state();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.FileSpecificInfo.cache_state)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

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

TeamDriveRootSpecificInfo::TeamDriveRootSpecificInfo()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_drive_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:drive.TeamDriveRootSpecificInfo)
}
TeamDriveRootSpecificInfo::TeamDriveRootSpecificInfo(const TeamDriveRootSpecificInfo& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  start_page_token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_start_page_token()) {
    start_page_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.start_page_token_);
  }
  // @@protoc_insertion_point(copy_constructor:drive.TeamDriveRootSpecificInfo)
}

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

TeamDriveRootSpecificInfo::~TeamDriveRootSpecificInfo() {
  // @@protoc_insertion_point(destructor:drive.TeamDriveRootSpecificInfo)
  SharedDtor();
}

void TeamDriveRootSpecificInfo::SharedDtor() {
  start_page_token_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

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

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

void TeamDriveRootSpecificInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:drive.TeamDriveRootSpecificInfo)
  if (has_start_page_token()) {
    GOOGLE_DCHECK(!start_page_token_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*start_page_token_.UnsafeRawStringPointer())->clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TeamDriveRootSpecificInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:drive.TeamDriveRootSpecificInfo)
  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 string start_page_token = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_start_page_token()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

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

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

size_t TeamDriveRootSpecificInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:drive.TeamDriveRootSpecificInfo)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional string start_page_token = 1;
  if (has_start_page_token()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->start_page_token());
  }

  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 TeamDriveRootSpecificInfo::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const TeamDriveRootSpecificInfo*>(&from));
}

void TeamDriveRootSpecificInfo::MergeFrom(const TeamDriveRootSpecificInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:drive.TeamDriveRootSpecificInfo)
  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_start_page_token()) {
    set_has_start_page_token();
    start_page_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.start_page_token_);
  }
}

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

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

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

::std::string TeamDriveRootSpecificInfo::GetTypeName() const {
  return "drive.TeamDriveRootSpecificInfo";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// TeamDriveRootSpecificInfo

// optional string start_page_token = 1;
bool TeamDriveRootSpecificInfo::has_start_page_token() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void TeamDriveRootSpecificInfo::set_has_start_page_token() {
  _has_bits_[0] |= 0x00000001u;
}
void TeamDriveRootSpecificInfo::clear_has_start_page_token() {
  _has_bits_[0] &= ~0x00000001u;
}
void TeamDriveRootSpecificInfo::clear_start_page_token() {
  start_page_token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_start_page_token();
}
const ::std::string& TeamDriveRootSpecificInfo::start_page_token() const {
  // @@protoc_insertion_point(field_get:drive.TeamDriveRootSpecificInfo.start_page_token)
  return start_page_token_.GetNoArena();
}
void TeamDriveRootSpecificInfo::set_start_page_token(const ::std::string& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.TeamDriveRootSpecificInfo.start_page_token)
}
#if LANG_CXX11
void TeamDriveRootSpecificInfo::set_start_page_token(::std::string&& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.TeamDriveRootSpecificInfo.start_page_token)
}
#endif
void TeamDriveRootSpecificInfo::set_start_page_token(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.TeamDriveRootSpecificInfo.start_page_token)
}
void TeamDriveRootSpecificInfo::set_start_page_token(const char* value, size_t size) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.TeamDriveRootSpecificInfo.start_page_token)
}
::std::string* TeamDriveRootSpecificInfo::mutable_start_page_token() {
  set_has_start_page_token();
  // @@protoc_insertion_point(field_mutable:drive.TeamDriveRootSpecificInfo.start_page_token)
  return start_page_token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* TeamDriveRootSpecificInfo::release_start_page_token() {
  // @@protoc_insertion_point(field_release:drive.TeamDriveRootSpecificInfo.start_page_token)
  clear_has_start_page_token();
  return start_page_token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void TeamDriveRootSpecificInfo::set_allocated_start_page_token(::std::string* start_page_token) {
  if (start_page_token != NULL) {
    set_has_start_page_token();
  } else {
    clear_has_start_page_token();
  }
  start_page_token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_page_token);
  // @@protoc_insertion_point(field_set_allocated:drive.TeamDriveRootSpecificInfo.start_page_token)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DirectorySpecificInfo::kChangestampFieldNumber;
const int DirectorySpecificInfo::kStartPageTokenFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DirectorySpecificInfo::DirectorySpecificInfo()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_drive_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:drive.DirectorySpecificInfo)
}
DirectorySpecificInfo::DirectorySpecificInfo(const DirectorySpecificInfo& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  start_page_token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_start_page_token()) {
    start_page_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.start_page_token_);
  }
  changestamp_ = from.changestamp_;
  // @@protoc_insertion_point(copy_constructor:drive.DirectorySpecificInfo)
}

void DirectorySpecificInfo::SharedCtor() {
  _cached_size_ = 0;
  start_page_token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  changestamp_ = GOOGLE_LONGLONG(0);
}

DirectorySpecificInfo::~DirectorySpecificInfo() {
  // @@protoc_insertion_point(destructor:drive.DirectorySpecificInfo)
  SharedDtor();
}

void DirectorySpecificInfo::SharedDtor() {
  start_page_token_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

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

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

void DirectorySpecificInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:drive.DirectorySpecificInfo)
  if (has_start_page_token()) {
    GOOGLE_DCHECK(!start_page_token_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*start_page_token_.UnsafeRawStringPointer())->clear();
  }
  changestamp_ = GOOGLE_LONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DirectorySpecificInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:drive.DirectorySpecificInfo)
  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 int64 changestamp = 1 [deprecated = true];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_changestamp();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &changestamp_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

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

  cached_has_bits = _has_bits_[0];
  // optional int64 changestamp = 1 [deprecated = true];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->changestamp(), output);
  }

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

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

size_t DirectorySpecificInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:drive.DirectorySpecificInfo)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional string start_page_token = 2;
    if (has_start_page_token()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->start_page_token());
    }

    // optional int64 changestamp = 1 [deprecated = true];
    if (has_changestamp()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->changestamp());
    }

  }
  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 DirectorySpecificInfo::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DirectorySpecificInfo*>(&from));
}

void DirectorySpecificInfo::MergeFrom(const DirectorySpecificInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:drive.DirectorySpecificInfo)
  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_start_page_token();
      start_page_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.start_page_token_);
    }
    if (cached_has_bits & 0x00000002u) {
      changestamp_ = from.changestamp_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

::std::string DirectorySpecificInfo::GetTypeName() const {
  return "drive.DirectorySpecificInfo";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DirectorySpecificInfo

// optional int64 changestamp = 1 [deprecated = true];
bool DirectorySpecificInfo::has_changestamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DirectorySpecificInfo::set_has_changestamp() {
  _has_bits_[0] |= 0x00000002u;
}
void DirectorySpecificInfo::clear_has_changestamp() {
  _has_bits_[0] &= ~0x00000002u;
}
void DirectorySpecificInfo::clear_changestamp() {
  changestamp_ = GOOGLE_LONGLONG(0);
  clear_has_changestamp();
}
::google::protobuf::int64 DirectorySpecificInfo::changestamp() const {
  // @@protoc_insertion_point(field_get:drive.DirectorySpecificInfo.changestamp)
  return changestamp_;
}
void DirectorySpecificInfo::set_changestamp(::google::protobuf::int64 value) {
  set_has_changestamp();
  changestamp_ = value;
  // @@protoc_insertion_point(field_set:drive.DirectorySpecificInfo.changestamp)
}

// optional string start_page_token = 2;
bool DirectorySpecificInfo::has_start_page_token() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DirectorySpecificInfo::set_has_start_page_token() {
  _has_bits_[0] |= 0x00000001u;
}
void DirectorySpecificInfo::clear_has_start_page_token() {
  _has_bits_[0] &= ~0x00000001u;
}
void DirectorySpecificInfo::clear_start_page_token() {
  start_page_token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_start_page_token();
}
const ::std::string& DirectorySpecificInfo::start_page_token() const {
  // @@protoc_insertion_point(field_get:drive.DirectorySpecificInfo.start_page_token)
  return start_page_token_.GetNoArena();
}
void DirectorySpecificInfo::set_start_page_token(const ::std::string& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.DirectorySpecificInfo.start_page_token)
}
#if LANG_CXX11
void DirectorySpecificInfo::set_start_page_token(::std::string&& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.DirectorySpecificInfo.start_page_token)
}
#endif
void DirectorySpecificInfo::set_start_page_token(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.DirectorySpecificInfo.start_page_token)
}
void DirectorySpecificInfo::set_start_page_token(const char* value, size_t size) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.DirectorySpecificInfo.start_page_token)
}
::std::string* DirectorySpecificInfo::mutable_start_page_token() {
  set_has_start_page_token();
  // @@protoc_insertion_point(field_mutable:drive.DirectorySpecificInfo.start_page_token)
  return start_page_token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DirectorySpecificInfo::release_start_page_token() {
  // @@protoc_insertion_point(field_release:drive.DirectorySpecificInfo.start_page_token)
  clear_has_start_page_token();
  return start_page_token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DirectorySpecificInfo::set_allocated_start_page_token(::std::string* start_page_token) {
  if (start_page_token != NULL) {
    set_has_start_page_token();
  } else {
    clear_has_start_page_token();
  }
  start_page_token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_page_token);
  // @@protoc_insertion_point(field_set_allocated:drive.DirectorySpecificInfo.start_page_token)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ResourceEntry::kFileInfoFieldNumber;
const int ResourceEntry::kBaseNameFieldNumber;
const int ResourceEntry::kTitleFieldNumber;
const int ResourceEntry::kResourceIdFieldNumber;
const int ResourceEntry::kLocalIdFieldNumber;
const int ResourceEntry::kParentLocalIdFieldNumber;
const int ResourceEntry::kDeletedFieldNumber;
const int ResourceEntry::kStarredFieldNumber;
const int ResourceEntry::kSharedWithMeFieldNumber;
const int ResourceEntry::kSharedFieldNumber;
const int ResourceEntry::kCapabilitiesInfoFieldNumber;
const int ResourceEntry::kFileSpecificInfoFieldNumber;
const int ResourceEntry::kDirectorySpecificInfoFieldNumber;
const int ResourceEntry::kTeamDriveRootSpecificInfoFieldNumber;
const int ResourceEntry::kMetadataEditStateFieldNumber;
const int ResourceEntry::kModificationDateFieldNumber;
const int ResourceEntry::kNewPropertiesFieldNumber;
const int ResourceEntry::kLastModifiedByMeFieldNumber;
const int ResourceEntry::kAlternateUrlFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ResourceEntry::ResourceEntry()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_drive_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:drive.ResourceEntry)
}
ResourceEntry::ResourceEntry(const ResourceEntry& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      new_properties_(from.new_properties_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  base_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_base_name()) {
    base_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.base_name_);
  }
  title_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_title()) {
    title_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.title_);
  }
  resource_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_resource_id()) {
    resource_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.resource_id_);
  }
  parent_local_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_parent_local_id()) {
    parent_local_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.parent_local_id_);
  }
  local_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_local_id()) {
    local_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.local_id_);
  }
  alternate_url_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_alternate_url()) {
    alternate_url_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.alternate_url_);
  }
  if (from.has_file_info()) {
    file_info_ = new ::drive::PlatformFileInfoProto(*from.file_info_);
  } else {
    file_info_ = NULL;
  }
  if (from.has_file_specific_info()) {
    file_specific_info_ = new ::drive::FileSpecificInfo(*from.file_specific_info_);
  } else {
    file_specific_info_ = NULL;
  }
  if (from.has_directory_specific_info()) {
    directory_specific_info_ = new ::drive::DirectorySpecificInfo(*from.directory_specific_info_);
  } else {
    directory_specific_info_ = NULL;
  }
  if (from.has_team_drive_root_specific_info()) {
    team_drive_root_specific_info_ = new ::drive::TeamDriveRootSpecificInfo(*from.team_drive_root_specific_info_);
  } else {
    team_drive_root_specific_info_ = NULL;
  }
  if (from.has_capabilities_info()) {
    capabilities_info_ = new ::drive::CapabilitiesInfo(*from.capabilities_info_);
  } else {
    capabilities_info_ = NULL;
  }
  ::memcpy(&deleted_, &from.deleted_,
    static_cast<size_t>(reinterpret_cast<char*>(&last_modified_by_me_) -
    reinterpret_cast<char*>(&deleted_)) + sizeof(last_modified_by_me_));
  // @@protoc_insertion_point(copy_constructor:drive.ResourceEntry)
}

void ResourceEntry::SharedCtor() {
  _cached_size_ = 0;
  base_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  title_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  resource_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  parent_local_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  local_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  alternate_url_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&file_info_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&last_modified_by_me_) -
      reinterpret_cast<char*>(&file_info_)) + sizeof(last_modified_by_me_));
}

ResourceEntry::~ResourceEntry() {
  // @@protoc_insertion_point(destructor:drive.ResourceEntry)
  SharedDtor();
}

void ResourceEntry::SharedDtor() {
  base_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  title_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  resource_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  parent_local_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  local_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  alternate_url_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete file_info_;
  }
  if (this != internal_default_instance()) {
    delete file_specific_info_;
  }
  if (this != internal_default_instance()) {
    delete directory_specific_info_;
  }
  if (this != internal_default_instance()) {
    delete team_drive_root_specific_info_;
  }
  if (this != internal_default_instance()) {
    delete capabilities_info_;
  }
}

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

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

void ResourceEntry::Clear() {
// @@protoc_insertion_point(message_clear_start:drive.ResourceEntry)
  new_properties_.Clear();
  if (_has_bits_[0 / 32] & 255u) {
    if (has_base_name()) {
      GOOGLE_DCHECK(!base_name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*base_name_.UnsafeRawStringPointer())->clear();
    }
    if (has_title()) {
      GOOGLE_DCHECK(!title_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*title_.UnsafeRawStringPointer())->clear();
    }
    if (has_resource_id()) {
      GOOGLE_DCHECK(!resource_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*resource_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_parent_local_id()) {
      GOOGLE_DCHECK(!parent_local_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*parent_local_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_local_id()) {
      GOOGLE_DCHECK(!local_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*local_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_alternate_url()) {
      GOOGLE_DCHECK(!alternate_url_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*alternate_url_.UnsafeRawStringPointer())->clear();
    }
    if (has_file_info()) {
      GOOGLE_DCHECK(file_info_ != NULL);
      file_info_->::drive::PlatformFileInfoProto::Clear();
    }
    if (has_file_specific_info()) {
      GOOGLE_DCHECK(file_specific_info_ != NULL);
      file_specific_info_->::drive::FileSpecificInfo::Clear();
    }
  }
  if (_has_bits_[8 / 32] & 1792u) {
    if (has_directory_specific_info()) {
      GOOGLE_DCHECK(directory_specific_info_ != NULL);
      directory_specific_info_->::drive::DirectorySpecificInfo::Clear();
    }
    if (has_team_drive_root_specific_info()) {
      GOOGLE_DCHECK(team_drive_root_specific_info_ != NULL);
      team_drive_root_specific_info_->::drive::TeamDriveRootSpecificInfo::Clear();
    }
    if (has_capabilities_info()) {
      GOOGLE_DCHECK(capabilities_info_ != NULL);
      capabilities_info_->::drive::CapabilitiesInfo::Clear();
    }
  }
  if (_has_bits_[8 / 32] & 63488u) {
    ::memset(&deleted_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&metadata_edit_state_) -
        reinterpret_cast<char*>(&deleted_)) + sizeof(metadata_edit_state_));
  }
  if (_has_bits_[16 / 32] & 196608u) {
    ::memset(&modification_date_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&last_modified_by_me_) -
        reinterpret_cast<char*>(&modification_date_)) + sizeof(last_modified_by_me_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

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

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

      // optional string title = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_title()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string resource_id = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_resource_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string parent_local_id = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_parent_local_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .drive.FileSpecificInfo file_specific_info = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_file_specific_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool deleted = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u)) {
          set_has_deleted();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &deleted_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .drive.DirectorySpecificInfo directory_specific_info = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_directory_specific_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool shared_with_me = 14;
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(112u)) {
          set_has_shared_with_me();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &shared_with_me_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string local_id = 15;
      case 15: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(122u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_local_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .drive.ResourceEntry.EditState metadata_edit_state = 16;
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(128u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::drive::ResourceEntry_EditState_IsValid(value)) {
            set_metadata_edit_state(static_cast< ::drive::ResourceEntry_EditState >(value));
          } else {
            unknown_fields_stream.WriteVarint32(128u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool shared = 17;
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(136u)) {
          set_has_shared();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &shared_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 modification_date = 18;
      case 18: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(144u)) {
          set_has_modification_date();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &modification_date_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .drive.Property new_properties = 19;
      case 19: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(154u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_new_properties()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool starred = 20;
      case 20: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(160u)) {
          set_has_starred();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &starred_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 last_modified_by_me = 21;
      case 21: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(168u)) {
          set_has_last_modified_by_me();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &last_modified_by_me_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string alternate_url = 22;
      case 22: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(178u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_alternate_url()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .drive.TeamDriveRootSpecificInfo team_drive_root_specific_info = 23;
      case 23: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(186u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_team_drive_root_specific_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .drive.CapabilitiesInfo capabilities_info = 24;
      case 24: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(194u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_capabilities_info()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

  cached_has_bits = _has_bits_[0];
  // optional .drive.PlatformFileInfoProto file_info = 1;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, *this->file_info_, output);
  }

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

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

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

  // optional string parent_local_id = 7;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      7, this->parent_local_id(), output);
  }

  // optional .drive.FileSpecificInfo file_specific_info = 9;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      9, *this->file_specific_info_, output);
  }

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

  // optional .drive.DirectorySpecificInfo directory_specific_info = 13;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      13, *this->directory_specific_info_, output);
  }

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

  // optional string local_id = 15;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      15, this->local_id(), output);
  }

  // optional .drive.ResourceEntry.EditState metadata_edit_state = 16;
  if (cached_has_bits & 0x00008000u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      16, this->metadata_edit_state(), output);
  }

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

  // optional int64 modification_date = 18;
  if (cached_has_bits & 0x00010000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(18, this->modification_date(), output);
  }

  // repeated .drive.Property new_properties = 19;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->new_properties_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      19, this->new_properties(static_cast<int>(i)), output);
  }

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

  // optional int64 last_modified_by_me = 21;
  if (cached_has_bits & 0x00020000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(21, this->last_modified_by_me(), output);
  }

  // optional string alternate_url = 22;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      22, this->alternate_url(), output);
  }

  // optional .drive.TeamDriveRootSpecificInfo team_drive_root_specific_info = 23;
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      23, *this->team_drive_root_specific_info_, output);
  }

  // optional .drive.CapabilitiesInfo capabilities_info = 24;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      24, *this->capabilities_info_, output);
  }

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

size_t ResourceEntry::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:drive.ResourceEntry)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // repeated .drive.Property new_properties = 19;
  {
    unsigned int count = static_cast<unsigned int>(this->new_properties_size());
    total_size += 2UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->new_properties(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 255u) {
    // optional string base_name = 2;
    if (has_base_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->base_name());
    }

    // optional string title = 3;
    if (has_title()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->title());
    }

    // optional string resource_id = 4;
    if (has_resource_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->resource_id());
    }

    // optional string parent_local_id = 7;
    if (has_parent_local_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->parent_local_id());
    }

    // optional string local_id = 15;
    if (has_local_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->local_id());
    }

    // optional string alternate_url = 22;
    if (has_alternate_url()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->alternate_url());
    }

    // optional .drive.PlatformFileInfoProto file_info = 1;
    if (has_file_info()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->file_info_);
    }

    // optional .drive.FileSpecificInfo file_specific_info = 9;
    if (has_file_specific_info()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->file_specific_info_);
    }

  }
  if (_has_bits_[8 / 32] & 65280u) {
    // optional .drive.DirectorySpecificInfo directory_specific_info = 13;
    if (has_directory_specific_info()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->directory_specific_info_);
    }

    // optional .drive.TeamDriveRootSpecificInfo team_drive_root_specific_info = 23;
    if (has_team_drive_root_specific_info()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->team_drive_root_specific_info_);
    }

    // optional .drive.CapabilitiesInfo capabilities_info = 24;
    if (has_capabilities_info()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->capabilities_info_);
    }

    // optional bool deleted = 11;
    if (has_deleted()) {
      total_size += 1 + 1;
    }

    // optional bool starred = 20;
    if (has_starred()) {
      total_size += 2 + 1;
    }

    // optional bool shared_with_me = 14;
    if (has_shared_with_me()) {
      total_size += 1 + 1;
    }

    // optional bool shared = 17;
    if (has_shared()) {
      total_size += 2 + 1;
    }

    // optional .drive.ResourceEntry.EditState metadata_edit_state = 16;
    if (has_metadata_edit_state()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->metadata_edit_state());
    }

  }
  if (_has_bits_[16 / 32] & 196608u) {
    // optional int64 modification_date = 18;
    if (has_modification_date()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->modification_date());
    }

    // optional int64 last_modified_by_me = 21;
    if (has_last_modified_by_me()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->last_modified_by_me());
    }

  }
  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 ResourceEntry::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ResourceEntry*>(&from));
}

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

  new_properties_.MergeFrom(from.new_properties_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_base_name();
      base_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.base_name_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_title();
      title_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.title_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_resource_id();
      resource_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.resource_id_);
    }
    if (cached_has_bits & 0x00000008u) {
      set_has_parent_local_id();
      parent_local_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.parent_local_id_);
    }
    if (cached_has_bits & 0x00000010u) {
      set_has_local_id();
      local_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.local_id_);
    }
    if (cached_has_bits & 0x00000020u) {
      set_has_alternate_url();
      alternate_url_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.alternate_url_);
    }
    if (cached_has_bits & 0x00000040u) {
      mutable_file_info()->::drive::PlatformFileInfoProto::MergeFrom(from.file_info());
    }
    if (cached_has_bits & 0x00000080u) {
      mutable_file_specific_info()->::drive::FileSpecificInfo::MergeFrom(from.file_specific_info());
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      mutable_directory_specific_info()->::drive::DirectorySpecificInfo::MergeFrom(from.directory_specific_info());
    }
    if (cached_has_bits & 0x00000200u) {
      mutable_team_drive_root_specific_info()->::drive::TeamDriveRootSpecificInfo::MergeFrom(from.team_drive_root_specific_info());
    }
    if (cached_has_bits & 0x00000400u) {
      mutable_capabilities_info()->::drive::CapabilitiesInfo::MergeFrom(from.capabilities_info());
    }
    if (cached_has_bits & 0x00000800u) {
      deleted_ = from.deleted_;
    }
    if (cached_has_bits & 0x00001000u) {
      starred_ = from.starred_;
    }
    if (cached_has_bits & 0x00002000u) {
      shared_with_me_ = from.shared_with_me_;
    }
    if (cached_has_bits & 0x00004000u) {
      shared_ = from.shared_;
    }
    if (cached_has_bits & 0x00008000u) {
      metadata_edit_state_ = from.metadata_edit_state_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 196608u) {
    if (cached_has_bits & 0x00010000u) {
      modification_date_ = from.modification_date_;
    }
    if (cached_has_bits & 0x00020000u) {
      last_modified_by_me_ = from.last_modified_by_me_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void ResourceEntry::Swap(ResourceEntry* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ResourceEntry::InternalSwap(ResourceEntry* other) {
  new_properties_.InternalSwap(&other->new_properties_);
  base_name_.Swap(&other->base_name_);
  title_.Swap(&other->title_);
  resource_id_.Swap(&other->resource_id_);
  parent_local_id_.Swap(&other->parent_local_id_);
  local_id_.Swap(&other->local_id_);
  alternate_url_.Swap(&other->alternate_url_);
  std::swap(file_info_, other->file_info_);
  std::swap(file_specific_info_, other->file_specific_info_);
  std::swap(directory_specific_info_, other->directory_specific_info_);
  std::swap(team_drive_root_specific_info_, other->team_drive_root_specific_info_);
  std::swap(capabilities_info_, other->capabilities_info_);
  std::swap(deleted_, other->deleted_);
  std::swap(starred_, other->starred_);
  std::swap(shared_with_me_, other->shared_with_me_);
  std::swap(shared_, other->shared_);
  std::swap(metadata_edit_state_, other->metadata_edit_state_);
  std::swap(modification_date_, other->modification_date_);
  std::swap(last_modified_by_me_, other->last_modified_by_me_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ResourceEntry::GetTypeName() const {
  return "drive.ResourceEntry";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ResourceEntry

// optional .drive.PlatformFileInfoProto file_info = 1;
bool ResourceEntry::has_file_info() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void ResourceEntry::set_has_file_info() {
  _has_bits_[0] |= 0x00000040u;
}
void ResourceEntry::clear_has_file_info() {
  _has_bits_[0] &= ~0x00000040u;
}
void ResourceEntry::clear_file_info() {
  if (file_info_ != NULL) file_info_->::drive::PlatformFileInfoProto::Clear();
  clear_has_file_info();
}
const ::drive::PlatformFileInfoProto& ResourceEntry::file_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.file_info)
  return file_info_ != NULL ? *file_info_
                         : *::drive::PlatformFileInfoProto::internal_default_instance();
}
::drive::PlatformFileInfoProto* ResourceEntry::mutable_file_info() {
  set_has_file_info();
  if (file_info_ == NULL) {
    file_info_ = new ::drive::PlatformFileInfoProto;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.file_info)
  return file_info_;
}
::drive::PlatformFileInfoProto* ResourceEntry::release_file_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.file_info)
  clear_has_file_info();
  ::drive::PlatformFileInfoProto* temp = file_info_;
  file_info_ = NULL;
  return temp;
}
void ResourceEntry::set_allocated_file_info(::drive::PlatformFileInfoProto* file_info) {
  delete file_info_;
  file_info_ = file_info;
  if (file_info) {
    set_has_file_info();
  } else {
    clear_has_file_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.file_info)
}

// optional string base_name = 2;
bool ResourceEntry::has_base_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ResourceEntry::set_has_base_name() {
  _has_bits_[0] |= 0x00000001u;
}
void ResourceEntry::clear_has_base_name() {
  _has_bits_[0] &= ~0x00000001u;
}
void ResourceEntry::clear_base_name() {
  base_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_base_name();
}
const ::std::string& ResourceEntry::base_name() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.base_name)
  return base_name_.GetNoArena();
}
void ResourceEntry::set_base_name(const ::std::string& value) {
  set_has_base_name();
  base_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.base_name)
}
#if LANG_CXX11
void ResourceEntry::set_base_name(::std::string&& value) {
  set_has_base_name();
  base_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.base_name)
}
#endif
void ResourceEntry::set_base_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_base_name();
  base_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.base_name)
}
void ResourceEntry::set_base_name(const char* value, size_t size) {
  set_has_base_name();
  base_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.base_name)
}
::std::string* ResourceEntry::mutable_base_name() {
  set_has_base_name();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.base_name)
  return base_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ResourceEntry::release_base_name() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.base_name)
  clear_has_base_name();
  return base_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResourceEntry::set_allocated_base_name(::std::string* base_name) {
  if (base_name != NULL) {
    set_has_base_name();
  } else {
    clear_has_base_name();
  }
  base_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), base_name);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.base_name)
}

// optional string title = 3;
bool ResourceEntry::has_title() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void ResourceEntry::set_has_title() {
  _has_bits_[0] |= 0x00000002u;
}
void ResourceEntry::clear_has_title() {
  _has_bits_[0] &= ~0x00000002u;
}
void ResourceEntry::clear_title() {
  title_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_title();
}
const ::std::string& ResourceEntry::title() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.title)
  return title_.GetNoArena();
}
void ResourceEntry::set_title(const ::std::string& value) {
  set_has_title();
  title_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.title)
}
#if LANG_CXX11
void ResourceEntry::set_title(::std::string&& value) {
  set_has_title();
  title_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.title)
}
#endif
void ResourceEntry::set_title(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_title();
  title_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.title)
}
void ResourceEntry::set_title(const char* value, size_t size) {
  set_has_title();
  title_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.title)
}
::std::string* ResourceEntry::mutable_title() {
  set_has_title();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.title)
  return title_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ResourceEntry::release_title() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.title)
  clear_has_title();
  return title_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResourceEntry::set_allocated_title(::std::string* title) {
  if (title != NULL) {
    set_has_title();
  } else {
    clear_has_title();
  }
  title_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), title);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.title)
}

// optional string resource_id = 4;
bool ResourceEntry::has_resource_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void ResourceEntry::set_has_resource_id() {
  _has_bits_[0] |= 0x00000004u;
}
void ResourceEntry::clear_has_resource_id() {
  _has_bits_[0] &= ~0x00000004u;
}
void ResourceEntry::clear_resource_id() {
  resource_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_resource_id();
}
const ::std::string& ResourceEntry::resource_id() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.resource_id)
  return resource_id_.GetNoArena();
}
void ResourceEntry::set_resource_id(const ::std::string& value) {
  set_has_resource_id();
  resource_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.resource_id)
}
#if LANG_CXX11
void ResourceEntry::set_resource_id(::std::string&& value) {
  set_has_resource_id();
  resource_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.resource_id)
}
#endif
void ResourceEntry::set_resource_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_resource_id();
  resource_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.resource_id)
}
void ResourceEntry::set_resource_id(const char* value, size_t size) {
  set_has_resource_id();
  resource_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.resource_id)
}
::std::string* ResourceEntry::mutable_resource_id() {
  set_has_resource_id();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.resource_id)
  return resource_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ResourceEntry::release_resource_id() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.resource_id)
  clear_has_resource_id();
  return resource_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResourceEntry::set_allocated_resource_id(::std::string* resource_id) {
  if (resource_id != NULL) {
    set_has_resource_id();
  } else {
    clear_has_resource_id();
  }
  resource_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), resource_id);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.resource_id)
}

// optional string local_id = 15;
bool ResourceEntry::has_local_id() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void ResourceEntry::set_has_local_id() {
  _has_bits_[0] |= 0x00000010u;
}
void ResourceEntry::clear_has_local_id() {
  _has_bits_[0] &= ~0x00000010u;
}
void ResourceEntry::clear_local_id() {
  local_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_local_id();
}
const ::std::string& ResourceEntry::local_id() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.local_id)
  return local_id_.GetNoArena();
}
void ResourceEntry::set_local_id(const ::std::string& value) {
  set_has_local_id();
  local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.local_id)
}
#if LANG_CXX11
void ResourceEntry::set_local_id(::std::string&& value) {
  set_has_local_id();
  local_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.local_id)
}
#endif
void ResourceEntry::set_local_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_local_id();
  local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.local_id)
}
void ResourceEntry::set_local_id(const char* value, size_t size) {
  set_has_local_id();
  local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.local_id)
}
::std::string* ResourceEntry::mutable_local_id() {
  set_has_local_id();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.local_id)
  return local_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ResourceEntry::release_local_id() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.local_id)
  clear_has_local_id();
  return local_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResourceEntry::set_allocated_local_id(::std::string* local_id) {
  if (local_id != NULL) {
    set_has_local_id();
  } else {
    clear_has_local_id();
  }
  local_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), local_id);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.local_id)
}

// optional string parent_local_id = 7;
bool ResourceEntry::has_parent_local_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void ResourceEntry::set_has_parent_local_id() {
  _has_bits_[0] |= 0x00000008u;
}
void ResourceEntry::clear_has_parent_local_id() {
  _has_bits_[0] &= ~0x00000008u;
}
void ResourceEntry::clear_parent_local_id() {
  parent_local_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_parent_local_id();
}
const ::std::string& ResourceEntry::parent_local_id() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.parent_local_id)
  return parent_local_id_.GetNoArena();
}
void ResourceEntry::set_parent_local_id(const ::std::string& value) {
  set_has_parent_local_id();
  parent_local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.parent_local_id)
}
#if LANG_CXX11
void ResourceEntry::set_parent_local_id(::std::string&& value) {
  set_has_parent_local_id();
  parent_local_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.parent_local_id)
}
#endif
void ResourceEntry::set_parent_local_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_parent_local_id();
  parent_local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.parent_local_id)
}
void ResourceEntry::set_parent_local_id(const char* value, size_t size) {
  set_has_parent_local_id();
  parent_local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.parent_local_id)
}
::std::string* ResourceEntry::mutable_parent_local_id() {
  set_has_parent_local_id();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.parent_local_id)
  return parent_local_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ResourceEntry::release_parent_local_id() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.parent_local_id)
  clear_has_parent_local_id();
  return parent_local_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResourceEntry::set_allocated_parent_local_id(::std::string* parent_local_id) {
  if (parent_local_id != NULL) {
    set_has_parent_local_id();
  } else {
    clear_has_parent_local_id();
  }
  parent_local_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), parent_local_id);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.parent_local_id)
}

// optional bool deleted = 11;
bool ResourceEntry::has_deleted() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
void ResourceEntry::set_has_deleted() {
  _has_bits_[0] |= 0x00000800u;
}
void ResourceEntry::clear_has_deleted() {
  _has_bits_[0] &= ~0x00000800u;
}
void ResourceEntry::clear_deleted() {
  deleted_ = false;
  clear_has_deleted();
}
bool ResourceEntry::deleted() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.deleted)
  return deleted_;
}
void ResourceEntry::set_deleted(bool value) {
  set_has_deleted();
  deleted_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.deleted)
}

// optional bool starred = 20;
bool ResourceEntry::has_starred() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
void ResourceEntry::set_has_starred() {
  _has_bits_[0] |= 0x00001000u;
}
void ResourceEntry::clear_has_starred() {
  _has_bits_[0] &= ~0x00001000u;
}
void ResourceEntry::clear_starred() {
  starred_ = false;
  clear_has_starred();
}
bool ResourceEntry::starred() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.starred)
  return starred_;
}
void ResourceEntry::set_starred(bool value) {
  set_has_starred();
  starred_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.starred)
}

// optional bool shared_with_me = 14;
bool ResourceEntry::has_shared_with_me() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
void ResourceEntry::set_has_shared_with_me() {
  _has_bits_[0] |= 0x00002000u;
}
void ResourceEntry::clear_has_shared_with_me() {
  _has_bits_[0] &= ~0x00002000u;
}
void ResourceEntry::clear_shared_with_me() {
  shared_with_me_ = false;
  clear_has_shared_with_me();
}
bool ResourceEntry::shared_with_me() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.shared_with_me)
  return shared_with_me_;
}
void ResourceEntry::set_shared_with_me(bool value) {
  set_has_shared_with_me();
  shared_with_me_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.shared_with_me)
}

// optional bool shared = 17;
bool ResourceEntry::has_shared() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
void ResourceEntry::set_has_shared() {
  _has_bits_[0] |= 0x00004000u;
}
void ResourceEntry::clear_has_shared() {
  _has_bits_[0] &= ~0x00004000u;
}
void ResourceEntry::clear_shared() {
  shared_ = false;
  clear_has_shared();
}
bool ResourceEntry::shared() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.shared)
  return shared_;
}
void ResourceEntry::set_shared(bool value) {
  set_has_shared();
  shared_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.shared)
}

// optional .drive.CapabilitiesInfo capabilities_info = 24;
bool ResourceEntry::has_capabilities_info() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
void ResourceEntry::set_has_capabilities_info() {
  _has_bits_[0] |= 0x00000400u;
}
void ResourceEntry::clear_has_capabilities_info() {
  _has_bits_[0] &= ~0x00000400u;
}
void ResourceEntry::clear_capabilities_info() {
  if (capabilities_info_ != NULL) capabilities_info_->::drive::CapabilitiesInfo::Clear();
  clear_has_capabilities_info();
}
const ::drive::CapabilitiesInfo& ResourceEntry::capabilities_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.capabilities_info)
  return capabilities_info_ != NULL ? *capabilities_info_
                         : *::drive::CapabilitiesInfo::internal_default_instance();
}
::drive::CapabilitiesInfo* ResourceEntry::mutable_capabilities_info() {
  set_has_capabilities_info();
  if (capabilities_info_ == NULL) {
    capabilities_info_ = new ::drive::CapabilitiesInfo;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.capabilities_info)
  return capabilities_info_;
}
::drive::CapabilitiesInfo* ResourceEntry::release_capabilities_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.capabilities_info)
  clear_has_capabilities_info();
  ::drive::CapabilitiesInfo* temp = capabilities_info_;
  capabilities_info_ = NULL;
  return temp;
}
void ResourceEntry::set_allocated_capabilities_info(::drive::CapabilitiesInfo* capabilities_info) {
  delete capabilities_info_;
  capabilities_info_ = capabilities_info;
  if (capabilities_info) {
    set_has_capabilities_info();
  } else {
    clear_has_capabilities_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.capabilities_info)
}

// optional .drive.FileSpecificInfo file_specific_info = 9;
bool ResourceEntry::has_file_specific_info() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void ResourceEntry::set_has_file_specific_info() {
  _has_bits_[0] |= 0x00000080u;
}
void ResourceEntry::clear_has_file_specific_info() {
  _has_bits_[0] &= ~0x00000080u;
}
void ResourceEntry::clear_file_specific_info() {
  if (file_specific_info_ != NULL) file_specific_info_->::drive::FileSpecificInfo::Clear();
  clear_has_file_specific_info();
}
const ::drive::FileSpecificInfo& ResourceEntry::file_specific_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.file_specific_info)
  return file_specific_info_ != NULL ? *file_specific_info_
                         : *::drive::FileSpecificInfo::internal_default_instance();
}
::drive::FileSpecificInfo* ResourceEntry::mutable_file_specific_info() {
  set_has_file_specific_info();
  if (file_specific_info_ == NULL) {
    file_specific_info_ = new ::drive::FileSpecificInfo;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.file_specific_info)
  return file_specific_info_;
}
::drive::FileSpecificInfo* ResourceEntry::release_file_specific_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.file_specific_info)
  clear_has_file_specific_info();
  ::drive::FileSpecificInfo* temp = file_specific_info_;
  file_specific_info_ = NULL;
  return temp;
}
void ResourceEntry::set_allocated_file_specific_info(::drive::FileSpecificInfo* file_specific_info) {
  delete file_specific_info_;
  file_specific_info_ = file_specific_info;
  if (file_specific_info) {
    set_has_file_specific_info();
  } else {
    clear_has_file_specific_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.file_specific_info)
}

// optional .drive.DirectorySpecificInfo directory_specific_info = 13;
bool ResourceEntry::has_directory_specific_info() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void ResourceEntry::set_has_directory_specific_info() {
  _has_bits_[0] |= 0x00000100u;
}
void ResourceEntry::clear_has_directory_specific_info() {
  _has_bits_[0] &= ~0x00000100u;
}
void ResourceEntry::clear_directory_specific_info() {
  if (directory_specific_info_ != NULL) directory_specific_info_->::drive::DirectorySpecificInfo::Clear();
  clear_has_directory_specific_info();
}
const ::drive::DirectorySpecificInfo& ResourceEntry::directory_specific_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.directory_specific_info)
  return directory_specific_info_ != NULL ? *directory_specific_info_
                         : *::drive::DirectorySpecificInfo::internal_default_instance();
}
::drive::DirectorySpecificInfo* ResourceEntry::mutable_directory_specific_info() {
  set_has_directory_specific_info();
  if (directory_specific_info_ == NULL) {
    directory_specific_info_ = new ::drive::DirectorySpecificInfo;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.directory_specific_info)
  return directory_specific_info_;
}
::drive::DirectorySpecificInfo* ResourceEntry::release_directory_specific_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.directory_specific_info)
  clear_has_directory_specific_info();
  ::drive::DirectorySpecificInfo* temp = directory_specific_info_;
  directory_specific_info_ = NULL;
  return temp;
}
void ResourceEntry::set_allocated_directory_specific_info(::drive::DirectorySpecificInfo* directory_specific_info) {
  delete directory_specific_info_;
  directory_specific_info_ = directory_specific_info;
  if (directory_specific_info) {
    set_has_directory_specific_info();
  } else {
    clear_has_directory_specific_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.directory_specific_info)
}

// optional .drive.TeamDriveRootSpecificInfo team_drive_root_specific_info = 23;
bool ResourceEntry::has_team_drive_root_specific_info() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
void ResourceEntry::set_has_team_drive_root_specific_info() {
  _has_bits_[0] |= 0x00000200u;
}
void ResourceEntry::clear_has_team_drive_root_specific_info() {
  _has_bits_[0] &= ~0x00000200u;
}
void ResourceEntry::clear_team_drive_root_specific_info() {
  if (team_drive_root_specific_info_ != NULL) team_drive_root_specific_info_->::drive::TeamDriveRootSpecificInfo::Clear();
  clear_has_team_drive_root_specific_info();
}
const ::drive::TeamDriveRootSpecificInfo& ResourceEntry::team_drive_root_specific_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.team_drive_root_specific_info)
  return team_drive_root_specific_info_ != NULL ? *team_drive_root_specific_info_
                         : *::drive::TeamDriveRootSpecificInfo::internal_default_instance();
}
::drive::TeamDriveRootSpecificInfo* ResourceEntry::mutable_team_drive_root_specific_info() {
  set_has_team_drive_root_specific_info();
  if (team_drive_root_specific_info_ == NULL) {
    team_drive_root_specific_info_ = new ::drive::TeamDriveRootSpecificInfo;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.team_drive_root_specific_info)
  return team_drive_root_specific_info_;
}
::drive::TeamDriveRootSpecificInfo* ResourceEntry::release_team_drive_root_specific_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.team_drive_root_specific_info)
  clear_has_team_drive_root_specific_info();
  ::drive::TeamDriveRootSpecificInfo* temp = team_drive_root_specific_info_;
  team_drive_root_specific_info_ = NULL;
  return temp;
}
void ResourceEntry::set_allocated_team_drive_root_specific_info(::drive::TeamDriveRootSpecificInfo* team_drive_root_specific_info) {
  delete team_drive_root_specific_info_;
  team_drive_root_specific_info_ = team_drive_root_specific_info;
  if (team_drive_root_specific_info) {
    set_has_team_drive_root_specific_info();
  } else {
    clear_has_team_drive_root_specific_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.team_drive_root_specific_info)
}

// optional .drive.ResourceEntry.EditState metadata_edit_state = 16;
bool ResourceEntry::has_metadata_edit_state() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
void ResourceEntry::set_has_metadata_edit_state() {
  _has_bits_[0] |= 0x00008000u;
}
void ResourceEntry::clear_has_metadata_edit_state() {
  _has_bits_[0] &= ~0x00008000u;
}
void ResourceEntry::clear_metadata_edit_state() {
  metadata_edit_state_ = 0;
  clear_has_metadata_edit_state();
}
::drive::ResourceEntry_EditState ResourceEntry::metadata_edit_state() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.metadata_edit_state)
  return static_cast< ::drive::ResourceEntry_EditState >(metadata_edit_state_);
}
void ResourceEntry::set_metadata_edit_state(::drive::ResourceEntry_EditState value) {
  assert(::drive::ResourceEntry_EditState_IsValid(value));
  set_has_metadata_edit_state();
  metadata_edit_state_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.metadata_edit_state)
}

// optional int64 modification_date = 18;
bool ResourceEntry::has_modification_date() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
void ResourceEntry::set_has_modification_date() {
  _has_bits_[0] |= 0x00010000u;
}
void ResourceEntry::clear_has_modification_date() {
  _has_bits_[0] &= ~0x00010000u;
}
void ResourceEntry::clear_modification_date() {
  modification_date_ = GOOGLE_LONGLONG(0);
  clear_has_modification_date();
}
::google::protobuf::int64 ResourceEntry::modification_date() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.modification_date)
  return modification_date_;
}
void ResourceEntry::set_modification_date(::google::protobuf::int64 value) {
  set_has_modification_date();
  modification_date_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.modification_date)
}

// repeated .drive.Property new_properties = 19;
int ResourceEntry::new_properties_size() const {
  return new_properties_.size();
}
void ResourceEntry::clear_new_properties() {
  new_properties_.Clear();
}
const ::drive::Property& ResourceEntry::new_properties(int index) const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.new_properties)
  return new_properties_.Get(index);
}
::drive::Property* ResourceEntry::mutable_new_properties(int index) {
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.new_properties)
  return new_properties_.Mutable(index);
}
::drive::Property* ResourceEntry::add_new_properties() {
  // @@protoc_insertion_point(field_add:drive.ResourceEntry.new_properties)
  return new_properties_.Add();
}
::google::protobuf::RepeatedPtrField< ::drive::Property >*
ResourceEntry::mutable_new_properties() {
  // @@protoc_insertion_point(field_mutable_list:drive.ResourceEntry.new_properties)
  return &new_properties_;
}
const ::google::protobuf::RepeatedPtrField< ::drive::Property >&
ResourceEntry::new_properties() const {
  // @@protoc_insertion_point(field_list:drive.ResourceEntry.new_properties)
  return new_properties_;
}

// optional int64 last_modified_by_me = 21;
bool ResourceEntry::has_last_modified_by_me() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
void ResourceEntry::set_has_last_modified_by_me() {
  _has_bits_[0] |= 0x00020000u;
}
void ResourceEntry::clear_has_last_modified_by_me() {
  _has_bits_[0] &= ~0x00020000u;
}
void ResourceEntry::clear_last_modified_by_me() {
  last_modified_by_me_ = GOOGLE_LONGLONG(0);
  clear_has_last_modified_by_me();
}
::google::protobuf::int64 ResourceEntry::last_modified_by_me() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.last_modified_by_me)
  return last_modified_by_me_;
}
void ResourceEntry::set_last_modified_by_me(::google::protobuf::int64 value) {
  set_has_last_modified_by_me();
  last_modified_by_me_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.last_modified_by_me)
}

// optional string alternate_url = 22;
bool ResourceEntry::has_alternate_url() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void ResourceEntry::set_has_alternate_url() {
  _has_bits_[0] |= 0x00000020u;
}
void ResourceEntry::clear_has_alternate_url() {
  _has_bits_[0] &= ~0x00000020u;
}
void ResourceEntry::clear_alternate_url() {
  alternate_url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_alternate_url();
}
const ::std::string& ResourceEntry::alternate_url() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.alternate_url)
  return alternate_url_.GetNoArena();
}
void ResourceEntry::set_alternate_url(const ::std::string& value) {
  set_has_alternate_url();
  alternate_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.alternate_url)
}
#if LANG_CXX11
void ResourceEntry::set_alternate_url(::std::string&& value) {
  set_has_alternate_url();
  alternate_url_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.alternate_url)
}
#endif
void ResourceEntry::set_alternate_url(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_alternate_url();
  alternate_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.alternate_url)
}
void ResourceEntry::set_alternate_url(const char* value, size_t size) {
  set_has_alternate_url();
  alternate_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.alternate_url)
}
::std::string* ResourceEntry::mutable_alternate_url() {
  set_has_alternate_url();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.alternate_url)
  return alternate_url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ResourceEntry::release_alternate_url() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.alternate_url)
  clear_has_alternate_url();
  return alternate_url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResourceEntry::set_allocated_alternate_url(::std::string* alternate_url) {
  if (alternate_url != NULL) {
    set_has_alternate_url();
  } else {
    clear_has_alternate_url();
  }
  alternate_url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), alternate_url);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.alternate_url)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ResourceMetadataHeader::kVersionFieldNumber;
const int ResourceMetadataHeader::kLargestChangestampFieldNumber;
const int ResourceMetadataHeader::kStartPageTokenFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ResourceMetadataHeader::ResourceMetadataHeader()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_drive_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:drive.ResourceMetadataHeader)
}
ResourceMetadataHeader::ResourceMetadataHeader(const ResourceMetadataHeader& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  start_page_token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_start_page_token()) {
    start_page_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.start_page_token_);
  }
  ::memcpy(&largest_changestamp_, &from.largest_changestamp_,
    static_cast<size_t>(reinterpret_cast<char*>(&version_) -
    reinterpret_cast<char*>(&largest_changestamp_)) + sizeof(version_));
  // @@protoc_insertion_point(copy_constructor:drive.ResourceMetadataHeader)
}

void ResourceMetadataHeader::SharedCtor() {
  _cached_size_ = 0;
  start_page_token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&largest_changestamp_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&version_) -
      reinterpret_cast<char*>(&largest_changestamp_)) + sizeof(version_));
}

ResourceMetadataHeader::~ResourceMetadataHeader() {
  // @@protoc_insertion_point(destructor:drive.ResourceMetadataHeader)
  SharedDtor();
}

void ResourceMetadataHeader::SharedDtor() {
  start_page_token_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

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

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

void ResourceMetadataHeader::Clear() {
// @@protoc_insertion_point(message_clear_start:drive.ResourceMetadataHeader)
  if (has_start_page_token()) {
    GOOGLE_DCHECK(!start_page_token_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*start_page_token_.UnsafeRawStringPointer())->clear();
  }
  if (_has_bits_[0 / 32] & 6u) {
    ::memset(&largest_changestamp_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&version_) -
        reinterpret_cast<char*>(&largest_changestamp_)) + sizeof(version_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ResourceMetadataHeader::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:drive.ResourceMetadataHeader)
  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 int32 version = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_version();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &version_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 largest_changestamp = 2 [deprecated = true];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_largest_changestamp();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &largest_changestamp_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string start_page_token = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_start_page_token()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

  cached_has_bits = _has_bits_[0];
  // optional int32 version = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->version(), output);
  }

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

  // optional string start_page_token = 4;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->start_page_token(), output);
  }

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

size_t ResourceMetadataHeader::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:drive.ResourceMetadataHeader)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional string start_page_token = 4;
    if (has_start_page_token()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->start_page_token());
    }

    // optional int64 largest_changestamp = 2 [deprecated = true];
    if (has_largest_changestamp()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->largest_changestamp());
    }

    // optional int32 version = 1;
    if (has_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->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 ResourceMetadataHeader::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ResourceMetadataHeader*>(&from));
}

void ResourceMetadataHeader::MergeFrom(const ResourceMetadataHeader& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:drive.ResourceMetadataHeader)
  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_start_page_token();
      start_page_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.start_page_token_);
    }
    if (cached_has_bits & 0x00000002u) {
      largest_changestamp_ = from.largest_changestamp_;
    }
    if (cached_has_bits & 0x00000004u) {
      version_ = from.version_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

::std::string ResourceMetadataHeader::GetTypeName() const {
  return "drive.ResourceMetadataHeader";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ResourceMetadataHeader

// optional int32 version = 1;
bool ResourceMetadataHeader::has_version() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void ResourceMetadataHeader::set_has_version() {
  _has_bits_[0] |= 0x00000004u;
}
void ResourceMetadataHeader::clear_has_version() {
  _has_bits_[0] &= ~0x00000004u;
}
void ResourceMetadataHeader::clear_version() {
  version_ = 0;
  clear_has_version();
}
::google::protobuf::int32 ResourceMetadataHeader::version() const {
  // @@protoc_insertion_point(field_get:drive.ResourceMetadataHeader.version)
  return version_;
}
void ResourceMetadataHeader::set_version(::google::protobuf::int32 value) {
  set_has_version();
  version_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceMetadataHeader.version)
}

// optional int64 largest_changestamp = 2 [deprecated = true];
bool ResourceMetadataHeader::has_largest_changestamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void ResourceMetadataHeader::set_has_largest_changestamp() {
  _has_bits_[0] |= 0x00000002u;
}
void ResourceMetadataHeader::clear_has_largest_changestamp() {
  _has_bits_[0] &= ~0x00000002u;
}
void ResourceMetadataHeader::clear_largest_changestamp() {
  largest_changestamp_ = GOOGLE_LONGLONG(0);
  clear_has_largest_changestamp();
}
::google::protobuf::int64 ResourceMetadataHeader::largest_changestamp() const {
  // @@protoc_insertion_point(field_get:drive.ResourceMetadataHeader.largest_changestamp)
  return largest_changestamp_;
}
void ResourceMetadataHeader::set_largest_changestamp(::google::protobuf::int64 value) {
  set_has_largest_changestamp();
  largest_changestamp_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceMetadataHeader.largest_changestamp)
}

// optional string start_page_token = 4;
bool ResourceMetadataHeader::has_start_page_token() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ResourceMetadataHeader::set_has_start_page_token() {
  _has_bits_[0] |= 0x00000001u;
}
void ResourceMetadataHeader::clear_has_start_page_token() {
  _has_bits_[0] &= ~0x00000001u;
}
void ResourceMetadataHeader::clear_start_page_token() {
  start_page_token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_start_page_token();
}
const ::std::string& ResourceMetadataHeader::start_page_token() const {
  // @@protoc_insertion_point(field_get:drive.ResourceMetadataHeader.start_page_token)
  return start_page_token_.GetNoArena();
}
void ResourceMetadataHeader::set_start_page_token(const ::std::string& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceMetadataHeader.start_page_token)
}
#if LANG_CXX11
void ResourceMetadataHeader::set_start_page_token(::std::string&& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceMetadataHeader.start_page_token)
}
#endif
void ResourceMetadataHeader::set_start_page_token(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceMetadataHeader.start_page_token)
}
void ResourceMetadataHeader::set_start_page_token(const char* value, size_t size) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceMetadataHeader.start_page_token)
}
::std::string* ResourceMetadataHeader::mutable_start_page_token() {
  set_has_start_page_token();
  // @@protoc_insertion_point(field_mutable:drive.ResourceMetadataHeader.start_page_token)
  return start_page_token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ResourceMetadataHeader::release_start_page_token() {
  // @@protoc_insertion_point(field_release:drive.ResourceMetadataHeader.start_page_token)
  clear_has_start_page_token();
  return start_page_token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResourceMetadataHeader::set_allocated_start_page_token(::std::string* start_page_token) {
  if (start_page_token != NULL) {
    set_has_start_page_token();
  } else {
    clear_has_start_page_token();
  }
  start_page_token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_page_token);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceMetadataHeader.start_page_token)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FileCacheEntry::kMd5FieldNumber;
const int FileCacheEntry::kIsPresentFieldNumber;
const int FileCacheEntry::kIsPinnedFieldNumber;
const int FileCacheEntry::kIsDirtyFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FileCacheEntry::FileCacheEntry()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_drive_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:drive.FileCacheEntry)
}
FileCacheEntry::FileCacheEntry(const FileCacheEntry& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  md5_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_md5()) {
    md5_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.md5_);
  }
  ::memcpy(&is_present_, &from.is_present_,
    static_cast<size_t>(reinterpret_cast<char*>(&is_dirty_) -
    reinterpret_cast<char*>(&is_present_)) + sizeof(is_dirty_));
  // @@protoc_insertion_point(copy_constructor:drive.FileCacheEntry)
}

void FileCacheEntry::SharedCtor() {
  _cached_size_ = 0;
  md5_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&is_present_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&is_dirty_) -
      reinterpret_cast<char*>(&is_present_)) + sizeof(is_dirty_));
}

FileCacheEntry::~FileCacheEntry() {
  // @@protoc_insertion_point(destructor:drive.FileCacheEntry)
  SharedDtor();
}

void FileCacheEntry::SharedDtor() {
  md5_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

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

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

void FileCacheEntry::Clear() {
// @@protoc_insertion_point(message_clear_start:drive.FileCacheEntry)
  if (has_md5()) {
    GOOGLE_DCHECK(!md5_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*md5_.UnsafeRawStringPointer())->clear();
  }
  if (_has_bits_[0 / 32] & 14u) {
    ::memset(&is_present_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&is_dirty_) -
        reinterpret_cast<char*>(&is_present_)) + sizeof(is_dirty_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FileCacheEntry::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:drive.FileCacheEntry)
  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 string md5 = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_md5()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_present = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_is_present();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_present_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_pinned = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_is_pinned();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_pinned_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_dirty = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_is_dirty();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_dirty_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

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

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

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

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

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

size_t FileCacheEntry::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:drive.FileCacheEntry)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 15u) {
    // optional string md5 = 1;
    if (has_md5()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->md5());
    }

    // optional bool is_present = 2;
    if (has_is_present()) {
      total_size += 1 + 1;
    }

    // optional bool is_pinned = 3;
    if (has_is_pinned()) {
      total_size += 1 + 1;
    }

    // optional bool is_dirty = 4;
    if (has_is_dirty()) {
      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 FileCacheEntry::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const FileCacheEntry*>(&from));
}

void FileCacheEntry::MergeFrom(const FileCacheEntry& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:drive.FileCacheEntry)
  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 & 15u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_md5();
      md5_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.md5_);
    }
    if (cached_has_bits & 0x00000002u) {
      is_present_ = from.is_present_;
    }
    if (cached_has_bits & 0x00000004u) {
      is_pinned_ = from.is_pinned_;
    }
    if (cached_has_bits & 0x00000008u) {
      is_dirty_ = from.is_dirty_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

::std::string FileCacheEntry::GetTypeName() const {
  return "drive.FileCacheEntry";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// FileCacheEntry

// optional string md5 = 1;
bool FileCacheEntry::has_md5() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void FileCacheEntry::set_has_md5() {
  _has_bits_[0] |= 0x00000001u;
}
void FileCacheEntry::clear_has_md5() {
  _has_bits_[0] &= ~0x00000001u;
}
void FileCacheEntry::clear_md5() {
  md5_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_md5();
}
const ::std::string& FileCacheEntry::md5() const {
  // @@protoc_insertion_point(field_get:drive.FileCacheEntry.md5)
  return md5_.GetNoArena();
}
void FileCacheEntry::set_md5(const ::std::string& value) {
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.FileCacheEntry.md5)
}
#if LANG_CXX11
void FileCacheEntry::set_md5(::std::string&& value) {
  set_has_md5();
  md5_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.FileCacheEntry.md5)
}
#endif
void FileCacheEntry::set_md5(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.FileCacheEntry.md5)
}
void FileCacheEntry::set_md5(const char* value, size_t size) {
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.FileCacheEntry.md5)
}
::std::string* FileCacheEntry::mutable_md5() {
  set_has_md5();
  // @@protoc_insertion_point(field_mutable:drive.FileCacheEntry.md5)
  return md5_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* FileCacheEntry::release_md5() {
  // @@protoc_insertion_point(field_release:drive.FileCacheEntry.md5)
  clear_has_md5();
  return md5_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void FileCacheEntry::set_allocated_md5(::std::string* md5) {
  if (md5 != NULL) {
    set_has_md5();
  } else {
    clear_has_md5();
  }
  md5_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), md5);
  // @@protoc_insertion_point(field_set_allocated:drive.FileCacheEntry.md5)
}

// optional bool is_present = 2;
bool FileCacheEntry::has_is_present() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void FileCacheEntry::set_has_is_present() {
  _has_bits_[0] |= 0x00000002u;
}
void FileCacheEntry::clear_has_is_present() {
  _has_bits_[0] &= ~0x00000002u;
}
void FileCacheEntry::clear_is_present() {
  is_present_ = false;
  clear_has_is_present();
}
bool FileCacheEntry::is_present() const {
  // @@protoc_insertion_point(field_get:drive.FileCacheEntry.is_present)
  return is_present_;
}
void FileCacheEntry::set_is_present(bool value) {
  set_has_is_present();
  is_present_ = value;
  // @@protoc_insertion_point(field_set:drive.FileCacheEntry.is_present)
}

// optional bool is_pinned = 3;
bool FileCacheEntry::has_is_pinned() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void FileCacheEntry::set_has_is_pinned() {
  _has_bits_[0] |= 0x00000004u;
}
void FileCacheEntry::clear_has_is_pinned() {
  _has_bits_[0] &= ~0x00000004u;
}
void FileCacheEntry::clear_is_pinned() {
  is_pinned_ = false;
  clear_has_is_pinned();
}
bool FileCacheEntry::is_pinned() const {
  // @@protoc_insertion_point(field_get:drive.FileCacheEntry.is_pinned)
  return is_pinned_;
}
void FileCacheEntry::set_is_pinned(bool value) {
  set_has_is_pinned();
  is_pinned_ = value;
  // @@protoc_insertion_point(field_set:drive.FileCacheEntry.is_pinned)
}

// optional bool is_dirty = 4;
bool FileCacheEntry::has_is_dirty() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void FileCacheEntry::set_has_is_dirty() {
  _has_bits_[0] |= 0x00000008u;
}
void FileCacheEntry::clear_has_is_dirty() {
  _has_bits_[0] &= ~0x00000008u;
}
void FileCacheEntry::clear_is_dirty() {
  is_dirty_ = false;
  clear_has_is_dirty();
}
bool FileCacheEntry::is_dirty() const {
  // @@protoc_insertion_point(field_get:drive.FileCacheEntry.is_dirty)
  return is_dirty_;
}
void FileCacheEntry::set_is_dirty(bool value) {
  set_has_is_dirty();
  is_dirty_ = value;
  // @@protoc_insertion_point(field_set:drive.FileCacheEntry.is_dirty)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace drive

// @@protoc_insertion_point(global_scope)