diff options
Diffstat (limited to 'toolkit/components/url-classifier/protobuf')
| -rw-r--r-- | toolkit/components/url-classifier/protobuf/safebrowsing.pb.cc | 7166 | ||||
| -rw-r--r-- | toolkit/components/url-classifier/protobuf/safebrowsing.pb.h | 6283 |
2 files changed, 13449 insertions, 0 deletions
diff --git a/toolkit/components/url-classifier/protobuf/safebrowsing.pb.cc b/toolkit/components/url-classifier/protobuf/safebrowsing.pb.cc new file mode 100644 index 000000000..d3e49251b --- /dev/null +++ b/toolkit/components/url-classifier/protobuf/safebrowsing.pb.cc @@ -0,0 +1,7166 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: safebrowsing.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "safebrowsing.pb.h" + +#include <algorithm> + +#include <google/protobuf/stubs/common.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 mozilla { +namespace safebrowsing { + +void protobuf_ShutdownFile_safebrowsing_2eproto() { + delete ThreatInfo::default_instance_; + delete ThreatMatch::default_instance_; + delete FindThreatMatchesRequest::default_instance_; + delete FindThreatMatchesResponse::default_instance_; + delete FetchThreatListUpdatesRequest::default_instance_; + delete FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance_; + delete FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance_; + delete FetchThreatListUpdatesResponse::default_instance_; + delete FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance_; + delete FindFullHashesRequest::default_instance_; + delete FindFullHashesResponse::default_instance_; + delete ThreatHit::default_instance_; + delete ThreatHit_ThreatSource::default_instance_; + delete ClientInfo::default_instance_; + delete Checksum::default_instance_; + delete ThreatEntry::default_instance_; + delete ThreatEntrySet::default_instance_; + delete RawIndices::default_instance_; + delete RawHashes::default_instance_; + delete RiceDeltaEncoding::default_instance_; + delete ThreatEntryMetadata::default_instance_; + delete ThreatEntryMetadata_MetadataEntry::default_instance_; + delete ThreatListDescriptor::default_instance_; + delete ListThreatListsResponse::default_instance_; + delete Duration::default_instance_; +} + +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER +void protobuf_AddDesc_safebrowsing_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#else +void protobuf_AddDesc_safebrowsing_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#endif + ThreatInfo::default_instance_ = new ThreatInfo(); + ThreatMatch::default_instance_ = new ThreatMatch(); + FindThreatMatchesRequest::default_instance_ = new FindThreatMatchesRequest(); + FindThreatMatchesResponse::default_instance_ = new FindThreatMatchesResponse(); + FetchThreatListUpdatesRequest::default_instance_ = new FetchThreatListUpdatesRequest(); + FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance_ = new FetchThreatListUpdatesRequest_ListUpdateRequest(); + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance_ = new FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(); + FetchThreatListUpdatesResponse::default_instance_ = new FetchThreatListUpdatesResponse(); + FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance_ = new FetchThreatListUpdatesResponse_ListUpdateResponse(); + FindFullHashesRequest::default_instance_ = new FindFullHashesRequest(); + FindFullHashesResponse::default_instance_ = new FindFullHashesResponse(); + ThreatHit::default_instance_ = new ThreatHit(); + ThreatHit_ThreatSource::default_instance_ = new ThreatHit_ThreatSource(); + ClientInfo::default_instance_ = new ClientInfo(); + Checksum::default_instance_ = new Checksum(); + ThreatEntry::default_instance_ = new ThreatEntry(); + ThreatEntrySet::default_instance_ = new ThreatEntrySet(); + RawIndices::default_instance_ = new RawIndices(); + RawHashes::default_instance_ = new RawHashes(); + RiceDeltaEncoding::default_instance_ = new RiceDeltaEncoding(); + ThreatEntryMetadata::default_instance_ = new ThreatEntryMetadata(); + ThreatEntryMetadata_MetadataEntry::default_instance_ = new ThreatEntryMetadata_MetadataEntry(); + ThreatListDescriptor::default_instance_ = new ThreatListDescriptor(); + ListThreatListsResponse::default_instance_ = new ListThreatListsResponse(); + Duration::default_instance_ = new Duration(); + ThreatInfo::default_instance_->InitAsDefaultInstance(); + ThreatMatch::default_instance_->InitAsDefaultInstance(); + FindThreatMatchesRequest::default_instance_->InitAsDefaultInstance(); + FindThreatMatchesResponse::default_instance_->InitAsDefaultInstance(); + FetchThreatListUpdatesRequest::default_instance_->InitAsDefaultInstance(); + FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance_->InitAsDefaultInstance(); + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance_->InitAsDefaultInstance(); + FetchThreatListUpdatesResponse::default_instance_->InitAsDefaultInstance(); + FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance_->InitAsDefaultInstance(); + FindFullHashesRequest::default_instance_->InitAsDefaultInstance(); + FindFullHashesResponse::default_instance_->InitAsDefaultInstance(); + ThreatHit::default_instance_->InitAsDefaultInstance(); + ThreatHit_ThreatSource::default_instance_->InitAsDefaultInstance(); + ClientInfo::default_instance_->InitAsDefaultInstance(); + Checksum::default_instance_->InitAsDefaultInstance(); + ThreatEntry::default_instance_->InitAsDefaultInstance(); + ThreatEntrySet::default_instance_->InitAsDefaultInstance(); + RawIndices::default_instance_->InitAsDefaultInstance(); + RawHashes::default_instance_->InitAsDefaultInstance(); + RiceDeltaEncoding::default_instance_->InitAsDefaultInstance(); + ThreatEntryMetadata::default_instance_->InitAsDefaultInstance(); + ThreatEntryMetadata_MetadataEntry::default_instance_->InitAsDefaultInstance(); + ThreatListDescriptor::default_instance_->InitAsDefaultInstance(); + ListThreatListsResponse::default_instance_->InitAsDefaultInstance(); + Duration::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_safebrowsing_2eproto); +} + +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_safebrowsing_2eproto_once_); +void protobuf_AddDesc_safebrowsing_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_safebrowsing_2eproto_once_, + &protobuf_AddDesc_safebrowsing_2eproto_impl); +} +#else +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_safebrowsing_2eproto { + StaticDescriptorInitializer_safebrowsing_2eproto() { + protobuf_AddDesc_safebrowsing_2eproto(); + } +} static_descriptor_initializer_safebrowsing_2eproto_; +#endif +bool ThreatType_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + return true; + default: + return false; + } +} + +bool PlatformType_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + return true; + default: + return false; + } +} + +bool CompressionType_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +bool ThreatEntryType_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ThreatInfo::kThreatTypesFieldNumber; +const int ThreatInfo::kPlatformTypesFieldNumber; +const int ThreatInfo::kThreatEntryTypesFieldNumber; +const int ThreatInfo::kThreatEntriesFieldNumber; +#endif // !_MSC_VER + +ThreatInfo::ThreatInfo() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatInfo) +} + +void ThreatInfo::InitAsDefaultInstance() { +} + +ThreatInfo::ThreatInfo(const ThreatInfo& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatInfo) +} + +void ThreatInfo::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ThreatInfo::~ThreatInfo() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatInfo) + SharedDtor(); +} + +void ThreatInfo::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void ThreatInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ThreatInfo& ThreatInfo::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ThreatInfo* ThreatInfo::default_instance_ = NULL; + +ThreatInfo* ThreatInfo::New() const { + return new ThreatInfo; +} + +void ThreatInfo::Clear() { + threat_types_.Clear(); + platform_types_.Clear(); + threat_entry_types_.Clear(); + threat_entries_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ThreatInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatInfo) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .mozilla.safebrowsing.ThreatType threat_types = 1; + case 1: { + if (tag == 8) { + parse_threat_types: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatType_IsValid(value)) { + add_threat_types(static_cast< ::mozilla::safebrowsing::ThreatType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else if (tag == 10) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::mozilla::safebrowsing::ThreatType_IsValid, + this->mutable_threat_types()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(8)) goto parse_threat_types; + if (input->ExpectTag(16)) goto parse_platform_types; + break; + } + + // repeated .mozilla.safebrowsing.PlatformType platform_types = 2; + case 2: { + if (tag == 16) { + parse_platform_types: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::PlatformType_IsValid(value)) { + add_platform_types(static_cast< ::mozilla::safebrowsing::PlatformType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else if (tag == 18) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::mozilla::safebrowsing::PlatformType_IsValid, + this->mutable_platform_types()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_platform_types; + if (input->ExpectTag(26)) goto parse_threat_entries; + break; + } + + // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; + case 3: { + if (tag == 26) { + parse_threat_entries: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_threat_entries())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_threat_entries; + if (input->ExpectTag(32)) goto parse_threat_entry_types; + break; + } + + // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; + case 4: { + if (tag == 32) { + parse_threat_entry_types: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) { + add_threat_entry_types(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else if (tag == 34) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::mozilla::safebrowsing::ThreatEntryType_IsValid, + this->mutable_threat_entry_types()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_threat_entry_types; + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ThreatInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatInfo) + return false; +#undef DO_ +} + +void ThreatInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatInfo) + // repeated .mozilla.safebrowsing.ThreatType threat_types = 1; + for (int i = 0; i < this->threat_types_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->threat_types(i), output); + } + + // repeated .mozilla.safebrowsing.PlatformType platform_types = 2; + for (int i = 0; i < this->platform_types_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->platform_types(i), output); + } + + // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; + for (int i = 0; i < this->threat_entries_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->threat_entries(i), output); + } + + // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; + for (int i = 0; i < this->threat_entry_types_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 4, this->threat_entry_types(i), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatInfo) +} + +int ThreatInfo::ByteSize() const { + int total_size = 0; + + // repeated .mozilla.safebrowsing.ThreatType threat_types = 1; + { + int data_size = 0; + for (int i = 0; i < this->threat_types_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->threat_types(i)); + } + total_size += 1 * this->threat_types_size() + data_size; + } + + // repeated .mozilla.safebrowsing.PlatformType platform_types = 2; + { + int data_size = 0; + for (int i = 0; i < this->platform_types_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->platform_types(i)); + } + total_size += 1 * this->platform_types_size() + data_size; + } + + // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; + { + int data_size = 0; + for (int i = 0; i < this->threat_entry_types_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->threat_entry_types(i)); + } + total_size += 1 * this->threat_entry_types_size() + data_size; + } + + // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; + total_size += 1 * this->threat_entries_size(); + for (int i = 0; i < this->threat_entries_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->threat_entries(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThreatInfo::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ThreatInfo*>(&from)); +} + +void ThreatInfo::MergeFrom(const ThreatInfo& from) { + GOOGLE_CHECK_NE(&from, this); + threat_types_.MergeFrom(from.threat_types_); + platform_types_.MergeFrom(from.platform_types_); + threat_entry_types_.MergeFrom(from.threat_entry_types_); + threat_entries_.MergeFrom(from.threat_entries_); + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ThreatInfo::CopyFrom(const ThreatInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatInfo::IsInitialized() const { + + return true; +} + +void ThreatInfo::Swap(ThreatInfo* other) { + if (other != this) { + threat_types_.Swap(&other->threat_types_); + platform_types_.Swap(&other->platform_types_); + threat_entry_types_.Swap(&other->threat_entry_types_); + threat_entries_.Swap(&other->threat_entries_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ThreatInfo::GetTypeName() const { + return "mozilla.safebrowsing.ThreatInfo"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ThreatMatch::kThreatTypeFieldNumber; +const int ThreatMatch::kPlatformTypeFieldNumber; +const int ThreatMatch::kThreatEntryTypeFieldNumber; +const int ThreatMatch::kThreatFieldNumber; +const int ThreatMatch::kThreatEntryMetadataFieldNumber; +const int ThreatMatch::kCacheDurationFieldNumber; +#endif // !_MSC_VER + +ThreatMatch::ThreatMatch() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatMatch) +} + +void ThreatMatch::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + threat_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>( + ::mozilla::safebrowsing::ThreatEntry::internal_default_instance()); +#else + threat_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>(&::mozilla::safebrowsing::ThreatEntry::default_instance()); +#endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + threat_entry_metadata_ = const_cast< ::mozilla::safebrowsing::ThreatEntryMetadata*>( + ::mozilla::safebrowsing::ThreatEntryMetadata::internal_default_instance()); +#else + threat_entry_metadata_ = const_cast< ::mozilla::safebrowsing::ThreatEntryMetadata*>(&::mozilla::safebrowsing::ThreatEntryMetadata::default_instance()); +#endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>( + ::mozilla::safebrowsing::Duration::internal_default_instance()); +#else + cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(&::mozilla::safebrowsing::Duration::default_instance()); +#endif +} + +ThreatMatch::ThreatMatch(const ThreatMatch& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatMatch) +} + +void ThreatMatch::SharedCtor() { + _cached_size_ = 0; + threat_type_ = 0; + platform_type_ = 0; + threat_entry_type_ = 0; + threat_ = NULL; + threat_entry_metadata_ = NULL; + cache_duration_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ThreatMatch::~ThreatMatch() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatMatch) + SharedDtor(); +} + +void ThreatMatch::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete threat_; + delete threat_entry_metadata_; + delete cache_duration_; + } +} + +void ThreatMatch::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ThreatMatch& ThreatMatch::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ThreatMatch* ThreatMatch::default_instance_ = NULL; + +ThreatMatch* ThreatMatch::New() const { + return new ThreatMatch; +} + +void ThreatMatch::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \ + &reinterpret_cast<ThreatMatch*>(16)->f) - \ + reinterpret_cast<char*>(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 63) { + ZR_(threat_type_, platform_type_); + threat_entry_type_ = 0; + if (has_threat()) { + if (threat_ != NULL) threat_->::mozilla::safebrowsing::ThreatEntry::Clear(); + } + if (has_threat_entry_metadata()) { + if (threat_entry_metadata_ != NULL) threat_entry_metadata_->::mozilla::safebrowsing::ThreatEntryMetadata::Clear(); + } + if (has_cache_duration()) { + if (cache_duration_ != NULL) cache_duration_->::mozilla::safebrowsing::Duration::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ThreatMatch::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatMatch) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatType_IsValid(value)) { + set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_platform_type; + break; + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + case 2: { + if (tag == 16) { + parse_platform_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::PlatformType_IsValid(value)) { + set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_threat; + break; + } + + // optional .mozilla.safebrowsing.ThreatEntry threat = 3; + case 3: { + if (tag == 26) { + parse_threat: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_threat())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_threat_entry_metadata; + break; + } + + // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; + case 4: { + if (tag == 34) { + parse_threat_entry_metadata: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_threat_entry_metadata())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_cache_duration; + break; + } + + // optional .mozilla.safebrowsing.Duration cache_duration = 5; + case 5: { + if (tag == 42) { + parse_cache_duration: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_cache_duration())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_threat_entry_type; + break; + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; + case 6: { + if (tag == 48) { + parse_threat_entry_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) { + set_threat_entry_type(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ThreatMatch) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatMatch) + return false; +#undef DO_ +} + +void ThreatMatch::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatMatch) + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->threat_type(), output); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (has_platform_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->platform_type(), output); + } + + // optional .mozilla.safebrowsing.ThreatEntry threat = 3; + if (has_threat()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->threat(), output); + } + + // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; + if (has_threat_entry_metadata()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->threat_entry_metadata(), output); + } + + // optional .mozilla.safebrowsing.Duration cache_duration = 5; + if (has_cache_duration()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 5, this->cache_duration(), output); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; + if (has_threat_entry_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->threat_entry_type(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatMatch) +} + +int ThreatMatch::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (has_platform_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; + if (has_threat_entry_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_entry_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntry threat = 3; + if (has_threat()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->threat()); + } + + // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; + if (has_threat_entry_metadata()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->threat_entry_metadata()); + } + + // optional .mozilla.safebrowsing.Duration cache_duration = 5; + if (has_cache_duration()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->cache_duration()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThreatMatch::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ThreatMatch*>(&from)); +} + +void ThreatMatch::MergeFrom(const ThreatMatch& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_threat_type()) { + set_threat_type(from.threat_type()); + } + if (from.has_platform_type()) { + set_platform_type(from.platform_type()); + } + if (from.has_threat_entry_type()) { + set_threat_entry_type(from.threat_entry_type()); + } + if (from.has_threat()) { + mutable_threat()->::mozilla::safebrowsing::ThreatEntry::MergeFrom(from.threat()); + } + if (from.has_threat_entry_metadata()) { + mutable_threat_entry_metadata()->::mozilla::safebrowsing::ThreatEntryMetadata::MergeFrom(from.threat_entry_metadata()); + } + if (from.has_cache_duration()) { + mutable_cache_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from.cache_duration()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ThreatMatch::CopyFrom(const ThreatMatch& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatMatch::IsInitialized() const { + + return true; +} + +void ThreatMatch::Swap(ThreatMatch* other) { + if (other != this) { + std::swap(threat_type_, other->threat_type_); + std::swap(platform_type_, other->platform_type_); + std::swap(threat_entry_type_, other->threat_entry_type_); + std::swap(threat_, other->threat_); + std::swap(threat_entry_metadata_, other->threat_entry_metadata_); + std::swap(cache_duration_, other->cache_duration_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ThreatMatch::GetTypeName() const { + return "mozilla.safebrowsing.ThreatMatch"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FindThreatMatchesRequest::kClientFieldNumber; +const int FindThreatMatchesRequest::kThreatInfoFieldNumber; +#endif // !_MSC_VER + +FindThreatMatchesRequest::FindThreatMatchesRequest() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindThreatMatchesRequest) +} + +void FindThreatMatchesRequest::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>( + ::mozilla::safebrowsing::ClientInfo::internal_default_instance()); +#else + client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(&::mozilla::safebrowsing::ClientInfo::default_instance()); +#endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>( + ::mozilla::safebrowsing::ThreatInfo::internal_default_instance()); +#else + threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>(&::mozilla::safebrowsing::ThreatInfo::default_instance()); +#endif +} + +FindThreatMatchesRequest::FindThreatMatchesRequest(const FindThreatMatchesRequest& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindThreatMatchesRequest) +} + +void FindThreatMatchesRequest::SharedCtor() { + _cached_size_ = 0; + client_ = NULL; + threat_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FindThreatMatchesRequest::~FindThreatMatchesRequest() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindThreatMatchesRequest) + SharedDtor(); +} + +void FindThreatMatchesRequest::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete client_; + delete threat_info_; + } +} + +void FindThreatMatchesRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FindThreatMatchesRequest& FindThreatMatchesRequest::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +FindThreatMatchesRequest* FindThreatMatchesRequest::default_instance_ = NULL; + +FindThreatMatchesRequest* FindThreatMatchesRequest::New() const { + return new FindThreatMatchesRequest; +} + +void FindThreatMatchesRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_client()) { + if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear(); + } + if (has_threat_info()) { + if (threat_info_ != NULL) threat_info_->::mozilla::safebrowsing::ThreatInfo::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool FindThreatMatchesRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FindThreatMatchesRequest) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_client())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_threat_info; + break; + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; + case 2: { + if (tag == 18) { + parse_threat_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_threat_info())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.FindThreatMatchesRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FindThreatMatchesRequest) + return false; +#undef DO_ +} + +void FindThreatMatchesRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FindThreatMatchesRequest) + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (has_client()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->client(), output); + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; + if (has_threat_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->threat_info(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FindThreatMatchesRequest) +} + +int FindThreatMatchesRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (has_client()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->client()); + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; + if (has_threat_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->threat_info()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FindThreatMatchesRequest::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const FindThreatMatchesRequest*>(&from)); +} + +void FindThreatMatchesRequest::MergeFrom(const FindThreatMatchesRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_client()) { + mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from.client()); + } + if (from.has_threat_info()) { + mutable_threat_info()->::mozilla::safebrowsing::ThreatInfo::MergeFrom(from.threat_info()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void FindThreatMatchesRequest::CopyFrom(const FindThreatMatchesRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FindThreatMatchesRequest::IsInitialized() const { + + return true; +} + +void FindThreatMatchesRequest::Swap(FindThreatMatchesRequest* other) { + if (other != this) { + std::swap(client_, other->client_); + std::swap(threat_info_, other->threat_info_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FindThreatMatchesRequest::GetTypeName() const { + return "mozilla.safebrowsing.FindThreatMatchesRequest"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FindThreatMatchesResponse::kMatchesFieldNumber; +#endif // !_MSC_VER + +FindThreatMatchesResponse::FindThreatMatchesResponse() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindThreatMatchesResponse) +} + +void FindThreatMatchesResponse::InitAsDefaultInstance() { +} + +FindThreatMatchesResponse::FindThreatMatchesResponse(const FindThreatMatchesResponse& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindThreatMatchesResponse) +} + +void FindThreatMatchesResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FindThreatMatchesResponse::~FindThreatMatchesResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindThreatMatchesResponse) + SharedDtor(); +} + +void FindThreatMatchesResponse::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void FindThreatMatchesResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FindThreatMatchesResponse& FindThreatMatchesResponse::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +FindThreatMatchesResponse* FindThreatMatchesResponse::default_instance_ = NULL; + +FindThreatMatchesResponse* FindThreatMatchesResponse::New() const { + return new FindThreatMatchesResponse; +} + +void FindThreatMatchesResponse::Clear() { + matches_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool FindThreatMatchesResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FindThreatMatchesResponse) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + case 1: { + if (tag == 10) { + parse_matches: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_matches())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_matches; + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.FindThreatMatchesResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FindThreatMatchesResponse) + return false; +#undef DO_ +} + +void FindThreatMatchesResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FindThreatMatchesResponse) + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + for (int i = 0; i < this->matches_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->matches(i), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FindThreatMatchesResponse) +} + +int FindThreatMatchesResponse::ByteSize() const { + int total_size = 0; + + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + total_size += 1 * this->matches_size(); + for (int i = 0; i < this->matches_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->matches(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FindThreatMatchesResponse::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const FindThreatMatchesResponse*>(&from)); +} + +void FindThreatMatchesResponse::MergeFrom(const FindThreatMatchesResponse& from) { + GOOGLE_CHECK_NE(&from, this); + matches_.MergeFrom(from.matches_); + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void FindThreatMatchesResponse::CopyFrom(const FindThreatMatchesResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FindThreatMatchesResponse::IsInitialized() const { + + return true; +} + +void FindThreatMatchesResponse::Swap(FindThreatMatchesResponse* other) { + if (other != this) { + matches_.Swap(&other->matches_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FindThreatMatchesResponse::GetTypeName() const { + return "mozilla.safebrowsing.FindThreatMatchesResponse"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::kMaxUpdateEntriesFieldNumber; +const int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::kMaxDatabaseEntriesFieldNumber; +const int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::kRegionFieldNumber; +const int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::kSupportedCompressionsFieldNumber; +#endif // !_MSC_VER + +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::InitAsDefaultInstance() { +} + +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + max_update_entries_ = 0; + max_database_entries_ = 0; + region_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + SharedDtor(); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SharedDtor() { + if (region_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete region_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance_ = NULL; + +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::New() const { + return new FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \ + &reinterpret_cast<FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(16)->f) - \ + reinterpret_cast<char*>(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 7) { + ZR_(max_update_entries_, max_database_entries_); + if (has_region()) { + if (region_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + region_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + supported_compressions_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 max_update_entries = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &max_update_entries_))); + set_has_max_update_entries(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_max_database_entries; + break; + } + + // optional int32 max_database_entries = 2; + case 2: { + if (tag == 16) { + parse_max_database_entries: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &max_database_entries_))); + set_has_max_database_entries(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_region; + break; + } + + // optional string region = 3; + case 3: { + if (tag == 26) { + parse_region: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_region())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_supported_compressions; + break; + } + + // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; + case 4: { + if (tag == 32) { + parse_supported_compressions: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::CompressionType_IsValid(value)) { + add_supported_compressions(static_cast< ::mozilla::safebrowsing::CompressionType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else if (tag == 34) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::mozilla::safebrowsing::CompressionType_IsValid, + this->mutable_supported_compressions()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_supported_compressions; + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + return false; +#undef DO_ +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + // optional int32 max_update_entries = 1; + if (has_max_update_entries()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->max_update_entries(), output); + } + + // optional int32 max_database_entries = 2; + if (has_max_database_entries()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->max_database_entries(), output); + } + + // optional string region = 3; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->region(), output); + } + + // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; + for (int i = 0; i < this->supported_compressions_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 4, this->supported_compressions(i), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) +} + +int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional int32 max_update_entries = 1; + if (has_max_update_entries()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->max_update_entries()); + } + + // optional int32 max_database_entries = 2; + if (has_max_database_entries()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->max_database_entries()); + } + + // optional string region = 3; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->region()); + } + + } + // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; + { + int data_size = 0; + for (int i = 0; i < this->supported_compressions_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->supported_compressions(i)); + } + total_size += 1 * this->supported_compressions_size() + data_size; + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(&from)); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) { + GOOGLE_CHECK_NE(&from, this); + supported_compressions_.MergeFrom(from.supported_compressions_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_max_update_entries()) { + set_max_update_entries(from.max_update_entries()); + } + if (from.has_max_database_entries()) { + set_max_database_entries(from.max_database_entries()); + } + if (from.has_region()) { + set_region(from.region()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::IsInitialized() const { + + return true; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other) { + if (other != this) { + std::swap(max_update_entries_, other->max_update_entries_); + std::swap(max_database_entries_, other->max_database_entries_); + std::swap(region_, other->region_); + supported_compressions_.Swap(&other->supported_compressions_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints"; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int FetchThreatListUpdatesRequest_ListUpdateRequest::kThreatTypeFieldNumber; +const int FetchThreatListUpdatesRequest_ListUpdateRequest::kPlatformTypeFieldNumber; +const int FetchThreatListUpdatesRequest_ListUpdateRequest::kThreatEntryTypeFieldNumber; +const int FetchThreatListUpdatesRequest_ListUpdateRequest::kStateFieldNumber; +const int FetchThreatListUpdatesRequest_ListUpdateRequest::kConstraintsFieldNumber; +#endif // !_MSC_VER + +FetchThreatListUpdatesRequest_ListUpdateRequest::FetchThreatListUpdatesRequest_ListUpdateRequest() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + constraints_ = const_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>( + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::internal_default_instance()); +#else + constraints_ = const_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(&::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance()); +#endif +} + +FetchThreatListUpdatesRequest_ListUpdateRequest::FetchThreatListUpdatesRequest_ListUpdateRequest(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + threat_type_ = 0; + platform_type_ = 0; + threat_entry_type_ = 0; + state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + constraints_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FetchThreatListUpdatesRequest_ListUpdateRequest::~FetchThreatListUpdatesRequest_ListUpdateRequest() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + SharedDtor(); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::SharedDtor() { + if (state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete state_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete constraints_; + } +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance_ = NULL; + +FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest_ListUpdateRequest::New() const { + return new FetchThreatListUpdatesRequest_ListUpdateRequest; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \ + &reinterpret_cast<FetchThreatListUpdatesRequest_ListUpdateRequest*>(16)->f) - \ + reinterpret_cast<char*>(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 31) { + ZR_(threat_type_, platform_type_); + threat_entry_type_ = 0; + if (has_state()) { + if (state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + state_->clear(); + } + } + if (has_constraints()) { + if (constraints_ != NULL) constraints_->::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool FetchThreatListUpdatesRequest_ListUpdateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatType_IsValid(value)) { + set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_platform_type; + break; + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + case 2: { + if (tag == 16) { + parse_platform_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::PlatformType_IsValid(value)) { + set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_state; + break; + } + + // optional bytes state = 3; + case 3: { + if (tag == 26) { + parse_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_constraints; + break; + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; + case 4: { + if (tag == 34) { + parse_constraints: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_constraints())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_threat_entry_type; + break; + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; + case 5: { + if (tag == 40) { + parse_threat_entry_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) { + set_threat_entry_type(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + return false; +#undef DO_ +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->threat_type(), output); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (has_platform_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->platform_type(), output); + } + + // optional bytes state = 3; + if (has_state()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 3, this->state(), output); + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; + if (has_constraints()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->constraints(), output); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; + if (has_threat_entry_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 5, this->threat_entry_type(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) +} + +int FetchThreatListUpdatesRequest_ListUpdateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (has_platform_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; + if (has_threat_entry_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_entry_type()); + } + + // optional bytes state = 3; + if (has_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->state()); + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; + if (has_constraints()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->constraints()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest*>(&from)); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_threat_type()) { + set_threat_type(from.threat_type()); + } + if (from.has_platform_type()) { + set_platform_type(from.platform_type()); + } + if (from.has_threat_entry_type()) { + set_threat_entry_type(from.threat_entry_type()); + } + if (from.has_state()) { + set_state(from.state()); + } + if (from.has_constraints()) { + mutable_constraints()->::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergeFrom(from.constraints()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesRequest_ListUpdateRequest::IsInitialized() const { + + return true; +} + +void FetchThreatListUpdatesRequest_ListUpdateRequest::Swap(FetchThreatListUpdatesRequest_ListUpdateRequest* other) { + if (other != this) { + std::swap(threat_type_, other->threat_type_); + std::swap(platform_type_, other->platform_type_); + std::swap(threat_entry_type_, other->threat_entry_type_); + std::swap(state_, other->state_); + std::swap(constraints_, other->constraints_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FetchThreatListUpdatesRequest_ListUpdateRequest::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest"; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int FetchThreatListUpdatesRequest::kClientFieldNumber; +const int FetchThreatListUpdatesRequest::kListUpdateRequestsFieldNumber; +#endif // !_MSC_VER + +FetchThreatListUpdatesRequest::FetchThreatListUpdatesRequest() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest) +} + +void FetchThreatListUpdatesRequest::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>( + ::mozilla::safebrowsing::ClientInfo::internal_default_instance()); +#else + client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(&::mozilla::safebrowsing::ClientInfo::default_instance()); +#endif +} + +FetchThreatListUpdatesRequest::FetchThreatListUpdatesRequest(const FetchThreatListUpdatesRequest& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest) +} + +void FetchThreatListUpdatesRequest::SharedCtor() { + _cached_size_ = 0; + client_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FetchThreatListUpdatesRequest::~FetchThreatListUpdatesRequest() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + SharedDtor(); +} + +void FetchThreatListUpdatesRequest::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete client_; + } +} + +void FetchThreatListUpdatesRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FetchThreatListUpdatesRequest& FetchThreatListUpdatesRequest::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +FetchThreatListUpdatesRequest* FetchThreatListUpdatesRequest::default_instance_ = NULL; + +FetchThreatListUpdatesRequest* FetchThreatListUpdatesRequest::New() const { + return new FetchThreatListUpdatesRequest; +} + +void FetchThreatListUpdatesRequest::Clear() { + if (has_client()) { + if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear(); + } + list_update_requests_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool FetchThreatListUpdatesRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_client())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_list_update_requests; + break; + } + + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; + case 3: { + if (tag == 26) { + parse_list_update_requests: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_list_update_requests())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_list_update_requests; + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + return false; +#undef DO_ +} + +void FetchThreatListUpdatesRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (has_client()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->client(), output); + } + + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; + for (int i = 0; i < this->list_update_requests_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->list_update_requests(i), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesRequest) +} + +int FetchThreatListUpdatesRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (has_client()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->client()); + } + + } + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; + total_size += 1 * this->list_update_requests_size(); + for (int i = 0; i < this->list_update_requests_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->list_update_requests(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FetchThreatListUpdatesRequest::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesRequest*>(&from)); +} + +void FetchThreatListUpdatesRequest::MergeFrom(const FetchThreatListUpdatesRequest& from) { + GOOGLE_CHECK_NE(&from, this); + list_update_requests_.MergeFrom(from.list_update_requests_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_client()) { + mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from.client()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void FetchThreatListUpdatesRequest::CopyFrom(const FetchThreatListUpdatesRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesRequest::IsInitialized() const { + + return true; +} + +void FetchThreatListUpdatesRequest::Swap(FetchThreatListUpdatesRequest* other) { + if (other != this) { + std::swap(client_, other->client_); + list_update_requests_.Swap(&other->list_update_requests_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FetchThreatListUpdatesRequest::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesRequest"; +} + + +// =================================================================== + +bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::RESPONSE_TYPE_UNSPECIFIED; +const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::PARTIAL_UPDATE; +const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::FULL_UPDATE; +const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::ResponseType_MIN; +const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::ResponseType_MAX; +const int FetchThreatListUpdatesResponse_ListUpdateResponse::ResponseType_ARRAYSIZE; +#endif // _MSC_VER +#ifndef _MSC_VER +const int FetchThreatListUpdatesResponse_ListUpdateResponse::kThreatTypeFieldNumber; +const int FetchThreatListUpdatesResponse_ListUpdateResponse::kThreatEntryTypeFieldNumber; +const int FetchThreatListUpdatesResponse_ListUpdateResponse::kPlatformTypeFieldNumber; +const int FetchThreatListUpdatesResponse_ListUpdateResponse::kResponseTypeFieldNumber; +const int FetchThreatListUpdatesResponse_ListUpdateResponse::kAdditionsFieldNumber; +const int FetchThreatListUpdatesResponse_ListUpdateResponse::kRemovalsFieldNumber; +const int FetchThreatListUpdatesResponse_ListUpdateResponse::kNewClientStateFieldNumber; +const int FetchThreatListUpdatesResponse_ListUpdateResponse::kChecksumFieldNumber; +#endif // !_MSC_VER + +FetchThreatListUpdatesResponse_ListUpdateResponse::FetchThreatListUpdatesResponse_ListUpdateResponse() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + checksum_ = const_cast< ::mozilla::safebrowsing::Checksum*>( + ::mozilla::safebrowsing::Checksum::internal_default_instance()); +#else + checksum_ = const_cast< ::mozilla::safebrowsing::Checksum*>(&::mozilla::safebrowsing::Checksum::default_instance()); +#endif +} + +FetchThreatListUpdatesResponse_ListUpdateResponse::FetchThreatListUpdatesResponse_ListUpdateResponse(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + threat_type_ = 0; + threat_entry_type_ = 0; + platform_type_ = 0; + response_type_ = 0; + new_client_state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + checksum_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FetchThreatListUpdatesResponse_ListUpdateResponse::~FetchThreatListUpdatesResponse_ListUpdateResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + SharedDtor(); +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::SharedDtor() { + if (new_client_state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete new_client_state_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete checksum_; + } +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance_ = NULL; + +FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse_ListUpdateResponse::New() const { + return new FetchThreatListUpdatesResponse_ListUpdateResponse; +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \ + &reinterpret_cast<FetchThreatListUpdatesResponse_ListUpdateResponse*>(16)->f) - \ + reinterpret_cast<char*>(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 207) { + ZR_(threat_type_, response_type_); + if (has_new_client_state()) { + if (new_client_state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + new_client_state_->clear(); + } + } + if (has_checksum()) { + if (checksum_ != NULL) checksum_->::mozilla::safebrowsing::Checksum::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + additions_.Clear(); + removals_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool FetchThreatListUpdatesResponse_ListUpdateResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatType_IsValid(value)) { + set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_threat_entry_type; + break; + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; + case 2: { + if (tag == 16) { + parse_threat_entry_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) { + set_threat_entry_type(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_platform_type; + break; + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 3; + case 3: { + if (tag == 24) { + parse_platform_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::PlatformType_IsValid(value)) { + set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_response_type; + break; + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; + case 4: { + if (tag == 32) { + parse_response_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value)) { + set_response_type(static_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_additions; + break; + } + + // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; + case 5: { + if (tag == 42) { + parse_additions: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_additions())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_additions; + if (input->ExpectTag(50)) goto parse_removals; + break; + } + + // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; + case 6: { + if (tag == 50) { + parse_removals: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_removals())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_removals; + if (input->ExpectTag(58)) goto parse_new_client_state; + break; + } + + // optional bytes new_client_state = 7; + case 7: { + if (tag == 58) { + parse_new_client_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_new_client_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_checksum; + break; + } + + // optional .mozilla.safebrowsing.Checksum checksum = 8; + case 8: { + if (tag == 66) { + parse_checksum: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_checksum())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + return false; +#undef DO_ +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->threat_type(), output); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; + if (has_threat_entry_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->threat_entry_type(), output); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 3; + if (has_platform_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 3, this->platform_type(), output); + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; + if (has_response_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 4, this->response_type(), output); + } + + // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; + for (int i = 0; i < this->additions_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 5, this->additions(i), output); + } + + // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; + for (int i = 0; i < this->removals_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 6, this->removals(i), output); + } + + // optional bytes new_client_state = 7; + if (has_new_client_state()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 7, this->new_client_state(), output); + } + + // optional .mozilla.safebrowsing.Checksum checksum = 8; + if (has_checksum()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 8, this->checksum(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) +} + +int FetchThreatListUpdatesResponse_ListUpdateResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; + if (has_threat_entry_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_entry_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 3; + if (has_platform_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type()); + } + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; + if (has_response_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->response_type()); + } + + // optional bytes new_client_state = 7; + if (has_new_client_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->new_client_state()); + } + + // optional .mozilla.safebrowsing.Checksum checksum = 8; + if (has_checksum()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->checksum()); + } + + } + // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; + total_size += 1 * this->additions_size(); + for (int i = 0; i < this->additions_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->additions(i)); + } + + // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; + total_size += 1 * this->removals_size(); + for (int i = 0; i < this->removals_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->removals(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesResponse_ListUpdateResponse*>(&from)); +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::MergeFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) { + GOOGLE_CHECK_NE(&from, this); + additions_.MergeFrom(from.additions_); + removals_.MergeFrom(from.removals_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_threat_type()) { + set_threat_type(from.threat_type()); + } + if (from.has_threat_entry_type()) { + set_threat_entry_type(from.threat_entry_type()); + } + if (from.has_platform_type()) { + set_platform_type(from.platform_type()); + } + if (from.has_response_type()) { + set_response_type(from.response_type()); + } + if (from.has_new_client_state()) { + set_new_client_state(from.new_client_state()); + } + if (from.has_checksum()) { + mutable_checksum()->::mozilla::safebrowsing::Checksum::MergeFrom(from.checksum()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::CopyFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesResponse_ListUpdateResponse::IsInitialized() const { + + return true; +} + +void FetchThreatListUpdatesResponse_ListUpdateResponse::Swap(FetchThreatListUpdatesResponse_ListUpdateResponse* other) { + if (other != this) { + std::swap(threat_type_, other->threat_type_); + std::swap(threat_entry_type_, other->threat_entry_type_); + std::swap(platform_type_, other->platform_type_); + std::swap(response_type_, other->response_type_); + additions_.Swap(&other->additions_); + removals_.Swap(&other->removals_); + std::swap(new_client_state_, other->new_client_state_); + std::swap(checksum_, other->checksum_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FetchThreatListUpdatesResponse_ListUpdateResponse::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse"; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int FetchThreatListUpdatesResponse::kListUpdateResponsesFieldNumber; +const int FetchThreatListUpdatesResponse::kMinimumWaitDurationFieldNumber; +#endif // !_MSC_VER + +FetchThreatListUpdatesResponse::FetchThreatListUpdatesResponse() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse) +} + +void FetchThreatListUpdatesResponse::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>( + ::mozilla::safebrowsing::Duration::internal_default_instance()); +#else + minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(&::mozilla::safebrowsing::Duration::default_instance()); +#endif +} + +FetchThreatListUpdatesResponse::FetchThreatListUpdatesResponse(const FetchThreatListUpdatesResponse& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse) +} + +void FetchThreatListUpdatesResponse::SharedCtor() { + _cached_size_ = 0; + minimum_wait_duration_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FetchThreatListUpdatesResponse::~FetchThreatListUpdatesResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + SharedDtor(); +} + +void FetchThreatListUpdatesResponse::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete minimum_wait_duration_; + } +} + +void FetchThreatListUpdatesResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FetchThreatListUpdatesResponse& FetchThreatListUpdatesResponse::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +FetchThreatListUpdatesResponse* FetchThreatListUpdatesResponse::default_instance_ = NULL; + +FetchThreatListUpdatesResponse* FetchThreatListUpdatesResponse::New() const { + return new FetchThreatListUpdatesResponse; +} + +void FetchThreatListUpdatesResponse::Clear() { + if (has_minimum_wait_duration()) { + if (minimum_wait_duration_ != NULL) minimum_wait_duration_->::mozilla::safebrowsing::Duration::Clear(); + } + list_update_responses_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool FetchThreatListUpdatesResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; + case 1: { + if (tag == 10) { + parse_list_update_responses: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_list_update_responses())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_list_update_responses; + if (input->ExpectTag(18)) goto parse_minimum_wait_duration; + break; + } + + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + case 2: { + if (tag == 18) { + parse_minimum_wait_duration: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_minimum_wait_duration())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + return false; +#undef DO_ +} + +void FetchThreatListUpdatesResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; + for (int i = 0; i < this->list_update_responses_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->list_update_responses(i), output); + } + + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + if (has_minimum_wait_duration()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->minimum_wait_duration(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesResponse) +} + +int FetchThreatListUpdatesResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + if (has_minimum_wait_duration()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->minimum_wait_duration()); + } + + } + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; + total_size += 1 * this->list_update_responses_size(); + for (int i = 0; i < this->list_update_responses_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->list_update_responses(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FetchThreatListUpdatesResponse::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesResponse*>(&from)); +} + +void FetchThreatListUpdatesResponse::MergeFrom(const FetchThreatListUpdatesResponse& from) { + GOOGLE_CHECK_NE(&from, this); + list_update_responses_.MergeFrom(from.list_update_responses_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_minimum_wait_duration()) { + mutable_minimum_wait_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from.minimum_wait_duration()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void FetchThreatListUpdatesResponse::CopyFrom(const FetchThreatListUpdatesResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchThreatListUpdatesResponse::IsInitialized() const { + + return true; +} + +void FetchThreatListUpdatesResponse::Swap(FetchThreatListUpdatesResponse* other) { + if (other != this) { + list_update_responses_.Swap(&other->list_update_responses_); + std::swap(minimum_wait_duration_, other->minimum_wait_duration_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FetchThreatListUpdatesResponse::GetTypeName() const { + return "mozilla.safebrowsing.FetchThreatListUpdatesResponse"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FindFullHashesRequest::kClientFieldNumber; +const int FindFullHashesRequest::kClientStatesFieldNumber; +const int FindFullHashesRequest::kThreatInfoFieldNumber; +#endif // !_MSC_VER + +FindFullHashesRequest::FindFullHashesRequest() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindFullHashesRequest) +} + +void FindFullHashesRequest::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>( + ::mozilla::safebrowsing::ClientInfo::internal_default_instance()); +#else + client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(&::mozilla::safebrowsing::ClientInfo::default_instance()); +#endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>( + ::mozilla::safebrowsing::ThreatInfo::internal_default_instance()); +#else + threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>(&::mozilla::safebrowsing::ThreatInfo::default_instance()); +#endif +} + +FindFullHashesRequest::FindFullHashesRequest(const FindFullHashesRequest& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindFullHashesRequest) +} + +void FindFullHashesRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + client_ = NULL; + threat_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FindFullHashesRequest::~FindFullHashesRequest() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindFullHashesRequest) + SharedDtor(); +} + +void FindFullHashesRequest::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete client_; + delete threat_info_; + } +} + +void FindFullHashesRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FindFullHashesRequest& FindFullHashesRequest::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +FindFullHashesRequest* FindFullHashesRequest::default_instance_ = NULL; + +FindFullHashesRequest* FindFullHashesRequest::New() const { + return new FindFullHashesRequest; +} + +void FindFullHashesRequest::Clear() { + if (_has_bits_[0 / 32] & 5) { + if (has_client()) { + if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear(); + } + if (has_threat_info()) { + if (threat_info_ != NULL) threat_info_->::mozilla::safebrowsing::ThreatInfo::Clear(); + } + } + client_states_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool FindFullHashesRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FindFullHashesRequest) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_client())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_client_states; + break; + } + + // repeated bytes client_states = 2; + case 2: { + if (tag == 18) { + parse_client_states: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->add_client_states())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_client_states; + if (input->ExpectTag(26)) goto parse_threat_info; + break; + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; + case 3: { + if (tag == 26) { + parse_threat_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_threat_info())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.FindFullHashesRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FindFullHashesRequest) + return false; +#undef DO_ +} + +void FindFullHashesRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FindFullHashesRequest) + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (has_client()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->client(), output); + } + + // repeated bytes client_states = 2; + for (int i = 0; i < this->client_states_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 2, this->client_states(i), output); + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; + if (has_threat_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->threat_info(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FindFullHashesRequest) +} + +int FindFullHashesRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .mozilla.safebrowsing.ClientInfo client = 1; + if (has_client()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->client()); + } + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; + if (has_threat_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->threat_info()); + } + + } + // repeated bytes client_states = 2; + total_size += 1 * this->client_states_size(); + for (int i = 0; i < this->client_states_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( + this->client_states(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FindFullHashesRequest::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const FindFullHashesRequest*>(&from)); +} + +void FindFullHashesRequest::MergeFrom(const FindFullHashesRequest& from) { + GOOGLE_CHECK_NE(&from, this); + client_states_.MergeFrom(from.client_states_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_client()) { + mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from.client()); + } + if (from.has_threat_info()) { + mutable_threat_info()->::mozilla::safebrowsing::ThreatInfo::MergeFrom(from.threat_info()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void FindFullHashesRequest::CopyFrom(const FindFullHashesRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FindFullHashesRequest::IsInitialized() const { + + return true; +} + +void FindFullHashesRequest::Swap(FindFullHashesRequest* other) { + if (other != this) { + std::swap(client_, other->client_); + client_states_.Swap(&other->client_states_); + std::swap(threat_info_, other->threat_info_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FindFullHashesRequest::GetTypeName() const { + return "mozilla.safebrowsing.FindFullHashesRequest"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FindFullHashesResponse::kMatchesFieldNumber; +const int FindFullHashesResponse::kMinimumWaitDurationFieldNumber; +const int FindFullHashesResponse::kNegativeCacheDurationFieldNumber; +#endif // !_MSC_VER + +FindFullHashesResponse::FindFullHashesResponse() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindFullHashesResponse) +} + +void FindFullHashesResponse::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>( + ::mozilla::safebrowsing::Duration::internal_default_instance()); +#else + minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(&::mozilla::safebrowsing::Duration::default_instance()); +#endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + negative_cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>( + ::mozilla::safebrowsing::Duration::internal_default_instance()); +#else + negative_cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(&::mozilla::safebrowsing::Duration::default_instance()); +#endif +} + +FindFullHashesResponse::FindFullHashesResponse(const FindFullHashesResponse& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindFullHashesResponse) +} + +void FindFullHashesResponse::SharedCtor() { + _cached_size_ = 0; + minimum_wait_duration_ = NULL; + negative_cache_duration_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FindFullHashesResponse::~FindFullHashesResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindFullHashesResponse) + SharedDtor(); +} + +void FindFullHashesResponse::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete minimum_wait_duration_; + delete negative_cache_duration_; + } +} + +void FindFullHashesResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FindFullHashesResponse& FindFullHashesResponse::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +FindFullHashesResponse* FindFullHashesResponse::default_instance_ = NULL; + +FindFullHashesResponse* FindFullHashesResponse::New() const { + return new FindFullHashesResponse; +} + +void FindFullHashesResponse::Clear() { + if (_has_bits_[0 / 32] & 6) { + if (has_minimum_wait_duration()) { + if (minimum_wait_duration_ != NULL) minimum_wait_duration_->::mozilla::safebrowsing::Duration::Clear(); + } + if (has_negative_cache_duration()) { + if (negative_cache_duration_ != NULL) negative_cache_duration_->::mozilla::safebrowsing::Duration::Clear(); + } + } + matches_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool FindFullHashesResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FindFullHashesResponse) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + case 1: { + if (tag == 10) { + parse_matches: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_matches())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_matches; + if (input->ExpectTag(18)) goto parse_minimum_wait_duration; + break; + } + + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + case 2: { + if (tag == 18) { + parse_minimum_wait_duration: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_minimum_wait_duration())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_negative_cache_duration; + break; + } + + // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; + case 3: { + if (tag == 26) { + parse_negative_cache_duration: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_negative_cache_duration())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.FindFullHashesResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FindFullHashesResponse) + return false; +#undef DO_ +} + +void FindFullHashesResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FindFullHashesResponse) + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + for (int i = 0; i < this->matches_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->matches(i), output); + } + + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + if (has_minimum_wait_duration()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->minimum_wait_duration(), output); + } + + // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; + if (has_negative_cache_duration()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->negative_cache_duration(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FindFullHashesResponse) +} + +int FindFullHashesResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + if (has_minimum_wait_duration()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->minimum_wait_duration()); + } + + // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; + if (has_negative_cache_duration()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->negative_cache_duration()); + } + + } + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + total_size += 1 * this->matches_size(); + for (int i = 0; i < this->matches_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->matches(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FindFullHashesResponse::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const FindFullHashesResponse*>(&from)); +} + +void FindFullHashesResponse::MergeFrom(const FindFullHashesResponse& from) { + GOOGLE_CHECK_NE(&from, this); + matches_.MergeFrom(from.matches_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_minimum_wait_duration()) { + mutable_minimum_wait_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from.minimum_wait_duration()); + } + if (from.has_negative_cache_duration()) { + mutable_negative_cache_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from.negative_cache_duration()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void FindFullHashesResponse::CopyFrom(const FindFullHashesResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FindFullHashesResponse::IsInitialized() const { + + return true; +} + +void FindFullHashesResponse::Swap(FindFullHashesResponse* other) { + if (other != this) { + matches_.Swap(&other->matches_); + std::swap(minimum_wait_duration_, other->minimum_wait_duration_); + std::swap(negative_cache_duration_, other->negative_cache_duration_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FindFullHashesResponse::GetTypeName() const { + return "mozilla.safebrowsing.FindFullHashesResponse"; +} + + +// =================================================================== + +bool ThreatHit_ThreatSourceType_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const ThreatHit_ThreatSourceType ThreatHit::THREAT_SOURCE_TYPE_UNSPECIFIED; +const ThreatHit_ThreatSourceType ThreatHit::MATCHING_URL; +const ThreatHit_ThreatSourceType ThreatHit::TAB_URL; +const ThreatHit_ThreatSourceType ThreatHit::TAB_REDIRECT; +const ThreatHit_ThreatSourceType ThreatHit::ThreatSourceType_MIN; +const ThreatHit_ThreatSourceType ThreatHit::ThreatSourceType_MAX; +const int ThreatHit::ThreatSourceType_ARRAYSIZE; +#endif // _MSC_VER +#ifndef _MSC_VER +const int ThreatHit_ThreatSource::kUrlFieldNumber; +const int ThreatHit_ThreatSource::kTypeFieldNumber; +const int ThreatHit_ThreatSource::kRemoteIpFieldNumber; +const int ThreatHit_ThreatSource::kReferrerFieldNumber; +#endif // !_MSC_VER + +ThreatHit_ThreatSource::ThreatHit_ThreatSource() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatHit.ThreatSource) +} + +void ThreatHit_ThreatSource::InitAsDefaultInstance() { +} + +ThreatHit_ThreatSource::ThreatHit_ThreatSource(const ThreatHit_ThreatSource& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit.ThreatSource) +} + +void ThreatHit_ThreatSource::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_ = 0; + remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ThreatHit_ThreatSource::~ThreatHit_ThreatSource() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit.ThreatSource) + SharedDtor(); +} + +void ThreatHit_ThreatSource::SharedDtor() { + if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete url_; + } + if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete remote_ip_; + } + if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete referrer_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void ThreatHit_ThreatSource::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ThreatHit_ThreatSource& ThreatHit_ThreatSource::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ThreatHit_ThreatSource* ThreatHit_ThreatSource::default_instance_ = NULL; + +ThreatHit_ThreatSource* ThreatHit_ThreatSource::New() const { + return new ThreatHit_ThreatSource; +} + +void ThreatHit_ThreatSource::Clear() { + if (_has_bits_[0 / 32] & 15) { + if (has_url()) { + if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_->clear(); + } + } + type_ = 0; + if (has_remote_ip()) { + if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + remote_ip_->clear(); + } + } + if (has_referrer()) { + if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + referrer_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ThreatHit_ThreatSource::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatHit.ThreatSource) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string url = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_url())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_type; + break; + } + + // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; + case 2: { + if (tag == 16) { + parse_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatHit_ThreatSourceType_IsValid(value)) { + set_type(static_cast< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_remote_ip; + break; + } + + // optional string remote_ip = 3; + case 3: { + if (tag == 26) { + parse_remote_ip: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_remote_ip())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_referrer; + break; + } + + // optional string referrer = 4; + case 4: { + if (tag == 34) { + parse_referrer: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_referrer())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ThreatHit.ThreatSource) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatHit.ThreatSource) + return false; +#undef DO_ +} + +void ThreatHit_ThreatSource::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatHit.ThreatSource) + // optional string url = 1; + if (has_url()) { + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->url(), output); + } + + // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->type(), output); + } + + // optional string remote_ip = 3; + if (has_remote_ip()) { + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->remote_ip(), output); + } + + // optional string referrer = 4; + if (has_referrer()) { + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->referrer(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatHit.ThreatSource) +} + +int ThreatHit_ThreatSource::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string url = 1; + if (has_url()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->url()); + } + + // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + } + + // optional string remote_ip = 3; + if (has_remote_ip()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->remote_ip()); + } + + // optional string referrer = 4; + if (has_referrer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->referrer()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThreatHit_ThreatSource::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ThreatHit_ThreatSource*>(&from)); +} + +void ThreatHit_ThreatSource::MergeFrom(const ThreatHit_ThreatSource& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_url()) { + set_url(from.url()); + } + if (from.has_type()) { + set_type(from.type()); + } + if (from.has_remote_ip()) { + set_remote_ip(from.remote_ip()); + } + if (from.has_referrer()) { + set_referrer(from.referrer()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ThreatHit_ThreatSource::CopyFrom(const ThreatHit_ThreatSource& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatHit_ThreatSource::IsInitialized() const { + + return true; +} + +void ThreatHit_ThreatSource::Swap(ThreatHit_ThreatSource* other) { + if (other != this) { + std::swap(url_, other->url_); + std::swap(type_, other->type_); + std::swap(remote_ip_, other->remote_ip_); + std::swap(referrer_, other->referrer_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ThreatHit_ThreatSource::GetTypeName() const { + return "mozilla.safebrowsing.ThreatHit.ThreatSource"; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int ThreatHit::kThreatTypeFieldNumber; +const int ThreatHit::kPlatformTypeFieldNumber; +const int ThreatHit::kEntryFieldNumber; +const int ThreatHit::kResourcesFieldNumber; +#endif // !_MSC_VER + +ThreatHit::ThreatHit() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatHit) +} + +void ThreatHit::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + entry_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>( + ::mozilla::safebrowsing::ThreatEntry::internal_default_instance()); +#else + entry_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>(&::mozilla::safebrowsing::ThreatEntry::default_instance()); +#endif +} + +ThreatHit::ThreatHit(const ThreatHit& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit) +} + +void ThreatHit::SharedCtor() { + _cached_size_ = 0; + threat_type_ = 0; + platform_type_ = 0; + entry_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ThreatHit::~ThreatHit() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit) + SharedDtor(); +} + +void ThreatHit::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete entry_; + } +} + +void ThreatHit::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ThreatHit& ThreatHit::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ThreatHit* ThreatHit::default_instance_ = NULL; + +ThreatHit* ThreatHit::New() const { + return new ThreatHit; +} + +void ThreatHit::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \ + &reinterpret_cast<ThreatHit*>(16)->f) - \ + reinterpret_cast<char*>(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 7) { + ZR_(threat_type_, platform_type_); + if (has_entry()) { + if (entry_ != NULL) entry_->::mozilla::safebrowsing::ThreatEntry::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + resources_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ThreatHit::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatHit) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatType_IsValid(value)) { + set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_platform_type; + break; + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + case 2: { + if (tag == 16) { + parse_platform_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::PlatformType_IsValid(value)) { + set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_entry; + break; + } + + // optional .mozilla.safebrowsing.ThreatEntry entry = 3; + case 3: { + if (tag == 26) { + parse_entry: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entry())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_resources; + break; + } + + // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; + case 4: { + if (tag == 34) { + parse_resources: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_resources())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_resources; + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ThreatHit) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatHit) + return false; +#undef DO_ +} + +void ThreatHit::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatHit) + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->threat_type(), output); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (has_platform_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->platform_type(), output); + } + + // optional .mozilla.safebrowsing.ThreatEntry entry = 3; + if (has_entry()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->entry(), output); + } + + // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; + for (int i = 0; i < this->resources_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->resources(i), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatHit) +} + +int ThreatHit::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (has_platform_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntry entry = 3; + if (has_entry()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entry()); + } + + } + // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; + total_size += 1 * this->resources_size(); + for (int i = 0; i < this->resources_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->resources(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThreatHit::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ThreatHit*>(&from)); +} + +void ThreatHit::MergeFrom(const ThreatHit& from) { + GOOGLE_CHECK_NE(&from, this); + resources_.MergeFrom(from.resources_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_threat_type()) { + set_threat_type(from.threat_type()); + } + if (from.has_platform_type()) { + set_platform_type(from.platform_type()); + } + if (from.has_entry()) { + mutable_entry()->::mozilla::safebrowsing::ThreatEntry::MergeFrom(from.entry()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ThreatHit::CopyFrom(const ThreatHit& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatHit::IsInitialized() const { + + return true; +} + +void ThreatHit::Swap(ThreatHit* other) { + if (other != this) { + std::swap(threat_type_, other->threat_type_); + std::swap(platform_type_, other->platform_type_); + std::swap(entry_, other->entry_); + resources_.Swap(&other->resources_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ThreatHit::GetTypeName() const { + return "mozilla.safebrowsing.ThreatHit"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ClientInfo::kClientIdFieldNumber; +const int ClientInfo::kClientVersionFieldNumber; +#endif // !_MSC_VER + +ClientInfo::ClientInfo() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ClientInfo) +} + +void ClientInfo::InitAsDefaultInstance() { +} + +ClientInfo::ClientInfo(const ClientInfo& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ClientInfo) +} + +void ClientInfo::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + client_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ClientInfo::~ClientInfo() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ClientInfo) + SharedDtor(); +} + +void ClientInfo::SharedDtor() { + if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_id_; + } + if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_version_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void ClientInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ClientInfo& ClientInfo::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ClientInfo* ClientInfo::default_instance_ = NULL; + +ClientInfo* ClientInfo::New() const { + return new ClientInfo; +} + +void ClientInfo::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_client_id()) { + if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_id_->clear(); + } + } + if (has_client_version()) { + if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_version_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ClientInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ClientInfo) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string client_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_client_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_client_version; + break; + } + + // optional string client_version = 2; + case 2: { + if (tag == 18) { + parse_client_version: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_client_version())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ClientInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ClientInfo) + return false; +#undef DO_ +} + +void ClientInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ClientInfo) + // optional string client_id = 1; + if (has_client_id()) { + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->client_id(), output); + } + + // optional string client_version = 2; + if (has_client_version()) { + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->client_version(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ClientInfo) +} + +int ClientInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string client_id = 1; + if (has_client_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->client_id()); + } + + // optional string client_version = 2; + if (has_client_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->client_version()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ClientInfo::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ClientInfo*>(&from)); +} + +void ClientInfo::MergeFrom(const ClientInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_client_id()) { + set_client_id(from.client_id()); + } + if (from.has_client_version()) { + set_client_version(from.client_version()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ClientInfo::CopyFrom(const ClientInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientInfo::IsInitialized() const { + + return true; +} + +void ClientInfo::Swap(ClientInfo* other) { + if (other != this) { + std::swap(client_id_, other->client_id_); + std::swap(client_version_, other->client_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ClientInfo::GetTypeName() const { + return "mozilla.safebrowsing.ClientInfo"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Checksum::kSha256FieldNumber; +#endif // !_MSC_VER + +Checksum::Checksum() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.Checksum) +} + +void Checksum::InitAsDefaultInstance() { +} + +Checksum::Checksum(const Checksum& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.Checksum) +} + +void Checksum::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Checksum::~Checksum() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.Checksum) + SharedDtor(); +} + +void Checksum::SharedDtor() { + if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sha256_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void Checksum::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const Checksum& Checksum::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +Checksum* Checksum::default_instance_ = NULL; + +Checksum* Checksum::New() const { + return new Checksum; +} + +void Checksum::Clear() { + if (has_sha256()) { + if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sha256_->clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool Checksum::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.Checksum) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional bytes sha256 = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_sha256())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.Checksum) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.Checksum) + return false; +#undef DO_ +} + +void Checksum::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.Checksum) + // optional bytes sha256 = 1; + if (has_sha256()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->sha256(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.Checksum) +} + +int Checksum::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bytes sha256 = 1; + if (has_sha256()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->sha256()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Checksum::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const Checksum*>(&from)); +} + +void Checksum::MergeFrom(const Checksum& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_sha256()) { + set_sha256(from.sha256()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void Checksum::CopyFrom(const Checksum& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Checksum::IsInitialized() const { + + return true; +} + +void Checksum::Swap(Checksum* other) { + if (other != this) { + std::swap(sha256_, other->sha256_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string Checksum::GetTypeName() const { + return "mozilla.safebrowsing.Checksum"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ThreatEntry::kHashFieldNumber; +const int ThreatEntry::kUrlFieldNumber; +#endif // !_MSC_VER + +ThreatEntry::ThreatEntry() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntry) +} + +void ThreatEntry::InitAsDefaultInstance() { +} + +ThreatEntry::ThreatEntry(const ThreatEntry& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntry) +} + +void ThreatEntry::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ThreatEntry::~ThreatEntry() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntry) + SharedDtor(); +} + +void ThreatEntry::SharedDtor() { + if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete hash_; + } + if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete url_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void ThreatEntry::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ThreatEntry& ThreatEntry::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ThreatEntry* ThreatEntry::default_instance_ = NULL; + +ThreatEntry* ThreatEntry::New() const { + return new ThreatEntry; +} + +void ThreatEntry::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_hash()) { + if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_->clear(); + } + } + if (has_url()) { + if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ThreatEntry::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatEntry) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional bytes hash = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_hash())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_url; + break; + } + + // optional string url = 2; + case 2: { + if (tag == 18) { + parse_url: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_url())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ThreatEntry) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatEntry) + return false; +#undef DO_ +} + +void ThreatEntry::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatEntry) + // optional bytes hash = 1; + if (has_hash()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->hash(), output); + } + + // optional string url = 2; + if (has_url()) { + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->url(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatEntry) +} + +int ThreatEntry::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bytes hash = 1; + if (has_hash()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->hash()); + } + + // optional string url = 2; + if (has_url()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->url()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThreatEntry::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ThreatEntry*>(&from)); +} + +void ThreatEntry::MergeFrom(const ThreatEntry& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_hash()) { + set_hash(from.hash()); + } + if (from.has_url()) { + set_url(from.url()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ThreatEntry::CopyFrom(const ThreatEntry& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatEntry::IsInitialized() const { + + return true; +} + +void ThreatEntry::Swap(ThreatEntry* other) { + if (other != this) { + std::swap(hash_, other->hash_); + std::swap(url_, other->url_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ThreatEntry::GetTypeName() const { + return "mozilla.safebrowsing.ThreatEntry"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ThreatEntrySet::kCompressionTypeFieldNumber; +const int ThreatEntrySet::kRawHashesFieldNumber; +const int ThreatEntrySet::kRawIndicesFieldNumber; +const int ThreatEntrySet::kRiceHashesFieldNumber; +const int ThreatEntrySet::kRiceIndicesFieldNumber; +#endif // !_MSC_VER + +ThreatEntrySet::ThreatEntrySet() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntrySet) +} + +void ThreatEntrySet::InitAsDefaultInstance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + raw_hashes_ = const_cast< ::mozilla::safebrowsing::RawHashes*>( + ::mozilla::safebrowsing::RawHashes::internal_default_instance()); +#else + raw_hashes_ = const_cast< ::mozilla::safebrowsing::RawHashes*>(&::mozilla::safebrowsing::RawHashes::default_instance()); +#endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + raw_indices_ = const_cast< ::mozilla::safebrowsing::RawIndices*>( + ::mozilla::safebrowsing::RawIndices::internal_default_instance()); +#else + raw_indices_ = const_cast< ::mozilla::safebrowsing::RawIndices*>(&::mozilla::safebrowsing::RawIndices::default_instance()); +#endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + rice_hashes_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>( + ::mozilla::safebrowsing::RiceDeltaEncoding::internal_default_instance()); +#else + rice_hashes_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>(&::mozilla::safebrowsing::RiceDeltaEncoding::default_instance()); +#endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + rice_indices_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>( + ::mozilla::safebrowsing::RiceDeltaEncoding::internal_default_instance()); +#else + rice_indices_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>(&::mozilla::safebrowsing::RiceDeltaEncoding::default_instance()); +#endif +} + +ThreatEntrySet::ThreatEntrySet(const ThreatEntrySet& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntrySet) +} + +void ThreatEntrySet::SharedCtor() { + _cached_size_ = 0; + compression_type_ = 0; + raw_hashes_ = NULL; + raw_indices_ = NULL; + rice_hashes_ = NULL; + rice_indices_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ThreatEntrySet::~ThreatEntrySet() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntrySet) + SharedDtor(); +} + +void ThreatEntrySet::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + delete raw_hashes_; + delete raw_indices_; + delete rice_hashes_; + delete rice_indices_; + } +} + +void ThreatEntrySet::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ThreatEntrySet& ThreatEntrySet::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ThreatEntrySet* ThreatEntrySet::default_instance_ = NULL; + +ThreatEntrySet* ThreatEntrySet::New() const { + return new ThreatEntrySet; +} + +void ThreatEntrySet::Clear() { + if (_has_bits_[0 / 32] & 31) { + compression_type_ = 0; + if (has_raw_hashes()) { + if (raw_hashes_ != NULL) raw_hashes_->::mozilla::safebrowsing::RawHashes::Clear(); + } + if (has_raw_indices()) { + if (raw_indices_ != NULL) raw_indices_->::mozilla::safebrowsing::RawIndices::Clear(); + } + if (has_rice_hashes()) { + if (rice_hashes_ != NULL) rice_hashes_->::mozilla::safebrowsing::RiceDeltaEncoding::Clear(); + } + if (has_rice_indices()) { + if (rice_indices_ != NULL) rice_indices_->::mozilla::safebrowsing::RiceDeltaEncoding::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ThreatEntrySet::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatEntrySet) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .mozilla.safebrowsing.CompressionType compression_type = 1; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::CompressionType_IsValid(value)) { + set_compression_type(static_cast< ::mozilla::safebrowsing::CompressionType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_raw_hashes; + break; + } + + // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; + case 2: { + if (tag == 18) { + parse_raw_hashes: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_raw_hashes())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_raw_indices; + break; + } + + // optional .mozilla.safebrowsing.RawIndices raw_indices = 3; + case 3: { + if (tag == 26) { + parse_raw_indices: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_raw_indices())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_rice_hashes; + break; + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; + case 4: { + if (tag == 34) { + parse_rice_hashes: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_rice_hashes())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_rice_indices; + break; + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; + case 5: { + if (tag == 42) { + parse_rice_indices: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_rice_indices())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ThreatEntrySet) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatEntrySet) + return false; +#undef DO_ +} + +void ThreatEntrySet::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatEntrySet) + // optional .mozilla.safebrowsing.CompressionType compression_type = 1; + if (has_compression_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->compression_type(), output); + } + + // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; + if (has_raw_hashes()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->raw_hashes(), output); + } + + // optional .mozilla.safebrowsing.RawIndices raw_indices = 3; + if (has_raw_indices()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->raw_indices(), output); + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; + if (has_rice_hashes()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->rice_hashes(), output); + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; + if (has_rice_indices()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 5, this->rice_indices(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatEntrySet) +} + +int ThreatEntrySet::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .mozilla.safebrowsing.CompressionType compression_type = 1; + if (has_compression_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->compression_type()); + } + + // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; + if (has_raw_hashes()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->raw_hashes()); + } + + // optional .mozilla.safebrowsing.RawIndices raw_indices = 3; + if (has_raw_indices()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->raw_indices()); + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; + if (has_rice_hashes()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->rice_hashes()); + } + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; + if (has_rice_indices()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->rice_indices()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThreatEntrySet::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ThreatEntrySet*>(&from)); +} + +void ThreatEntrySet::MergeFrom(const ThreatEntrySet& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_compression_type()) { + set_compression_type(from.compression_type()); + } + if (from.has_raw_hashes()) { + mutable_raw_hashes()->::mozilla::safebrowsing::RawHashes::MergeFrom(from.raw_hashes()); + } + if (from.has_raw_indices()) { + mutable_raw_indices()->::mozilla::safebrowsing::RawIndices::MergeFrom(from.raw_indices()); + } + if (from.has_rice_hashes()) { + mutable_rice_hashes()->::mozilla::safebrowsing::RiceDeltaEncoding::MergeFrom(from.rice_hashes()); + } + if (from.has_rice_indices()) { + mutable_rice_indices()->::mozilla::safebrowsing::RiceDeltaEncoding::MergeFrom(from.rice_indices()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ThreatEntrySet::CopyFrom(const ThreatEntrySet& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatEntrySet::IsInitialized() const { + + return true; +} + +void ThreatEntrySet::Swap(ThreatEntrySet* other) { + if (other != this) { + std::swap(compression_type_, other->compression_type_); + std::swap(raw_hashes_, other->raw_hashes_); + std::swap(raw_indices_, other->raw_indices_); + std::swap(rice_hashes_, other->rice_hashes_); + std::swap(rice_indices_, other->rice_indices_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ThreatEntrySet::GetTypeName() const { + return "mozilla.safebrowsing.ThreatEntrySet"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RawIndices::kIndicesFieldNumber; +#endif // !_MSC_VER + +RawIndices::RawIndices() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.RawIndices) +} + +void RawIndices::InitAsDefaultInstance() { +} + +RawIndices::RawIndices(const RawIndices& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RawIndices) +} + +void RawIndices::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RawIndices::~RawIndices() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.RawIndices) + SharedDtor(); +} + +void RawIndices::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void RawIndices::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const RawIndices& RawIndices::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +RawIndices* RawIndices::default_instance_ = NULL; + +RawIndices* RawIndices::New() const { + return new RawIndices; +} + +void RawIndices::Clear() { + indices_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool RawIndices::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.RawIndices) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated int32 indices = 1; + case 1: { + if (tag == 8) { + parse_indices: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + 1, 8, input, this->mutable_indices()))); + } else if (tag == 10) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_indices()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(8)) goto parse_indices; + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.RawIndices) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.RawIndices) + return false; +#undef DO_ +} + +void RawIndices::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.RawIndices) + // repeated int32 indices = 1; + for (int i = 0; i < this->indices_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt32( + 1, this->indices(i), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.RawIndices) +} + +int RawIndices::ByteSize() const { + int total_size = 0; + + // repeated int32 indices = 1; + { + int data_size = 0; + for (int i = 0; i < this->indices_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int32Size(this->indices(i)); + } + total_size += 1 * this->indices_size() + data_size; + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RawIndices::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const RawIndices*>(&from)); +} + +void RawIndices::MergeFrom(const RawIndices& from) { + GOOGLE_CHECK_NE(&from, this); + indices_.MergeFrom(from.indices_); + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void RawIndices::CopyFrom(const RawIndices& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RawIndices::IsInitialized() const { + + return true; +} + +void RawIndices::Swap(RawIndices* other) { + if (other != this) { + indices_.Swap(&other->indices_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string RawIndices::GetTypeName() const { + return "mozilla.safebrowsing.RawIndices"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RawHashes::kPrefixSizeFieldNumber; +const int RawHashes::kRawHashesFieldNumber; +#endif // !_MSC_VER + +RawHashes::RawHashes() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.RawHashes) +} + +void RawHashes::InitAsDefaultInstance() { +} + +RawHashes::RawHashes(const RawHashes& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RawHashes) +} + +void RawHashes::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + prefix_size_ = 0; + raw_hashes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RawHashes::~RawHashes() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.RawHashes) + SharedDtor(); +} + +void RawHashes::SharedDtor() { + if (raw_hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete raw_hashes_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void RawHashes::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const RawHashes& RawHashes::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +RawHashes* RawHashes::default_instance_ = NULL; + +RawHashes* RawHashes::New() const { + return new RawHashes; +} + +void RawHashes::Clear() { + if (_has_bits_[0 / 32] & 3) { + prefix_size_ = 0; + if (has_raw_hashes()) { + if (raw_hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raw_hashes_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool RawHashes::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.RawHashes) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 prefix_size = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &prefix_size_))); + set_has_prefix_size(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_raw_hashes; + break; + } + + // optional bytes raw_hashes = 2; + case 2: { + if (tag == 18) { + parse_raw_hashes: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_raw_hashes())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.RawHashes) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.RawHashes) + return false; +#undef DO_ +} + +void RawHashes::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.RawHashes) + // optional int32 prefix_size = 1; + if (has_prefix_size()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->prefix_size(), output); + } + + // optional bytes raw_hashes = 2; + if (has_raw_hashes()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->raw_hashes(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.RawHashes) +} + +int RawHashes::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional int32 prefix_size = 1; + if (has_prefix_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->prefix_size()); + } + + // optional bytes raw_hashes = 2; + if (has_raw_hashes()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->raw_hashes()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RawHashes::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const RawHashes*>(&from)); +} + +void RawHashes::MergeFrom(const RawHashes& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_prefix_size()) { + set_prefix_size(from.prefix_size()); + } + if (from.has_raw_hashes()) { + set_raw_hashes(from.raw_hashes()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void RawHashes::CopyFrom(const RawHashes& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RawHashes::IsInitialized() const { + + return true; +} + +void RawHashes::Swap(RawHashes* other) { + if (other != this) { + std::swap(prefix_size_, other->prefix_size_); + std::swap(raw_hashes_, other->raw_hashes_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string RawHashes::GetTypeName() const { + return "mozilla.safebrowsing.RawHashes"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RiceDeltaEncoding::kFirstValueFieldNumber; +const int RiceDeltaEncoding::kRiceParameterFieldNumber; +const int RiceDeltaEncoding::kNumEntriesFieldNumber; +const int RiceDeltaEncoding::kEncodedDataFieldNumber; +#endif // !_MSC_VER + +RiceDeltaEncoding::RiceDeltaEncoding() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.RiceDeltaEncoding) +} + +void RiceDeltaEncoding::InitAsDefaultInstance() { +} + +RiceDeltaEncoding::RiceDeltaEncoding(const RiceDeltaEncoding& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RiceDeltaEncoding) +} + +void RiceDeltaEncoding::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + first_value_ = GOOGLE_LONGLONG(0); + rice_parameter_ = 0; + num_entries_ = 0; + encoded_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RiceDeltaEncoding::~RiceDeltaEncoding() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.RiceDeltaEncoding) + SharedDtor(); +} + +void RiceDeltaEncoding::SharedDtor() { + if (encoded_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete encoded_data_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void RiceDeltaEncoding::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const RiceDeltaEncoding& RiceDeltaEncoding::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +RiceDeltaEncoding* RiceDeltaEncoding::default_instance_ = NULL; + +RiceDeltaEncoding* RiceDeltaEncoding::New() const { + return new RiceDeltaEncoding; +} + +void RiceDeltaEncoding::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \ + &reinterpret_cast<RiceDeltaEncoding*>(16)->f) - \ + reinterpret_cast<char*>(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + if (_has_bits_[0 / 32] & 15) { + ZR_(first_value_, num_entries_); + if (has_encoded_data()) { + if (encoded_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + encoded_data_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool RiceDeltaEncoding::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.RiceDeltaEncoding) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int64 first_value = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &first_value_))); + set_has_first_value(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_rice_parameter; + break; + } + + // optional int32 rice_parameter = 2; + case 2: { + if (tag == 16) { + parse_rice_parameter: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &rice_parameter_))); + set_has_rice_parameter(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_num_entries; + break; + } + + // optional int32 num_entries = 3; + case 3: { + if (tag == 24) { + parse_num_entries: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &num_entries_))); + set_has_num_entries(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_encoded_data; + break; + } + + // optional bytes encoded_data = 4; + case 4: { + if (tag == 34) { + parse_encoded_data: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_encoded_data())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.RiceDeltaEncoding) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.RiceDeltaEncoding) + return false; +#undef DO_ +} + +void RiceDeltaEncoding::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.RiceDeltaEncoding) + // optional int64 first_value = 1; + if (has_first_value()) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->first_value(), output); + } + + // optional int32 rice_parameter = 2; + if (has_rice_parameter()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->rice_parameter(), output); + } + + // optional int32 num_entries = 3; + if (has_num_entries()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->num_entries(), output); + } + + // optional bytes encoded_data = 4; + if (has_encoded_data()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 4, this->encoded_data(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.RiceDeltaEncoding) +} + +int RiceDeltaEncoding::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional int64 first_value = 1; + if (has_first_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->first_value()); + } + + // optional int32 rice_parameter = 2; + if (has_rice_parameter()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->rice_parameter()); + } + + // optional int32 num_entries = 3; + if (has_num_entries()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->num_entries()); + } + + // optional bytes encoded_data = 4; + if (has_encoded_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->encoded_data()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RiceDeltaEncoding::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const RiceDeltaEncoding*>(&from)); +} + +void RiceDeltaEncoding::MergeFrom(const RiceDeltaEncoding& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_first_value()) { + set_first_value(from.first_value()); + } + if (from.has_rice_parameter()) { + set_rice_parameter(from.rice_parameter()); + } + if (from.has_num_entries()) { + set_num_entries(from.num_entries()); + } + if (from.has_encoded_data()) { + set_encoded_data(from.encoded_data()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void RiceDeltaEncoding::CopyFrom(const RiceDeltaEncoding& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RiceDeltaEncoding::IsInitialized() const { + + return true; +} + +void RiceDeltaEncoding::Swap(RiceDeltaEncoding* other) { + if (other != this) { + std::swap(first_value_, other->first_value_); + std::swap(rice_parameter_, other->rice_parameter_); + std::swap(num_entries_, other->num_entries_); + std::swap(encoded_data_, other->encoded_data_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string RiceDeltaEncoding::GetTypeName() const { + return "mozilla.safebrowsing.RiceDeltaEncoding"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ThreatEntryMetadata_MetadataEntry::kKeyFieldNumber; +const int ThreatEntryMetadata_MetadataEntry::kValueFieldNumber; +#endif // !_MSC_VER + +ThreatEntryMetadata_MetadataEntry::ThreatEntryMetadata_MetadataEntry() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) +} + +void ThreatEntryMetadata_MetadataEntry::InitAsDefaultInstance() { +} + +ThreatEntryMetadata_MetadataEntry::ThreatEntryMetadata_MetadataEntry(const ThreatEntryMetadata_MetadataEntry& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) +} + +void ThreatEntryMetadata_MetadataEntry::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ThreatEntryMetadata_MetadataEntry::~ThreatEntryMetadata_MetadataEntry() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + SharedDtor(); +} + +void ThreatEntryMetadata_MetadataEntry::SharedDtor() { + if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete key_; + } + if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete value_; + } + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void ThreatEntryMetadata_MetadataEntry::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata_MetadataEntry::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata_MetadataEntry::default_instance_ = NULL; + +ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata_MetadataEntry::New() const { + return new ThreatEntryMetadata_MetadataEntry; +} + +void ThreatEntryMetadata_MetadataEntry::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_key()) { + if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_->clear(); + } + } + if (has_value()) { + if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + value_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ThreatEntryMetadata_MetadataEntry::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional bytes key = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_key())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_value; + break; + } + + // optional bytes value = 2; + case 2: { + if (tag == 18) { + parse_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_value())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + return false; +#undef DO_ +} + +void ThreatEntryMetadata_MetadataEntry::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + // optional bytes key = 1; + if (has_key()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->key(), output); + } + + // optional bytes value = 2; + if (has_value()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->value(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) +} + +int ThreatEntryMetadata_MetadataEntry::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bytes key = 1; + if (has_key()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->key()); + } + + // optional bytes value = 2; + if (has_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->value()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThreatEntryMetadata_MetadataEntry::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ThreatEntryMetadata_MetadataEntry*>(&from)); +} + +void ThreatEntryMetadata_MetadataEntry::MergeFrom(const ThreatEntryMetadata_MetadataEntry& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_key()) { + set_key(from.key()); + } + if (from.has_value()) { + set_value(from.value()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ThreatEntryMetadata_MetadataEntry::CopyFrom(const ThreatEntryMetadata_MetadataEntry& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatEntryMetadata_MetadataEntry::IsInitialized() const { + + return true; +} + +void ThreatEntryMetadata_MetadataEntry::Swap(ThreatEntryMetadata_MetadataEntry* other) { + if (other != this) { + std::swap(key_, other->key_); + std::swap(value_, other->value_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ThreatEntryMetadata_MetadataEntry::GetTypeName() const { + return "mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry"; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int ThreatEntryMetadata::kEntriesFieldNumber; +#endif // !_MSC_VER + +ThreatEntryMetadata::ThreatEntryMetadata() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntryMetadata) +} + +void ThreatEntryMetadata::InitAsDefaultInstance() { +} + +ThreatEntryMetadata::ThreatEntryMetadata(const ThreatEntryMetadata& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntryMetadata) +} + +void ThreatEntryMetadata::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ThreatEntryMetadata::~ThreatEntryMetadata() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntryMetadata) + SharedDtor(); +} + +void ThreatEntryMetadata::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void ThreatEntryMetadata::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ThreatEntryMetadata& ThreatEntryMetadata::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ThreatEntryMetadata* ThreatEntryMetadata::default_instance_ = NULL; + +ThreatEntryMetadata* ThreatEntryMetadata::New() const { + return new ThreatEntryMetadata; +} + +void ThreatEntryMetadata::Clear() { + entries_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ThreatEntryMetadata::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatEntryMetadata) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; + case 1: { + if (tag == 10) { + parse_entries: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_entries())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_entries; + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ThreatEntryMetadata) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatEntryMetadata) + return false; +#undef DO_ +} + +void ThreatEntryMetadata::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatEntryMetadata) + // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; + for (int i = 0; i < this->entries_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->entries(i), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatEntryMetadata) +} + +int ThreatEntryMetadata::ByteSize() const { + int total_size = 0; + + // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; + total_size += 1 * this->entries_size(); + for (int i = 0; i < this->entries_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entries(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThreatEntryMetadata::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ThreatEntryMetadata*>(&from)); +} + +void ThreatEntryMetadata::MergeFrom(const ThreatEntryMetadata& from) { + GOOGLE_CHECK_NE(&from, this); + entries_.MergeFrom(from.entries_); + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ThreatEntryMetadata::CopyFrom(const ThreatEntryMetadata& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatEntryMetadata::IsInitialized() const { + + return true; +} + +void ThreatEntryMetadata::Swap(ThreatEntryMetadata* other) { + if (other != this) { + entries_.Swap(&other->entries_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ThreatEntryMetadata::GetTypeName() const { + return "mozilla.safebrowsing.ThreatEntryMetadata"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ThreatListDescriptor::kThreatTypeFieldNumber; +const int ThreatListDescriptor::kPlatformTypeFieldNumber; +const int ThreatListDescriptor::kThreatEntryTypeFieldNumber; +#endif // !_MSC_VER + +ThreatListDescriptor::ThreatListDescriptor() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatListDescriptor) +} + +void ThreatListDescriptor::InitAsDefaultInstance() { +} + +ThreatListDescriptor::ThreatListDescriptor(const ThreatListDescriptor& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatListDescriptor) +} + +void ThreatListDescriptor::SharedCtor() { + _cached_size_ = 0; + threat_type_ = 0; + platform_type_ = 0; + threat_entry_type_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ThreatListDescriptor::~ThreatListDescriptor() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatListDescriptor) + SharedDtor(); +} + +void ThreatListDescriptor::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void ThreatListDescriptor::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ThreatListDescriptor& ThreatListDescriptor::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ThreatListDescriptor* ThreatListDescriptor::default_instance_ = NULL; + +ThreatListDescriptor* ThreatListDescriptor::New() const { + return new ThreatListDescriptor; +} + +void ThreatListDescriptor::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \ + &reinterpret_cast<ThreatListDescriptor*>(16)->f) - \ + reinterpret_cast<char*>(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(threat_type_, threat_entry_type_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ThreatListDescriptor::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatListDescriptor) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatType_IsValid(value)) { + set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_platform_type; + break; + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + case 2: { + if (tag == 16) { + parse_platform_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::PlatformType_IsValid(value)) { + set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_threat_entry_type; + break; + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; + case 3: { + if (tag == 24) { + parse_threat_entry_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) { + set_threat_entry_type(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value)); + } else { + unknown_fields_stream.WriteVarint32(tag); + unknown_fields_stream.WriteVarint32(value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ThreatListDescriptor) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatListDescriptor) + return false; +#undef DO_ +} + +void ThreatListDescriptor::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatListDescriptor) + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->threat_type(), output); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (has_platform_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->platform_type(), output); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; + if (has_threat_entry_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 3, this->threat_entry_type(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatListDescriptor) +} + +int ThreatListDescriptor::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + if (has_threat_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type()); + } + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + if (has_platform_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type()); + } + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; + if (has_threat_entry_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_entry_type()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThreatListDescriptor::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ThreatListDescriptor*>(&from)); +} + +void ThreatListDescriptor::MergeFrom(const ThreatListDescriptor& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_threat_type()) { + set_threat_type(from.threat_type()); + } + if (from.has_platform_type()) { + set_platform_type(from.platform_type()); + } + if (from.has_threat_entry_type()) { + set_threat_entry_type(from.threat_entry_type()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ThreatListDescriptor::CopyFrom(const ThreatListDescriptor& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ThreatListDescriptor::IsInitialized() const { + + return true; +} + +void ThreatListDescriptor::Swap(ThreatListDescriptor* other) { + if (other != this) { + std::swap(threat_type_, other->threat_type_); + std::swap(platform_type_, other->platform_type_); + std::swap(threat_entry_type_, other->threat_entry_type_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ThreatListDescriptor::GetTypeName() const { + return "mozilla.safebrowsing.ThreatListDescriptor"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ListThreatListsResponse::kThreatListsFieldNumber; +#endif // !_MSC_VER + +ListThreatListsResponse::ListThreatListsResponse() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ListThreatListsResponse) +} + +void ListThreatListsResponse::InitAsDefaultInstance() { +} + +ListThreatListsResponse::ListThreatListsResponse(const ListThreatListsResponse& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ListThreatListsResponse) +} + +void ListThreatListsResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ListThreatListsResponse::~ListThreatListsResponse() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ListThreatListsResponse) + SharedDtor(); +} + +void ListThreatListsResponse::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void ListThreatListsResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ListThreatListsResponse& ListThreatListsResponse::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +ListThreatListsResponse* ListThreatListsResponse::default_instance_ = NULL; + +ListThreatListsResponse* ListThreatListsResponse::New() const { + return new ListThreatListsResponse; +} + +void ListThreatListsResponse::Clear() { + threat_lists_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ListThreatListsResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ListThreatListsResponse) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; + case 1: { + if (tag == 10) { + parse_threat_lists: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_threat_lists())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_threat_lists; + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.ListThreatListsResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ListThreatListsResponse) + return false; +#undef DO_ +} + +void ListThreatListsResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ListThreatListsResponse) + // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; + for (int i = 0; i < this->threat_lists_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->threat_lists(i), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ListThreatListsResponse) +} + +int ListThreatListsResponse::ByteSize() const { + int total_size = 0; + + // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; + total_size += 1 * this->threat_lists_size(); + for (int i = 0; i < this->threat_lists_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->threat_lists(i)); + } + + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ListThreatListsResponse::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ListThreatListsResponse*>(&from)); +} + +void ListThreatListsResponse::MergeFrom(const ListThreatListsResponse& from) { + GOOGLE_CHECK_NE(&from, this); + threat_lists_.MergeFrom(from.threat_lists_); + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ListThreatListsResponse::CopyFrom(const ListThreatListsResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ListThreatListsResponse::IsInitialized() const { + + return true; +} + +void ListThreatListsResponse::Swap(ListThreatListsResponse* other) { + if (other != this) { + threat_lists_.Swap(&other->threat_lists_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ListThreatListsResponse::GetTypeName() const { + return "mozilla.safebrowsing.ListThreatListsResponse"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Duration::kSecondsFieldNumber; +const int Duration::kNanosFieldNumber; +#endif // !_MSC_VER + +Duration::Duration() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:mozilla.safebrowsing.Duration) +} + +void Duration::InitAsDefaultInstance() { +} + +Duration::Duration(const Duration& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.Duration) +} + +void Duration::SharedCtor() { + _cached_size_ = 0; + seconds_ = GOOGLE_LONGLONG(0); + nanos_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Duration::~Duration() { + // @@protoc_insertion_point(destructor:mozilla.safebrowsing.Duration) + SharedDtor(); +} + +void Duration::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void Duration::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const Duration& Duration::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_safebrowsing_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto(); +#endif + return *default_instance_; +} + +Duration* Duration::default_instance_ = NULL; + +Duration* Duration::New() const { + return new Duration; +} + +void Duration::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \ + &reinterpret_cast<Duration*>(16)->f) - \ + reinterpret_cast<char*>(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(seconds_, nanos_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool Duration::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.Duration) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int64 seconds = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &seconds_))); + set_has_seconds(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_nanos; + break; + } + + // optional int32 nanos = 2; + case 2: { + if (tag == 16) { + parse_nanos: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &nanos_))); + set_has_nanos(); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + 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:mozilla.safebrowsing.Duration) + return true; +failure: + // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.Duration) + return false; +#undef DO_ +} + +void Duration::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.Duration) + // optional int64 seconds = 1; + if (has_seconds()) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->seconds(), output); + } + + // optional int32 nanos = 2; + if (has_nanos()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->nanos(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.Duration) +} + +int Duration::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional int64 seconds = 1; + if (has_seconds()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->seconds()); + } + + // optional int32 nanos = 2; + if (has_nanos()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->nanos()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Duration::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const Duration*>(&from)); +} + +void Duration::MergeFrom(const Duration& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_seconds()) { + set_seconds(from.seconds()); + } + if (from.has_nanos()) { + set_nanos(from.nanos()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void Duration::CopyFrom(const Duration& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Duration::IsInitialized() const { + + return true; +} + +void Duration::Swap(Duration* other) { + if (other != this) { + std::swap(seconds_, other->seconds_); + std::swap(nanos_, other->nanos_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string Duration::GetTypeName() const { + return "mozilla.safebrowsing.Duration"; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace safebrowsing +} // namespace mozilla + +// @@protoc_insertion_point(global_scope) diff --git a/toolkit/components/url-classifier/protobuf/safebrowsing.pb.h b/toolkit/components/url-classifier/protobuf/safebrowsing.pb.h new file mode 100644 index 000000000..3c1b436df --- /dev/null +++ b/toolkit/components/url-classifier/protobuf/safebrowsing.pb.h @@ -0,0 +1,6283 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: safebrowsing.proto + +#ifndef PROTOBUF_safebrowsing_2eproto__INCLUDED +#define PROTOBUF_safebrowsing_2eproto__INCLUDED + +#include <string> + +#include <google/protobuf/stubs/common.h> + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include <google/protobuf/generated_message_util.h> +#include <google/protobuf/message_lite.h> +#include <google/protobuf/repeated_field.h> +#include <google/protobuf/extension_set.h> +// @@protoc_insertion_point(includes) + +namespace mozilla { +namespace safebrowsing { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_safebrowsing_2eproto(); +void protobuf_AssignDesc_safebrowsing_2eproto(); +void protobuf_ShutdownFile_safebrowsing_2eproto(); + +class ThreatInfo; +class ThreatMatch; +class FindThreatMatchesRequest; +class FindThreatMatchesResponse; +class FetchThreatListUpdatesRequest; +class FetchThreatListUpdatesRequest_ListUpdateRequest; +class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints; +class FetchThreatListUpdatesResponse; +class FetchThreatListUpdatesResponse_ListUpdateResponse; +class FindFullHashesRequest; +class FindFullHashesResponse; +class ThreatHit; +class ThreatHit_ThreatSource; +class ClientInfo; +class Checksum; +class ThreatEntry; +class ThreatEntrySet; +class RawIndices; +class RawHashes; +class RiceDeltaEncoding; +class ThreatEntryMetadata; +class ThreatEntryMetadata_MetadataEntry; +class ThreatListDescriptor; +class ListThreatListsResponse; +class Duration; + +enum FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType { + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED = 0, + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE = 1, + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE = 2 +}; +bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(int value); +const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED; +const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE; +const int FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX + 1; + +enum ThreatHit_ThreatSourceType { + ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED = 0, + ThreatHit_ThreatSourceType_MATCHING_URL = 1, + ThreatHit_ThreatSourceType_TAB_URL = 2, + ThreatHit_ThreatSourceType_TAB_REDIRECT = 3 +}; +bool ThreatHit_ThreatSourceType_IsValid(int value); +const ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MIN = ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED; +const ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MAX = ThreatHit_ThreatSourceType_TAB_REDIRECT; +const int ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE = ThreatHit_ThreatSourceType_ThreatSourceType_MAX + 1; + +enum ThreatType { + THREAT_TYPE_UNSPECIFIED = 0, + MALWARE_THREAT = 1, + SOCIAL_ENGINEERING_PUBLIC = 2, + UNWANTED_SOFTWARE = 3, + POTENTIALLY_HARMFUL_APPLICATION = 4, + SOCIAL_ENGINEERING = 5, + API_ABUSE = 6 +}; +bool ThreatType_IsValid(int value); +const ThreatType ThreatType_MIN = THREAT_TYPE_UNSPECIFIED; +const ThreatType ThreatType_MAX = API_ABUSE; +const int ThreatType_ARRAYSIZE = ThreatType_MAX + 1; + +enum PlatformType { + PLATFORM_TYPE_UNSPECIFIED = 0, + WINDOWS_PLATFORM = 1, + LINUX_PLATFORM = 2, + ANDROID_PLATFORM = 3, + OSX_PLATFORM = 4, + IOS_PLATFORM = 5, + ANY_PLATFORM = 6, + ALL_PLATFORMS = 7, + CHROME_PLATFORM = 8 +}; +bool PlatformType_IsValid(int value); +const PlatformType PlatformType_MIN = PLATFORM_TYPE_UNSPECIFIED; +const PlatformType PlatformType_MAX = CHROME_PLATFORM; +const int PlatformType_ARRAYSIZE = PlatformType_MAX + 1; + +enum CompressionType { + COMPRESSION_TYPE_UNSPECIFIED = 0, + RAW = 1, + RICE = 2 +}; +bool CompressionType_IsValid(int value); +const CompressionType CompressionType_MIN = COMPRESSION_TYPE_UNSPECIFIED; +const CompressionType CompressionType_MAX = RICE; +const int CompressionType_ARRAYSIZE = CompressionType_MAX + 1; + +enum ThreatEntryType { + THREAT_ENTRY_TYPE_UNSPECIFIED = 0, + URL = 1, + EXECUTABLE = 2, + IP_RANGE = 3 +}; +bool ThreatEntryType_IsValid(int value); +const ThreatEntryType ThreatEntryType_MIN = THREAT_ENTRY_TYPE_UNSPECIFIED; +const ThreatEntryType ThreatEntryType_MAX = IP_RANGE; +const int ThreatEntryType_ARRAYSIZE = ThreatEntryType_MAX + 1; + +// =================================================================== + +class ThreatInfo : public ::google::protobuf::MessageLite { + public: + ThreatInfo(); + virtual ~ThreatInfo(); + + ThreatInfo(const ThreatInfo& from); + + inline ThreatInfo& operator=(const ThreatInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ThreatInfo& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ThreatInfo* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ThreatInfo* other); + + // implements Message ---------------------------------------------- + + ThreatInfo* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ThreatInfo& from); + void MergeFrom(const ThreatInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .mozilla.safebrowsing.ThreatType threat_types = 1; + inline int threat_types_size() const; + inline void clear_threat_types(); + static const int kThreatTypesFieldNumber = 1; + inline ::mozilla::safebrowsing::ThreatType threat_types(int index) const; + inline void set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value); + inline void add_threat_types(::mozilla::safebrowsing::ThreatType value); + inline const ::google::protobuf::RepeatedField<int>& threat_types() const; + inline ::google::protobuf::RepeatedField<int>* mutable_threat_types(); + + // repeated .mozilla.safebrowsing.PlatformType platform_types = 2; + inline int platform_types_size() const; + inline void clear_platform_types(); + static const int kPlatformTypesFieldNumber = 2; + inline ::mozilla::safebrowsing::PlatformType platform_types(int index) const; + inline void set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value); + inline void add_platform_types(::mozilla::safebrowsing::PlatformType value); + inline const ::google::protobuf::RepeatedField<int>& platform_types() const; + inline ::google::protobuf::RepeatedField<int>* mutable_platform_types(); + + // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; + inline int threat_entry_types_size() const; + inline void clear_threat_entry_types(); + static const int kThreatEntryTypesFieldNumber = 4; + inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_types(int index) const; + inline void set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value); + inline void add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value); + inline const ::google::protobuf::RepeatedField<int>& threat_entry_types() const; + inline ::google::protobuf::RepeatedField<int>* mutable_threat_entry_types(); + + // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; + inline int threat_entries_size() const; + inline void clear_threat_entries(); + static const int kThreatEntriesFieldNumber = 3; + inline const ::mozilla::safebrowsing::ThreatEntry& threat_entries(int index) const; + inline ::mozilla::safebrowsing::ThreatEntry* mutable_threat_entries(int index); + inline ::mozilla::safebrowsing::ThreatEntry* add_threat_entries(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >& + threat_entries() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >* + mutable_threat_entries(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatInfo) + private: + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedField<int> threat_types_; + ::google::protobuf::RepeatedField<int> platform_types_; + ::google::protobuf::RepeatedField<int> threat_entry_types_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry > threat_entries_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ThreatInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class ThreatMatch : public ::google::protobuf::MessageLite { + public: + ThreatMatch(); + virtual ~ThreatMatch(); + + ThreatMatch(const ThreatMatch& from); + + inline ThreatMatch& operator=(const ThreatMatch& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ThreatMatch& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ThreatMatch* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ThreatMatch* other); + + // implements Message ---------------------------------------------- + + ThreatMatch* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ThreatMatch& from); + void MergeFrom(const ThreatMatch& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + inline bool has_threat_type() const; + inline void clear_threat_type(); + static const int kThreatTypeFieldNumber = 1; + inline ::mozilla::safebrowsing::ThreatType threat_type() const; + inline void set_threat_type(::mozilla::safebrowsing::ThreatType value); + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + inline bool has_platform_type() const; + inline void clear_platform_type(); + static const int kPlatformTypeFieldNumber = 2; + inline ::mozilla::safebrowsing::PlatformType platform_type() const; + inline void set_platform_type(::mozilla::safebrowsing::PlatformType value); + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; + inline bool has_threat_entry_type() const; + inline void clear_threat_entry_type(); + static const int kThreatEntryTypeFieldNumber = 6; + inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const; + inline void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + + // optional .mozilla.safebrowsing.ThreatEntry threat = 3; + inline bool has_threat() const; + inline void clear_threat(); + static const int kThreatFieldNumber = 3; + inline const ::mozilla::safebrowsing::ThreatEntry& threat() const; + inline ::mozilla::safebrowsing::ThreatEntry* mutable_threat(); + inline ::mozilla::safebrowsing::ThreatEntry* release_threat(); + inline void set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat); + + // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; + inline bool has_threat_entry_metadata() const; + inline void clear_threat_entry_metadata(); + static const int kThreatEntryMetadataFieldNumber = 4; + inline const ::mozilla::safebrowsing::ThreatEntryMetadata& threat_entry_metadata() const; + inline ::mozilla::safebrowsing::ThreatEntryMetadata* mutable_threat_entry_metadata(); + inline ::mozilla::safebrowsing::ThreatEntryMetadata* release_threat_entry_metadata(); + inline void set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata); + + // optional .mozilla.safebrowsing.Duration cache_duration = 5; + inline bool has_cache_duration() const; + inline void clear_cache_duration(); + static const int kCacheDurationFieldNumber = 5; + inline const ::mozilla::safebrowsing::Duration& cache_duration() const; + inline ::mozilla::safebrowsing::Duration* mutable_cache_duration(); + inline ::mozilla::safebrowsing::Duration* release_cache_duration(); + inline void set_allocated_cache_duration(::mozilla::safebrowsing::Duration* cache_duration); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatMatch) + private: + inline void set_has_threat_type(); + inline void clear_has_threat_type(); + inline void set_has_platform_type(); + inline void clear_has_platform_type(); + inline void set_has_threat_entry_type(); + inline void clear_has_threat_entry_type(); + inline void set_has_threat(); + inline void clear_has_threat(); + inline void set_has_threat_entry_metadata(); + inline void clear_has_threat_entry_metadata(); + inline void set_has_cache_duration(); + inline void clear_has_cache_duration(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + int threat_type_; + int platform_type_; + ::mozilla::safebrowsing::ThreatEntry* threat_; + ::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata_; + ::mozilla::safebrowsing::Duration* cache_duration_; + int threat_entry_type_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ThreatMatch* default_instance_; +}; +// ------------------------------------------------------------------- + +class FindThreatMatchesRequest : public ::google::protobuf::MessageLite { + public: + FindThreatMatchesRequest(); + virtual ~FindThreatMatchesRequest(); + + FindThreatMatchesRequest(const FindThreatMatchesRequest& from); + + inline FindThreatMatchesRequest& operator=(const FindThreatMatchesRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const FindThreatMatchesRequest& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const FindThreatMatchesRequest* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(FindThreatMatchesRequest* other); + + // implements Message ---------------------------------------------- + + FindThreatMatchesRequest* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FindThreatMatchesRequest& from); + void MergeFrom(const FindThreatMatchesRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .mozilla.safebrowsing.ClientInfo client = 1; + inline bool has_client() const; + inline void clear_client(); + static const int kClientFieldNumber = 1; + inline const ::mozilla::safebrowsing::ClientInfo& client() const; + inline ::mozilla::safebrowsing::ClientInfo* mutable_client(); + inline ::mozilla::safebrowsing::ClientInfo* release_client(); + inline void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client); + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; + inline bool has_threat_info() const; + inline void clear_threat_info(); + static const int kThreatInfoFieldNumber = 2; + inline const ::mozilla::safebrowsing::ThreatInfo& threat_info() const; + inline ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info(); + inline ::mozilla::safebrowsing::ThreatInfo* release_threat_info(); + inline void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesRequest) + private: + inline void set_has_client(); + inline void clear_has_client(); + inline void set_has_threat_info(); + inline void clear_has_threat_info(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::mozilla::safebrowsing::ClientInfo* client_; + ::mozilla::safebrowsing::ThreatInfo* threat_info_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static FindThreatMatchesRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class FindThreatMatchesResponse : public ::google::protobuf::MessageLite { + public: + FindThreatMatchesResponse(); + virtual ~FindThreatMatchesResponse(); + + FindThreatMatchesResponse(const FindThreatMatchesResponse& from); + + inline FindThreatMatchesResponse& operator=(const FindThreatMatchesResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const FindThreatMatchesResponse& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const FindThreatMatchesResponse* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(FindThreatMatchesResponse* other); + + // implements Message ---------------------------------------------- + + FindThreatMatchesResponse* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FindThreatMatchesResponse& from); + void MergeFrom(const FindThreatMatchesResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + inline int matches_size() const; + inline void clear_matches(); + static const int kMatchesFieldNumber = 1; + inline const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const; + inline ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index); + inline ::mozilla::safebrowsing::ThreatMatch* add_matches(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >& + matches() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >* + mutable_matches(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesResponse) + private: + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch > matches_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static FindThreatMatchesResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints : public ::google::protobuf::MessageLite { + public: + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(); + virtual ~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(); + + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from); + + inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other); + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from); + void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 max_update_entries = 1; + inline bool has_max_update_entries() const; + inline void clear_max_update_entries(); + static const int kMaxUpdateEntriesFieldNumber = 1; + inline ::google::protobuf::int32 max_update_entries() const; + inline void set_max_update_entries(::google::protobuf::int32 value); + + // optional int32 max_database_entries = 2; + inline bool has_max_database_entries() const; + inline void clear_max_database_entries(); + static const int kMaxDatabaseEntriesFieldNumber = 2; + inline ::google::protobuf::int32 max_database_entries() const; + inline void set_max_database_entries(::google::protobuf::int32 value); + + // optional string region = 3; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 3; + inline const ::std::string& region() const; + inline void set_region(const ::std::string& value); + inline void set_region(const char* value); + inline void set_region(const char* value, size_t size); + inline ::std::string* mutable_region(); + inline ::std::string* release_region(); + inline void set_allocated_region(::std::string* region); + + // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; + inline int supported_compressions_size() const; + inline void clear_supported_compressions(); + static const int kSupportedCompressionsFieldNumber = 4; + inline ::mozilla::safebrowsing::CompressionType supported_compressions(int index) const; + inline void set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value); + inline void add_supported_compressions(::mozilla::safebrowsing::CompressionType value); + inline const ::google::protobuf::RepeatedField<int>& supported_compressions() const; + inline ::google::protobuf::RepeatedField<int>* mutable_supported_compressions(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) + private: + inline void set_has_max_update_entries(); + inline void clear_has_max_update_entries(); + inline void set_has_max_database_entries(); + inline void clear_has_max_database_entries(); + inline void set_has_region(); + inline void clear_has_region(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::int32 max_update_entries_; + ::google::protobuf::int32 max_database_entries_; + ::std::string* region_; + ::google::protobuf::RepeatedField<int> supported_compressions_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* default_instance_; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesRequest_ListUpdateRequest : public ::google::protobuf::MessageLite { + public: + FetchThreatListUpdatesRequest_ListUpdateRequest(); + virtual ~FetchThreatListUpdatesRequest_ListUpdateRequest(); + + FetchThreatListUpdatesRequest_ListUpdateRequest(const FetchThreatListUpdatesRequest_ListUpdateRequest& from); + + inline FetchThreatListUpdatesRequest_ListUpdateRequest& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const FetchThreatListUpdatesRequest_ListUpdateRequest& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const FetchThreatListUpdatesRequest_ListUpdateRequest* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest* other); + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesRequest_ListUpdateRequest* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from); + void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints Constraints; + + // accessors ------------------------------------------------------- + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + inline bool has_threat_type() const; + inline void clear_threat_type(); + static const int kThreatTypeFieldNumber = 1; + inline ::mozilla::safebrowsing::ThreatType threat_type() const; + inline void set_threat_type(::mozilla::safebrowsing::ThreatType value); + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + inline bool has_platform_type() const; + inline void clear_platform_type(); + static const int kPlatformTypeFieldNumber = 2; + inline ::mozilla::safebrowsing::PlatformType platform_type() const; + inline void set_platform_type(::mozilla::safebrowsing::PlatformType value); + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; + inline bool has_threat_entry_type() const; + inline void clear_threat_entry_type(); + static const int kThreatEntryTypeFieldNumber = 5; + inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const; + inline void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + + // optional bytes state = 3; + inline bool has_state() const; + inline void clear_state(); + static const int kStateFieldNumber = 3; + inline const ::std::string& state() const; + inline void set_state(const ::std::string& value); + inline void set_state(const char* value); + inline void set_state(const void* value, size_t size); + inline ::std::string* mutable_state(); + inline ::std::string* release_state(); + inline void set_allocated_state(::std::string* state); + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; + inline bool has_constraints() const; + inline void clear_constraints(); + static const int kConstraintsFieldNumber = 4; + inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& constraints() const; + inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* mutable_constraints(); + inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* release_constraints(); + inline void set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) + private: + inline void set_has_threat_type(); + inline void clear_has_threat_type(); + inline void set_has_platform_type(); + inline void clear_has_platform_type(); + inline void set_has_threat_entry_type(); + inline void clear_has_threat_entry_type(); + inline void set_has_state(); + inline void clear_has_state(); + inline void set_has_constraints(); + inline void clear_has_constraints(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + int threat_type_; + int platform_type_; + ::std::string* state_; + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints_; + int threat_entry_type_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static FetchThreatListUpdatesRequest_ListUpdateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesRequest : public ::google::protobuf::MessageLite { + public: + FetchThreatListUpdatesRequest(); + virtual ~FetchThreatListUpdatesRequest(); + + FetchThreatListUpdatesRequest(const FetchThreatListUpdatesRequest& from); + + inline FetchThreatListUpdatesRequest& operator=(const FetchThreatListUpdatesRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const FetchThreatListUpdatesRequest& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const FetchThreatListUpdatesRequest* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(FetchThreatListUpdatesRequest* other); + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesRequest* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FetchThreatListUpdatesRequest& from); + void MergeFrom(const FetchThreatListUpdatesRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef FetchThreatListUpdatesRequest_ListUpdateRequest ListUpdateRequest; + + // accessors ------------------------------------------------------- + + // optional .mozilla.safebrowsing.ClientInfo client = 1; + inline bool has_client() const; + inline void clear_client(); + static const int kClientFieldNumber = 1; + inline const ::mozilla::safebrowsing::ClientInfo& client() const; + inline ::mozilla::safebrowsing::ClientInfo* mutable_client(); + inline ::mozilla::safebrowsing::ClientInfo* release_client(); + inline void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client); + + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; + inline int list_update_requests_size() const; + inline void clear_list_update_requests(); + static const int kListUpdateRequestsFieldNumber = 3; + inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& list_update_requests(int index) const; + inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* mutable_list_update_requests(int index); + inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* add_list_update_requests(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >& + list_update_requests() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >* + mutable_list_update_requests(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest) + private: + inline void set_has_client(); + inline void clear_has_client(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::mozilla::safebrowsing::ClientInfo* client_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest > list_update_requests_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static FetchThreatListUpdatesRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesResponse_ListUpdateResponse : public ::google::protobuf::MessageLite { + public: + FetchThreatListUpdatesResponse_ListUpdateResponse(); + virtual ~FetchThreatListUpdatesResponse_ListUpdateResponse(); + + FetchThreatListUpdatesResponse_ListUpdateResponse(const FetchThreatListUpdatesResponse_ListUpdateResponse& from); + + inline FetchThreatListUpdatesResponse_ListUpdateResponse& operator=(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const FetchThreatListUpdatesResponse_ListUpdateResponse& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const FetchThreatListUpdatesResponse_ListUpdateResponse* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(FetchThreatListUpdatesResponse_ListUpdateResponse* other); + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesResponse_ListUpdateResponse* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from); + void MergeFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType ResponseType; + static const ResponseType RESPONSE_TYPE_UNSPECIFIED = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED; + static const ResponseType PARTIAL_UPDATE = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE; + static const ResponseType FULL_UPDATE = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE; + static inline bool ResponseType_IsValid(int value) { + return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value); + } + static const ResponseType ResponseType_MIN = + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN; + static const ResponseType ResponseType_MAX = + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX; + static const int ResponseType_ARRAYSIZE = + FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE; + + // accessors ------------------------------------------------------- + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + inline bool has_threat_type() const; + inline void clear_threat_type(); + static const int kThreatTypeFieldNumber = 1; + inline ::mozilla::safebrowsing::ThreatType threat_type() const; + inline void set_threat_type(::mozilla::safebrowsing::ThreatType value); + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; + inline bool has_threat_entry_type() const; + inline void clear_threat_entry_type(); + static const int kThreatEntryTypeFieldNumber = 2; + inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const; + inline void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + + // optional .mozilla.safebrowsing.PlatformType platform_type = 3; + inline bool has_platform_type() const; + inline void clear_platform_type(); + static const int kPlatformTypeFieldNumber = 3; + inline ::mozilla::safebrowsing::PlatformType platform_type() const; + inline void set_platform_type(::mozilla::safebrowsing::PlatformType value); + + // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; + inline bool has_response_type() const; + inline void clear_response_type(); + static const int kResponseTypeFieldNumber = 4; + inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType response_type() const; + inline void set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value); + + // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; + inline int additions_size() const; + inline void clear_additions(); + static const int kAdditionsFieldNumber = 5; + inline const ::mozilla::safebrowsing::ThreatEntrySet& additions(int index) const; + inline ::mozilla::safebrowsing::ThreatEntrySet* mutable_additions(int index); + inline ::mozilla::safebrowsing::ThreatEntrySet* add_additions(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >& + additions() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >* + mutable_additions(); + + // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; + inline int removals_size() const; + inline void clear_removals(); + static const int kRemovalsFieldNumber = 6; + inline const ::mozilla::safebrowsing::ThreatEntrySet& removals(int index) const; + inline ::mozilla::safebrowsing::ThreatEntrySet* mutable_removals(int index); + inline ::mozilla::safebrowsing::ThreatEntrySet* add_removals(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >& + removals() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >* + mutable_removals(); + + // optional bytes new_client_state = 7; + inline bool has_new_client_state() const; + inline void clear_new_client_state(); + static const int kNewClientStateFieldNumber = 7; + inline const ::std::string& new_client_state() const; + inline void set_new_client_state(const ::std::string& value); + inline void set_new_client_state(const char* value); + inline void set_new_client_state(const void* value, size_t size); + inline ::std::string* mutable_new_client_state(); + inline ::std::string* release_new_client_state(); + inline void set_allocated_new_client_state(::std::string* new_client_state); + + // optional .mozilla.safebrowsing.Checksum checksum = 8; + inline bool has_checksum() const; + inline void clear_checksum(); + static const int kChecksumFieldNumber = 8; + inline const ::mozilla::safebrowsing::Checksum& checksum() const; + inline ::mozilla::safebrowsing::Checksum* mutable_checksum(); + inline ::mozilla::safebrowsing::Checksum* release_checksum(); + inline void set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) + private: + inline void set_has_threat_type(); + inline void clear_has_threat_type(); + inline void set_has_threat_entry_type(); + inline void clear_has_threat_entry_type(); + inline void set_has_platform_type(); + inline void clear_has_platform_type(); + inline void set_has_response_type(); + inline void clear_has_response_type(); + inline void set_has_new_client_state(); + inline void clear_has_new_client_state(); + inline void set_has_checksum(); + inline void clear_has_checksum(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + int threat_type_; + int threat_entry_type_; + int platform_type_; + int response_type_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > additions_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > removals_; + ::std::string* new_client_state_; + ::mozilla::safebrowsing::Checksum* checksum_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static FetchThreatListUpdatesResponse_ListUpdateResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class FetchThreatListUpdatesResponse : public ::google::protobuf::MessageLite { + public: + FetchThreatListUpdatesResponse(); + virtual ~FetchThreatListUpdatesResponse(); + + FetchThreatListUpdatesResponse(const FetchThreatListUpdatesResponse& from); + + inline FetchThreatListUpdatesResponse& operator=(const FetchThreatListUpdatesResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const FetchThreatListUpdatesResponse& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const FetchThreatListUpdatesResponse* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(FetchThreatListUpdatesResponse* other); + + // implements Message ---------------------------------------------- + + FetchThreatListUpdatesResponse* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FetchThreatListUpdatesResponse& from); + void MergeFrom(const FetchThreatListUpdatesResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef FetchThreatListUpdatesResponse_ListUpdateResponse ListUpdateResponse; + + // accessors ------------------------------------------------------- + + // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; + inline int list_update_responses_size() const; + inline void clear_list_update_responses(); + static const int kListUpdateResponsesFieldNumber = 1; + inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& list_update_responses(int index) const; + inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* mutable_list_update_responses(int index); + inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* add_list_update_responses(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >& + list_update_responses() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >* + mutable_list_update_responses(); + + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + inline bool has_minimum_wait_duration() const; + inline void clear_minimum_wait_duration(); + static const int kMinimumWaitDurationFieldNumber = 2; + inline const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const; + inline ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration(); + inline ::mozilla::safebrowsing::Duration* release_minimum_wait_duration(); + inline void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse) + private: + inline void set_has_minimum_wait_duration(); + inline void clear_has_minimum_wait_duration(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse > list_update_responses_; + ::mozilla::safebrowsing::Duration* minimum_wait_duration_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static FetchThreatListUpdatesResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class FindFullHashesRequest : public ::google::protobuf::MessageLite { + public: + FindFullHashesRequest(); + virtual ~FindFullHashesRequest(); + + FindFullHashesRequest(const FindFullHashesRequest& from); + + inline FindFullHashesRequest& operator=(const FindFullHashesRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const FindFullHashesRequest& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const FindFullHashesRequest* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(FindFullHashesRequest* other); + + // implements Message ---------------------------------------------- + + FindFullHashesRequest* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FindFullHashesRequest& from); + void MergeFrom(const FindFullHashesRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .mozilla.safebrowsing.ClientInfo client = 1; + inline bool has_client() const; + inline void clear_client(); + static const int kClientFieldNumber = 1; + inline const ::mozilla::safebrowsing::ClientInfo& client() const; + inline ::mozilla::safebrowsing::ClientInfo* mutable_client(); + inline ::mozilla::safebrowsing::ClientInfo* release_client(); + inline void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client); + + // repeated bytes client_states = 2; + inline int client_states_size() const; + inline void clear_client_states(); + static const int kClientStatesFieldNumber = 2; + inline const ::std::string& client_states(int index) const; + inline ::std::string* mutable_client_states(int index); + inline void set_client_states(int index, const ::std::string& value); + inline void set_client_states(int index, const char* value); + inline void set_client_states(int index, const void* value, size_t size); + inline ::std::string* add_client_states(); + inline void add_client_states(const ::std::string& value); + inline void add_client_states(const char* value); + inline void add_client_states(const void* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& client_states() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_client_states(); + + // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; + inline bool has_threat_info() const; + inline void clear_threat_info(); + static const int kThreatInfoFieldNumber = 3; + inline const ::mozilla::safebrowsing::ThreatInfo& threat_info() const; + inline ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info(); + inline ::mozilla::safebrowsing::ThreatInfo* release_threat_info(); + inline void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesRequest) + private: + inline void set_has_client(); + inline void clear_has_client(); + inline void set_has_threat_info(); + inline void clear_has_threat_info(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::mozilla::safebrowsing::ClientInfo* client_; + ::google::protobuf::RepeatedPtrField< ::std::string> client_states_; + ::mozilla::safebrowsing::ThreatInfo* threat_info_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static FindFullHashesRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class FindFullHashesResponse : public ::google::protobuf::MessageLite { + public: + FindFullHashesResponse(); + virtual ~FindFullHashesResponse(); + + FindFullHashesResponse(const FindFullHashesResponse& from); + + inline FindFullHashesResponse& operator=(const FindFullHashesResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const FindFullHashesResponse& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const FindFullHashesResponse* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(FindFullHashesResponse* other); + + // implements Message ---------------------------------------------- + + FindFullHashesResponse* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FindFullHashesResponse& from); + void MergeFrom(const FindFullHashesResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .mozilla.safebrowsing.ThreatMatch matches = 1; + inline int matches_size() const; + inline void clear_matches(); + static const int kMatchesFieldNumber = 1; + inline const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const; + inline ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index); + inline ::mozilla::safebrowsing::ThreatMatch* add_matches(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >& + matches() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >* + mutable_matches(); + + // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; + inline bool has_minimum_wait_duration() const; + inline void clear_minimum_wait_duration(); + static const int kMinimumWaitDurationFieldNumber = 2; + inline const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const; + inline ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration(); + inline ::mozilla::safebrowsing::Duration* release_minimum_wait_duration(); + inline void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration); + + // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; + inline bool has_negative_cache_duration() const; + inline void clear_negative_cache_duration(); + static const int kNegativeCacheDurationFieldNumber = 3; + inline const ::mozilla::safebrowsing::Duration& negative_cache_duration() const; + inline ::mozilla::safebrowsing::Duration* mutable_negative_cache_duration(); + inline ::mozilla::safebrowsing::Duration* release_negative_cache_duration(); + inline void set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesResponse) + private: + inline void set_has_minimum_wait_duration(); + inline void clear_has_minimum_wait_duration(); + inline void set_has_negative_cache_duration(); + inline void clear_has_negative_cache_duration(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch > matches_; + ::mozilla::safebrowsing::Duration* minimum_wait_duration_; + ::mozilla::safebrowsing::Duration* negative_cache_duration_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static FindFullHashesResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class ThreatHit_ThreatSource : public ::google::protobuf::MessageLite { + public: + ThreatHit_ThreatSource(); + virtual ~ThreatHit_ThreatSource(); + + ThreatHit_ThreatSource(const ThreatHit_ThreatSource& from); + + inline ThreatHit_ThreatSource& operator=(const ThreatHit_ThreatSource& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ThreatHit_ThreatSource& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ThreatHit_ThreatSource* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ThreatHit_ThreatSource* other); + + // implements Message ---------------------------------------------- + + ThreatHit_ThreatSource* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ThreatHit_ThreatSource& from); + void MergeFrom(const ThreatHit_ThreatSource& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string url = 1; + inline bool has_url() const; + inline void clear_url(); + static const int kUrlFieldNumber = 1; + inline const ::std::string& url() const; + inline void set_url(const ::std::string& value); + inline void set_url(const char* value); + inline void set_url(const char* value, size_t size); + inline ::std::string* mutable_url(); + inline ::std::string* release_url(); + inline void set_allocated_url(::std::string* url); + + // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 2; + inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType type() const; + inline void set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value); + + // optional string remote_ip = 3; + inline bool has_remote_ip() const; + inline void clear_remote_ip(); + static const int kRemoteIpFieldNumber = 3; + inline const ::std::string& remote_ip() const; + inline void set_remote_ip(const ::std::string& value); + inline void set_remote_ip(const char* value); + inline void set_remote_ip(const char* value, size_t size); + inline ::std::string* mutable_remote_ip(); + inline ::std::string* release_remote_ip(); + inline void set_allocated_remote_ip(::std::string* remote_ip); + + // optional string referrer = 4; + inline bool has_referrer() const; + inline void clear_referrer(); + static const int kReferrerFieldNumber = 4; + inline const ::std::string& referrer() const; + inline void set_referrer(const ::std::string& value); + inline void set_referrer(const char* value); + inline void set_referrer(const char* value, size_t size); + inline ::std::string* mutable_referrer(); + inline ::std::string* release_referrer(); + inline void set_allocated_referrer(::std::string* referrer); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit.ThreatSource) + private: + inline void set_has_url(); + inline void clear_has_url(); + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_remote_ip(); + inline void clear_has_remote_ip(); + inline void set_has_referrer(); + inline void clear_has_referrer(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* url_; + ::std::string* remote_ip_; + ::std::string* referrer_; + int type_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ThreatHit_ThreatSource* default_instance_; +}; +// ------------------------------------------------------------------- + +class ThreatHit : public ::google::protobuf::MessageLite { + public: + ThreatHit(); + virtual ~ThreatHit(); + + ThreatHit(const ThreatHit& from); + + inline ThreatHit& operator=(const ThreatHit& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ThreatHit& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ThreatHit* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ThreatHit* other); + + // implements Message ---------------------------------------------- + + ThreatHit* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ThreatHit& from); + void MergeFrom(const ThreatHit& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef ThreatHit_ThreatSource ThreatSource; + + typedef ThreatHit_ThreatSourceType ThreatSourceType; + static const ThreatSourceType THREAT_SOURCE_TYPE_UNSPECIFIED = ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED; + static const ThreatSourceType MATCHING_URL = ThreatHit_ThreatSourceType_MATCHING_URL; + static const ThreatSourceType TAB_URL = ThreatHit_ThreatSourceType_TAB_URL; + static const ThreatSourceType TAB_REDIRECT = ThreatHit_ThreatSourceType_TAB_REDIRECT; + static inline bool ThreatSourceType_IsValid(int value) { + return ThreatHit_ThreatSourceType_IsValid(value); + } + static const ThreatSourceType ThreatSourceType_MIN = + ThreatHit_ThreatSourceType_ThreatSourceType_MIN; + static const ThreatSourceType ThreatSourceType_MAX = + ThreatHit_ThreatSourceType_ThreatSourceType_MAX; + static const int ThreatSourceType_ARRAYSIZE = + ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE; + + // accessors ------------------------------------------------------- + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + inline bool has_threat_type() const; + inline void clear_threat_type(); + static const int kThreatTypeFieldNumber = 1; + inline ::mozilla::safebrowsing::ThreatType threat_type() const; + inline void set_threat_type(::mozilla::safebrowsing::ThreatType value); + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + inline bool has_platform_type() const; + inline void clear_platform_type(); + static const int kPlatformTypeFieldNumber = 2; + inline ::mozilla::safebrowsing::PlatformType platform_type() const; + inline void set_platform_type(::mozilla::safebrowsing::PlatformType value); + + // optional .mozilla.safebrowsing.ThreatEntry entry = 3; + inline bool has_entry() const; + inline void clear_entry(); + static const int kEntryFieldNumber = 3; + inline const ::mozilla::safebrowsing::ThreatEntry& entry() const; + inline ::mozilla::safebrowsing::ThreatEntry* mutable_entry(); + inline ::mozilla::safebrowsing::ThreatEntry* release_entry(); + inline void set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry); + + // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; + inline int resources_size() const; + inline void clear_resources(); + static const int kResourcesFieldNumber = 4; + inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& resources(int index) const; + inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* mutable_resources(int index); + inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* add_resources(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >& + resources() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >* + mutable_resources(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit) + private: + inline void set_has_threat_type(); + inline void clear_has_threat_type(); + inline void set_has_platform_type(); + inline void clear_has_platform_type(); + inline void set_has_entry(); + inline void clear_has_entry(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + int threat_type_; + int platform_type_; + ::mozilla::safebrowsing::ThreatEntry* entry_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource > resources_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ThreatHit* default_instance_; +}; +// ------------------------------------------------------------------- + +class ClientInfo : public ::google::protobuf::MessageLite { + public: + ClientInfo(); + virtual ~ClientInfo(); + + ClientInfo(const ClientInfo& from); + + inline ClientInfo& operator=(const ClientInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ClientInfo& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ClientInfo* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ClientInfo* other); + + // implements Message ---------------------------------------------- + + ClientInfo* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ClientInfo& from); + void MergeFrom(const ClientInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string client_id = 1; + inline bool has_client_id() const; + inline void clear_client_id(); + static const int kClientIdFieldNumber = 1; + inline const ::std::string& client_id() const; + inline void set_client_id(const ::std::string& value); + inline void set_client_id(const char* value); + inline void set_client_id(const char* value, size_t size); + inline ::std::string* mutable_client_id(); + inline ::std::string* release_client_id(); + inline void set_allocated_client_id(::std::string* client_id); + + // optional string client_version = 2; + inline bool has_client_version() const; + inline void clear_client_version(); + static const int kClientVersionFieldNumber = 2; + inline const ::std::string& client_version() const; + inline void set_client_version(const ::std::string& value); + inline void set_client_version(const char* value); + inline void set_client_version(const char* value, size_t size); + inline ::std::string* mutable_client_version(); + inline ::std::string* release_client_version(); + inline void set_allocated_client_version(::std::string* client_version); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ClientInfo) + private: + inline void set_has_client_id(); + inline void clear_has_client_id(); + inline void set_has_client_version(); + inline void clear_has_client_version(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* client_id_; + ::std::string* client_version_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ClientInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class Checksum : public ::google::protobuf::MessageLite { + public: + Checksum(); + virtual ~Checksum(); + + Checksum(const Checksum& from); + + inline Checksum& operator=(const Checksum& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const Checksum& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const Checksum* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(Checksum* other); + + // implements Message ---------------------------------------------- + + Checksum* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const Checksum& from); + void MergeFrom(const Checksum& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bytes sha256 = 1; + inline bool has_sha256() const; + inline void clear_sha256(); + static const int kSha256FieldNumber = 1; + inline const ::std::string& sha256() const; + inline void set_sha256(const ::std::string& value); + inline void set_sha256(const char* value); + inline void set_sha256(const void* value, size_t size); + inline ::std::string* mutable_sha256(); + inline ::std::string* release_sha256(); + inline void set_allocated_sha256(::std::string* sha256); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.Checksum) + private: + inline void set_has_sha256(); + inline void clear_has_sha256(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* sha256_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static Checksum* default_instance_; +}; +// ------------------------------------------------------------------- + +class ThreatEntry : public ::google::protobuf::MessageLite { + public: + ThreatEntry(); + virtual ~ThreatEntry(); + + ThreatEntry(const ThreatEntry& from); + + inline ThreatEntry& operator=(const ThreatEntry& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ThreatEntry& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ThreatEntry* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ThreatEntry* other); + + // implements Message ---------------------------------------------- + + ThreatEntry* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ThreatEntry& from); + void MergeFrom(const ThreatEntry& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bytes hash = 1; + inline bool has_hash() const; + inline void clear_hash(); + static const int kHashFieldNumber = 1; + inline const ::std::string& hash() const; + inline void set_hash(const ::std::string& value); + inline void set_hash(const char* value); + inline void set_hash(const void* value, size_t size); + inline ::std::string* mutable_hash(); + inline ::std::string* release_hash(); + inline void set_allocated_hash(::std::string* hash); + + // optional string url = 2; + inline bool has_url() const; + inline void clear_url(); + static const int kUrlFieldNumber = 2; + inline const ::std::string& url() const; + inline void set_url(const ::std::string& value); + inline void set_url(const char* value); + inline void set_url(const char* value, size_t size); + inline ::std::string* mutable_url(); + inline ::std::string* release_url(); + inline void set_allocated_url(::std::string* url); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntry) + private: + inline void set_has_hash(); + inline void clear_has_hash(); + inline void set_has_url(); + inline void clear_has_url(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* hash_; + ::std::string* url_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ThreatEntry* default_instance_; +}; +// ------------------------------------------------------------------- + +class ThreatEntrySet : public ::google::protobuf::MessageLite { + public: + ThreatEntrySet(); + virtual ~ThreatEntrySet(); + + ThreatEntrySet(const ThreatEntrySet& from); + + inline ThreatEntrySet& operator=(const ThreatEntrySet& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ThreatEntrySet& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ThreatEntrySet* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ThreatEntrySet* other); + + // implements Message ---------------------------------------------- + + ThreatEntrySet* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ThreatEntrySet& from); + void MergeFrom(const ThreatEntrySet& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .mozilla.safebrowsing.CompressionType compression_type = 1; + inline bool has_compression_type() const; + inline void clear_compression_type(); + static const int kCompressionTypeFieldNumber = 1; + inline ::mozilla::safebrowsing::CompressionType compression_type() const; + inline void set_compression_type(::mozilla::safebrowsing::CompressionType value); + + // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; + inline bool has_raw_hashes() const; + inline void clear_raw_hashes(); + static const int kRawHashesFieldNumber = 2; + inline const ::mozilla::safebrowsing::RawHashes& raw_hashes() const; + inline ::mozilla::safebrowsing::RawHashes* mutable_raw_hashes(); + inline ::mozilla::safebrowsing::RawHashes* release_raw_hashes(); + inline void set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes); + + // optional .mozilla.safebrowsing.RawIndices raw_indices = 3; + inline bool has_raw_indices() const; + inline void clear_raw_indices(); + static const int kRawIndicesFieldNumber = 3; + inline const ::mozilla::safebrowsing::RawIndices& raw_indices() const; + inline ::mozilla::safebrowsing::RawIndices* mutable_raw_indices(); + inline ::mozilla::safebrowsing::RawIndices* release_raw_indices(); + inline void set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices); + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; + inline bool has_rice_hashes() const; + inline void clear_rice_hashes(); + static const int kRiceHashesFieldNumber = 4; + inline const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_hashes() const; + inline ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_hashes(); + inline ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_hashes(); + inline void set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes); + + // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; + inline bool has_rice_indices() const; + inline void clear_rice_indices(); + static const int kRiceIndicesFieldNumber = 5; + inline const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_indices() const; + inline ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_indices(); + inline ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_indices(); + inline void set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntrySet) + private: + inline void set_has_compression_type(); + inline void clear_has_compression_type(); + inline void set_has_raw_hashes(); + inline void clear_has_raw_hashes(); + inline void set_has_raw_indices(); + inline void clear_has_raw_indices(); + inline void set_has_rice_hashes(); + inline void clear_has_rice_hashes(); + inline void set_has_rice_indices(); + inline void clear_has_rice_indices(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::mozilla::safebrowsing::RawHashes* raw_hashes_; + ::mozilla::safebrowsing::RawIndices* raw_indices_; + ::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes_; + ::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices_; + int compression_type_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ThreatEntrySet* default_instance_; +}; +// ------------------------------------------------------------------- + +class RawIndices : public ::google::protobuf::MessageLite { + public: + RawIndices(); + virtual ~RawIndices(); + + RawIndices(const RawIndices& from); + + inline RawIndices& operator=(const RawIndices& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const RawIndices& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const RawIndices* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(RawIndices* other); + + // implements Message ---------------------------------------------- + + RawIndices* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const RawIndices& from); + void MergeFrom(const RawIndices& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated int32 indices = 1; + inline int indices_size() const; + inline void clear_indices(); + static const int kIndicesFieldNumber = 1; + inline ::google::protobuf::int32 indices(int index) const; + inline void set_indices(int index, ::google::protobuf::int32 value); + inline void add_indices(::google::protobuf::int32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& + indices() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* + mutable_indices(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawIndices) + private: + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 > indices_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static RawIndices* default_instance_; +}; +// ------------------------------------------------------------------- + +class RawHashes : public ::google::protobuf::MessageLite { + public: + RawHashes(); + virtual ~RawHashes(); + + RawHashes(const RawHashes& from); + + inline RawHashes& operator=(const RawHashes& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const RawHashes& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const RawHashes* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(RawHashes* other); + + // implements Message ---------------------------------------------- + + RawHashes* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const RawHashes& from); + void MergeFrom(const RawHashes& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 prefix_size = 1; + inline bool has_prefix_size() const; + inline void clear_prefix_size(); + static const int kPrefixSizeFieldNumber = 1; + inline ::google::protobuf::int32 prefix_size() const; + inline void set_prefix_size(::google::protobuf::int32 value); + + // optional bytes raw_hashes = 2; + inline bool has_raw_hashes() const; + inline void clear_raw_hashes(); + static const int kRawHashesFieldNumber = 2; + inline const ::std::string& raw_hashes() const; + inline void set_raw_hashes(const ::std::string& value); + inline void set_raw_hashes(const char* value); + inline void set_raw_hashes(const void* value, size_t size); + inline ::std::string* mutable_raw_hashes(); + inline ::std::string* release_raw_hashes(); + inline void set_allocated_raw_hashes(::std::string* raw_hashes); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawHashes) + private: + inline void set_has_prefix_size(); + inline void clear_has_prefix_size(); + inline void set_has_raw_hashes(); + inline void clear_has_raw_hashes(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* raw_hashes_; + ::google::protobuf::int32 prefix_size_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static RawHashes* default_instance_; +}; +// ------------------------------------------------------------------- + +class RiceDeltaEncoding : public ::google::protobuf::MessageLite { + public: + RiceDeltaEncoding(); + virtual ~RiceDeltaEncoding(); + + RiceDeltaEncoding(const RiceDeltaEncoding& from); + + inline RiceDeltaEncoding& operator=(const RiceDeltaEncoding& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const RiceDeltaEncoding& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const RiceDeltaEncoding* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(RiceDeltaEncoding* other); + + // implements Message ---------------------------------------------- + + RiceDeltaEncoding* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const RiceDeltaEncoding& from); + void MergeFrom(const RiceDeltaEncoding& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int64 first_value = 1; + inline bool has_first_value() const; + inline void clear_first_value(); + static const int kFirstValueFieldNumber = 1; + inline ::google::protobuf::int64 first_value() const; + inline void set_first_value(::google::protobuf::int64 value); + + // optional int32 rice_parameter = 2; + inline bool has_rice_parameter() const; + inline void clear_rice_parameter(); + static const int kRiceParameterFieldNumber = 2; + inline ::google::protobuf::int32 rice_parameter() const; + inline void set_rice_parameter(::google::protobuf::int32 value); + + // optional int32 num_entries = 3; + inline bool has_num_entries() const; + inline void clear_num_entries(); + static const int kNumEntriesFieldNumber = 3; + inline ::google::protobuf::int32 num_entries() const; + inline void set_num_entries(::google::protobuf::int32 value); + + // optional bytes encoded_data = 4; + inline bool has_encoded_data() const; + inline void clear_encoded_data(); + static const int kEncodedDataFieldNumber = 4; + inline const ::std::string& encoded_data() const; + inline void set_encoded_data(const ::std::string& value); + inline void set_encoded_data(const char* value); + inline void set_encoded_data(const void* value, size_t size); + inline ::std::string* mutable_encoded_data(); + inline ::std::string* release_encoded_data(); + inline void set_allocated_encoded_data(::std::string* encoded_data); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RiceDeltaEncoding) + private: + inline void set_has_first_value(); + inline void clear_has_first_value(); + inline void set_has_rice_parameter(); + inline void clear_has_rice_parameter(); + inline void set_has_num_entries(); + inline void clear_has_num_entries(); + inline void set_has_encoded_data(); + inline void clear_has_encoded_data(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::int64 first_value_; + ::google::protobuf::int32 rice_parameter_; + ::google::protobuf::int32 num_entries_; + ::std::string* encoded_data_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static RiceDeltaEncoding* default_instance_; +}; +// ------------------------------------------------------------------- + +class ThreatEntryMetadata_MetadataEntry : public ::google::protobuf::MessageLite { + public: + ThreatEntryMetadata_MetadataEntry(); + virtual ~ThreatEntryMetadata_MetadataEntry(); + + ThreatEntryMetadata_MetadataEntry(const ThreatEntryMetadata_MetadataEntry& from); + + inline ThreatEntryMetadata_MetadataEntry& operator=(const ThreatEntryMetadata_MetadataEntry& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ThreatEntryMetadata_MetadataEntry& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ThreatEntryMetadata_MetadataEntry* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ThreatEntryMetadata_MetadataEntry* other); + + // implements Message ---------------------------------------------- + + ThreatEntryMetadata_MetadataEntry* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ThreatEntryMetadata_MetadataEntry& from); + void MergeFrom(const ThreatEntryMetadata_MetadataEntry& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bytes key = 1; + inline bool has_key() const; + inline void clear_key(); + static const int kKeyFieldNumber = 1; + inline const ::std::string& key() const; + inline void set_key(const ::std::string& value); + inline void set_key(const char* value); + inline void set_key(const void* value, size_t size); + inline ::std::string* mutable_key(); + inline ::std::string* release_key(); + inline void set_allocated_key(::std::string* key); + + // optional bytes value = 2; + inline bool has_value() const; + inline void clear_value(); + static const int kValueFieldNumber = 2; + inline const ::std::string& value() const; + inline void set_value(const ::std::string& value); + inline void set_value(const char* value); + inline void set_value(const void* value, size_t size); + inline ::std::string* mutable_value(); + inline ::std::string* release_value(); + inline void set_allocated_value(::std::string* value); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) + private: + inline void set_has_key(); + inline void clear_has_key(); + inline void set_has_value(); + inline void clear_has_value(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* key_; + ::std::string* value_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ThreatEntryMetadata_MetadataEntry* default_instance_; +}; +// ------------------------------------------------------------------- + +class ThreatEntryMetadata : public ::google::protobuf::MessageLite { + public: + ThreatEntryMetadata(); + virtual ~ThreatEntryMetadata(); + + ThreatEntryMetadata(const ThreatEntryMetadata& from); + + inline ThreatEntryMetadata& operator=(const ThreatEntryMetadata& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ThreatEntryMetadata& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ThreatEntryMetadata* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ThreatEntryMetadata* other); + + // implements Message ---------------------------------------------- + + ThreatEntryMetadata* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ThreatEntryMetadata& from); + void MergeFrom(const ThreatEntryMetadata& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef ThreatEntryMetadata_MetadataEntry MetadataEntry; + + // accessors ------------------------------------------------------- + + // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; + inline int entries_size() const; + inline void clear_entries(); + static const int kEntriesFieldNumber = 1; + inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& entries(int index) const; + inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* mutable_entries(int index); + inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* add_entries(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >& + entries() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >* + mutable_entries(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata) + private: + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry > entries_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ThreatEntryMetadata* default_instance_; +}; +// ------------------------------------------------------------------- + +class ThreatListDescriptor : public ::google::protobuf::MessageLite { + public: + ThreatListDescriptor(); + virtual ~ThreatListDescriptor(); + + ThreatListDescriptor(const ThreatListDescriptor& from); + + inline ThreatListDescriptor& operator=(const ThreatListDescriptor& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ThreatListDescriptor& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ThreatListDescriptor* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ThreatListDescriptor* other); + + // implements Message ---------------------------------------------- + + ThreatListDescriptor* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ThreatListDescriptor& from); + void MergeFrom(const ThreatListDescriptor& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .mozilla.safebrowsing.ThreatType threat_type = 1; + inline bool has_threat_type() const; + inline void clear_threat_type(); + static const int kThreatTypeFieldNumber = 1; + inline ::mozilla::safebrowsing::ThreatType threat_type() const; + inline void set_threat_type(::mozilla::safebrowsing::ThreatType value); + + // optional .mozilla.safebrowsing.PlatformType platform_type = 2; + inline bool has_platform_type() const; + inline void clear_platform_type(); + static const int kPlatformTypeFieldNumber = 2; + inline ::mozilla::safebrowsing::PlatformType platform_type() const; + inline void set_platform_type(::mozilla::safebrowsing::PlatformType value); + + // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; + inline bool has_threat_entry_type() const; + inline void clear_threat_entry_type(); + static const int kThreatEntryTypeFieldNumber = 3; + inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const; + inline void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatListDescriptor) + private: + inline void set_has_threat_type(); + inline void clear_has_threat_type(); + inline void set_has_platform_type(); + inline void clear_has_platform_type(); + inline void set_has_threat_entry_type(); + inline void clear_has_threat_entry_type(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + int threat_type_; + int platform_type_; + int threat_entry_type_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ThreatListDescriptor* default_instance_; +}; +// ------------------------------------------------------------------- + +class ListThreatListsResponse : public ::google::protobuf::MessageLite { + public: + ListThreatListsResponse(); + virtual ~ListThreatListsResponse(); + + ListThreatListsResponse(const ListThreatListsResponse& from); + + inline ListThreatListsResponse& operator=(const ListThreatListsResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ListThreatListsResponse& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ListThreatListsResponse* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ListThreatListsResponse* other); + + // implements Message ---------------------------------------------- + + ListThreatListsResponse* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ListThreatListsResponse& from); + void MergeFrom(const ListThreatListsResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; + inline int threat_lists_size() const; + inline void clear_threat_lists(); + static const int kThreatListsFieldNumber = 1; + inline const ::mozilla::safebrowsing::ThreatListDescriptor& threat_lists(int index) const; + inline ::mozilla::safebrowsing::ThreatListDescriptor* mutable_threat_lists(int index); + inline ::mozilla::safebrowsing::ThreatListDescriptor* add_threat_lists(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >& + threat_lists() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >* + mutable_threat_lists(); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ListThreatListsResponse) + private: + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor > threat_lists_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static ListThreatListsResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class Duration : public ::google::protobuf::MessageLite { + public: + Duration(); + virtual ~Duration(); + + Duration(const Duration& from); + + inline Duration& operator=(const Duration& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const Duration& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const Duration* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(Duration* other); + + // implements Message ---------------------------------------------- + + Duration* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const Duration& from); + void MergeFrom(const Duration& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int64 seconds = 1; + inline bool has_seconds() const; + inline void clear_seconds(); + static const int kSecondsFieldNumber = 1; + inline ::google::protobuf::int64 seconds() const; + inline void set_seconds(::google::protobuf::int64 value); + + // optional int32 nanos = 2; + inline bool has_nanos() const; + inline void clear_nanos(); + static const int kNanosFieldNumber = 2; + inline ::google::protobuf::int32 nanos() const; + inline void set_nanos(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.Duration) + private: + inline void set_has_seconds(); + inline void clear_has_seconds(); + inline void set_has_nanos(); + inline void clear_has_nanos(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::int64 seconds_; + ::google::protobuf::int32 nanos_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_safebrowsing_2eproto_impl(); + #else + friend void protobuf_AddDesc_safebrowsing_2eproto(); + #endif + friend void protobuf_AssignDesc_safebrowsing_2eproto(); + friend void protobuf_ShutdownFile_safebrowsing_2eproto(); + + void InitAsDefaultInstance(); + static Duration* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// ThreatInfo + +// repeated .mozilla.safebrowsing.ThreatType threat_types = 1; +inline int ThreatInfo::threat_types_size() const { + return threat_types_.size(); +} +inline void ThreatInfo::clear_threat_types() { + threat_types_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatType ThreatInfo::threat_types(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_types) + return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_types_.Get(index)); +} +inline void ThreatInfo::set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + threat_types_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_types) +} +inline void ThreatInfo::add_threat_types(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + threat_types_.Add(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_types) +} +inline const ::google::protobuf::RepeatedField<int>& +ThreatInfo::threat_types() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_types) + return threat_types_; +} +inline ::google::protobuf::RepeatedField<int>* +ThreatInfo::mutable_threat_types() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_types) + return &threat_types_; +} + +// repeated .mozilla.safebrowsing.PlatformType platform_types = 2; +inline int ThreatInfo::platform_types_size() const { + return platform_types_.size(); +} +inline void ThreatInfo::clear_platform_types() { + platform_types_.Clear(); +} +inline ::mozilla::safebrowsing::PlatformType ThreatInfo::platform_types(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.platform_types) + return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_types_.Get(index)); +} +inline void ThreatInfo::set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + platform_types_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.platform_types) +} +inline void ThreatInfo::add_platform_types(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + platform_types_.Add(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.platform_types) +} +inline const ::google::protobuf::RepeatedField<int>& +ThreatInfo::platform_types() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.platform_types) + return platform_types_; +} +inline ::google::protobuf::RepeatedField<int>* +ThreatInfo::mutable_platform_types() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.platform_types) + return &platform_types_; +} + +// repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4; +inline int ThreatInfo::threat_entry_types_size() const { + return threat_entry_types_.size(); +} +inline void ThreatInfo::clear_threat_entry_types() { + threat_entry_types_.Clear(); +} +inline ::mozilla::safebrowsing::ThreatEntryType ThreatInfo::threat_entry_types(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entry_types) + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_types_.Get(index)); +} +inline void ThreatInfo::set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + threat_entry_types_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_entry_types) +} +inline void ThreatInfo::add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + threat_entry_types_.Add(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entry_types) +} +inline const ::google::protobuf::RepeatedField<int>& +ThreatInfo::threat_entry_types() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types) + return threat_entry_types_; +} +inline ::google::protobuf::RepeatedField<int>* +ThreatInfo::mutable_threat_entry_types() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types) + return &threat_entry_types_; +} + +// repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3; +inline int ThreatInfo::threat_entries_size() const { + return threat_entries_.size(); +} +inline void ThreatInfo::clear_threat_entries() { + threat_entries_.Clear(); +} +inline const ::mozilla::safebrowsing::ThreatEntry& ThreatInfo::threat_entries(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entries) + return threat_entries_.Get(index); +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::mutable_threat_entries(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatInfo.threat_entries) + return threat_entries_.Mutable(index); +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::add_threat_entries() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entries) + return threat_entries_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >& +ThreatInfo::threat_entries() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entries) + return threat_entries_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >* +ThreatInfo::mutable_threat_entries() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entries) + return &threat_entries_; +} + +// ------------------------------------------------------------------- + +// ThreatMatch + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool ThreatMatch::has_threat_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ThreatMatch::set_has_threat_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void ThreatMatch::clear_has_threat_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ThreatMatch::clear_threat_type() { + threat_type_ = 0; + clear_has_threat_type(); +} +inline ::mozilla::safebrowsing::ThreatType ThreatMatch::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_type) + return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_); +} +inline void ThreatMatch::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + set_has_threat_type(); + threat_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 2; +inline bool ThreatMatch::has_platform_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ThreatMatch::set_has_platform_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void ThreatMatch::clear_has_platform_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ThreatMatch::clear_platform_type() { + platform_type_ = 0; + clear_has_platform_type(); +} +inline ::mozilla::safebrowsing::PlatformType ThreatMatch::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.platform_type) + return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_); +} +inline void ThreatMatch::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + set_has_platform_type(); + platform_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.platform_type) +} + +// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6; +inline bool ThreatMatch::has_threat_entry_type() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ThreatMatch::set_has_threat_entry_type() { + _has_bits_[0] |= 0x00000004u; +} +inline void ThreatMatch::clear_has_threat_entry_type() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ThreatMatch::clear_threat_entry_type() { + threat_entry_type_ = 0; + clear_has_threat_entry_type(); +} +inline ::mozilla::safebrowsing::ThreatEntryType ThreatMatch::threat_entry_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_type) + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_); +} +inline void ThreatMatch::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + set_has_threat_entry_type(); + threat_entry_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_entry_type) +} + +// optional .mozilla.safebrowsing.ThreatEntry threat = 3; +inline bool ThreatMatch::has_threat() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ThreatMatch::set_has_threat() { + _has_bits_[0] |= 0x00000008u; +} +inline void ThreatMatch::clear_has_threat() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ThreatMatch::clear_threat() { + if (threat_ != NULL) threat_->::mozilla::safebrowsing::ThreatEntry::Clear(); + clear_has_threat(); +} +inline const ::mozilla::safebrowsing::ThreatEntry& ThreatMatch::threat() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return threat_ != NULL ? *threat_ : *default_instance().threat_; +#else + return threat_ != NULL ? *threat_ : *default_instance_->threat_; +#endif +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::mutable_threat() { + set_has_threat(); + if (threat_ == NULL) threat_ = new ::mozilla::safebrowsing::ThreatEntry; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat) + return threat_; +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::release_threat() { + clear_has_threat(); + ::mozilla::safebrowsing::ThreatEntry* temp = threat_; + threat_ = NULL; + return temp; +} +inline void ThreatMatch::set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat) { + delete threat_; + threat_ = threat; + if (threat) { + set_has_threat(); + } else { + clear_has_threat(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat) +} + +// optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4; +inline bool ThreatMatch::has_threat_entry_metadata() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ThreatMatch::set_has_threat_entry_metadata() { + _has_bits_[0] |= 0x00000010u; +} +inline void ThreatMatch::clear_has_threat_entry_metadata() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ThreatMatch::clear_threat_entry_metadata() { + if (threat_entry_metadata_ != NULL) threat_entry_metadata_->::mozilla::safebrowsing::ThreatEntryMetadata::Clear(); + clear_has_threat_entry_metadata(); +} +inline const ::mozilla::safebrowsing::ThreatEntryMetadata& ThreatMatch::threat_entry_metadata() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return threat_entry_metadata_ != NULL ? *threat_entry_metadata_ : *default_instance().threat_entry_metadata_; +#else + return threat_entry_metadata_ != NULL ? *threat_entry_metadata_ : *default_instance_->threat_entry_metadata_; +#endif +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::mutable_threat_entry_metadata() { + set_has_threat_entry_metadata(); + if (threat_entry_metadata_ == NULL) threat_entry_metadata_ = new ::mozilla::safebrowsing::ThreatEntryMetadata; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata) + return threat_entry_metadata_; +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::release_threat_entry_metadata() { + clear_has_threat_entry_metadata(); + ::mozilla::safebrowsing::ThreatEntryMetadata* temp = threat_entry_metadata_; + threat_entry_metadata_ = NULL; + return temp; +} +inline void ThreatMatch::set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata) { + delete threat_entry_metadata_; + threat_entry_metadata_ = threat_entry_metadata; + if (threat_entry_metadata) { + set_has_threat_entry_metadata(); + } else { + clear_has_threat_entry_metadata(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata) +} + +// optional .mozilla.safebrowsing.Duration cache_duration = 5; +inline bool ThreatMatch::has_cache_duration() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void ThreatMatch::set_has_cache_duration() { + _has_bits_[0] |= 0x00000020u; +} +inline void ThreatMatch::clear_has_cache_duration() { + _has_bits_[0] &= ~0x00000020u; +} +inline void ThreatMatch::clear_cache_duration() { + if (cache_duration_ != NULL) cache_duration_->::mozilla::safebrowsing::Duration::Clear(); + clear_has_cache_duration(); +} +inline const ::mozilla::safebrowsing::Duration& ThreatMatch::cache_duration() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.cache_duration) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return cache_duration_ != NULL ? *cache_duration_ : *default_instance().cache_duration_; +#else + return cache_duration_ != NULL ? *cache_duration_ : *default_instance_->cache_duration_; +#endif +} +inline ::mozilla::safebrowsing::Duration* ThreatMatch::mutable_cache_duration() { + set_has_cache_duration(); + if (cache_duration_ == NULL) cache_duration_ = new ::mozilla::safebrowsing::Duration; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.cache_duration) + return cache_duration_; +} +inline ::mozilla::safebrowsing::Duration* ThreatMatch::release_cache_duration() { + clear_has_cache_duration(); + ::mozilla::safebrowsing::Duration* temp = cache_duration_; + cache_duration_ = NULL; + return temp; +} +inline void ThreatMatch::set_allocated_cache_duration(::mozilla::safebrowsing::Duration* cache_duration) { + delete cache_duration_; + cache_duration_ = cache_duration; + if (cache_duration) { + set_has_cache_duration(); + } else { + clear_has_cache_duration(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.cache_duration) +} + +// ------------------------------------------------------------------- + +// FindThreatMatchesRequest + +// optional .mozilla.safebrowsing.ClientInfo client = 1; +inline bool FindThreatMatchesRequest::has_client() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FindThreatMatchesRequest::set_has_client() { + _has_bits_[0] |= 0x00000001u; +} +inline void FindThreatMatchesRequest::clear_has_client() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FindThreatMatchesRequest::clear_client() { + if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear(); + clear_has_client(); +} +inline const ::mozilla::safebrowsing::ClientInfo& FindThreatMatchesRequest::client() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.client) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return client_ != NULL ? *client_ : *default_instance().client_; +#else + return client_ != NULL ? *client_ : *default_instance_->client_; +#endif +} +inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::mutable_client() { + set_has_client(); + if (client_ == NULL) client_ = new ::mozilla::safebrowsing::ClientInfo; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.client) + return client_; +} +inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::release_client() { + clear_has_client(); + ::mozilla::safebrowsing::ClientInfo* temp = client_; + client_ = NULL; + return temp; +} +inline void FindThreatMatchesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) { + delete client_; + client_ = client; + if (client) { + set_has_client(); + } else { + clear_has_client(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.client) +} + +// optional .mozilla.safebrowsing.ThreatInfo threat_info = 2; +inline bool FindThreatMatchesRequest::has_threat_info() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FindThreatMatchesRequest::set_has_threat_info() { + _has_bits_[0] |= 0x00000002u; +} +inline void FindThreatMatchesRequest::clear_has_threat_info() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FindThreatMatchesRequest::clear_threat_info() { + if (threat_info_ != NULL) threat_info_->::mozilla::safebrowsing::ThreatInfo::Clear(); + clear_has_threat_info(); +} +inline const ::mozilla::safebrowsing::ThreatInfo& FindThreatMatchesRequest::threat_info() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return threat_info_ != NULL ? *threat_info_ : *default_instance().threat_info_; +#else + return threat_info_ != NULL ? *threat_info_ : *default_instance_->threat_info_; +#endif +} +inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::mutable_threat_info() { + set_has_threat_info(); + if (threat_info_ == NULL) threat_info_ = new ::mozilla::safebrowsing::ThreatInfo; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info) + return threat_info_; +} +inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::release_threat_info() { + clear_has_threat_info(); + ::mozilla::safebrowsing::ThreatInfo* temp = threat_info_; + threat_info_ = NULL; + return temp; +} +inline void FindThreatMatchesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) { + delete threat_info_; + threat_info_ = threat_info; + if (threat_info) { + set_has_threat_info(); + } else { + clear_has_threat_info(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info) +} + +// ------------------------------------------------------------------- + +// FindThreatMatchesResponse + +// repeated .mozilla.safebrowsing.ThreatMatch matches = 1; +inline int FindThreatMatchesResponse::matches_size() const { + return matches_.size(); +} +inline void FindThreatMatchesResponse::clear_matches() { + matches_.Clear(); +} +inline const ::mozilla::safebrowsing::ThreatMatch& FindThreatMatchesResponse::matches(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return matches_.Get(index); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::mutable_matches(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return matches_.Mutable(index); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::add_matches() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return matches_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >& +FindThreatMatchesResponse::matches() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return matches_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >* +FindThreatMatchesResponse::mutable_matches() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches) + return &matches_; +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints + +// optional int32 max_update_entries = 1; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_update_entries() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_has_max_update_entries() { + _has_bits_[0] |= 0x00000001u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_has_max_update_entries() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_update_entries() { + max_update_entries_ = 0; + clear_has_max_update_entries(); +} +inline ::google::protobuf::int32 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_update_entries() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries) + return max_update_entries_; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_update_entries(::google::protobuf::int32 value) { + set_has_max_update_entries(); + max_update_entries_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries) +} + +// optional int32 max_database_entries = 2; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_database_entries() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_has_max_database_entries() { + _has_bits_[0] |= 0x00000002u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_has_max_database_entries() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_database_entries() { + max_database_entries_ = 0; + clear_has_max_database_entries(); +} +inline ::google::protobuf::int32 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_database_entries() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries) + return max_database_entries_; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_database_entries(::google::protobuf::int32 value) { + set_has_max_database_entries(); + max_database_entries_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries) +} + +// optional string region = 3; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_region() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_has_region() { + _has_bits_[0] |= 0x00000004u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_has_region() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_region() { + if (region_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + region_->clear(); + } + clear_has_region(); +} +inline const ::std::string& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::region() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) + return *region_; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(const ::std::string& value) { + set_has_region(); + if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + region_ = new ::std::string; + } + region_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(const char* value) { + set_has_region(); + if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + region_ = new ::std::string; + } + region_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(const char* value, size_t size) { + set_has_region(); + if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + region_ = new ::std::string; + } + region_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) +} +inline ::std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_region() { + set_has_region(); + if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + region_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) + return region_; +} +inline ::std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::release_region() { + clear_has_region(); + if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = region_; + region_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_allocated_region(::std::string* region) { + if (region_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete region_; + } + if (region) { + set_has_region(); + region_ = region; + } else { + clear_has_region(); + region_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region) +} + +// repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4; +inline int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions_size() const { + return supported_compressions_.size(); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_supported_compressions() { + supported_compressions_.Clear(); +} +inline ::mozilla::safebrowsing::CompressionType FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) + return static_cast< ::mozilla::safebrowsing::CompressionType >(supported_compressions_.Get(index)); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value) { + assert(::mozilla::safebrowsing::CompressionType_IsValid(value)); + supported_compressions_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::add_supported_compressions(::mozilla::safebrowsing::CompressionType value) { + assert(::mozilla::safebrowsing::CompressionType_IsValid(value)); + supported_compressions_.Add(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) +} +inline const ::google::protobuf::RepeatedField<int>& +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) + return supported_compressions_; +} +inline ::google::protobuf::RepeatedField<int>* +FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_supported_compressions() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions) + return &supported_compressions_; +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesRequest_ListUpdateRequest + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_threat_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_threat_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_type() { + threat_type_ = 0; + clear_has_threat_type(); +} +inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type) + return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + set_has_threat_type(); + threat_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 2; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_platform_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_platform_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_platform_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_platform_type() { + platform_type_ = 0; + clear_has_platform_type(); +} +inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesRequest_ListUpdateRequest::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type) + return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + set_has_platform_type(); + platform_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type) +} + +// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_entry_type() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_threat_entry_type() { + _has_bits_[0] |= 0x00000004u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_threat_entry_type() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_entry_type() { + threat_entry_type_ = 0; + clear_has_threat_entry_type(); +} +inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_entry_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type) + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_); +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + set_has_threat_entry_type(); + threat_entry_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type) +} + +// optional bytes state = 3; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_state() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_state() { + _has_bits_[0] |= 0x00000008u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_state() { + _has_bits_[0] &= ~0x00000008u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_state() { + if (state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + state_->clear(); + } + clear_has_state(); +} +inline const ::std::string& FetchThreatListUpdatesRequest_ListUpdateRequest::state() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) + return *state_; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(const ::std::string& value) { + set_has_state(); + if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + state_ = new ::std::string; + } + state_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(const char* value) { + set_has_state(); + if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + state_ = new ::std::string; + } + state_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(const void* value, size_t size) { + set_has_state(); + if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + state_ = new ::std::string; + } + state_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) +} +inline ::std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_state() { + set_has_state(); + if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + state_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) + return state_; +} +inline ::std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::release_state() { + clear_has_state(); + if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = state_; + state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_state(::std::string* state) { + if (state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete state_; + } + if (state) { + set_has_state(); + state_ = state; + } else { + clear_has_state(); + state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state) +} + +// optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4; +inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_constraints() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_constraints() { + _has_bits_[0] |= 0x00000010u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_constraints() { + _has_bits_[0] &= ~0x00000010u; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_constraints() { + if (constraints_ != NULL) constraints_->::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Clear(); + clear_has_constraints(); +} +inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest::constraints() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return constraints_ != NULL ? *constraints_ : *default_instance().constraints_; +#else + return constraints_ != NULL ? *constraints_ : *default_instance_->constraints_; +#endif +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_constraints() { + set_has_constraints(); + if (constraints_ == NULL) constraints_ = new ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints) + return constraints_; +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::release_constraints() { + clear_has_constraints(); + ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* temp = constraints_; + constraints_ = NULL; + return temp; +} +inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints) { + delete constraints_; + constraints_ = constraints; + if (constraints) { + set_has_constraints(); + } else { + clear_has_constraints(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints) +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesRequest + +// optional .mozilla.safebrowsing.ClientInfo client = 1; +inline bool FetchThreatListUpdatesRequest::has_client() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FetchThreatListUpdatesRequest::set_has_client() { + _has_bits_[0] |= 0x00000001u; +} +inline void FetchThreatListUpdatesRequest::clear_has_client() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FetchThreatListUpdatesRequest::clear_client() { + if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear(); + clear_has_client(); +} +inline const ::mozilla::safebrowsing::ClientInfo& FetchThreatListUpdatesRequest::client() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return client_ != NULL ? *client_ : *default_instance().client_; +#else + return client_ != NULL ? *client_ : *default_instance_->client_; +#endif +} +inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::mutable_client() { + set_has_client(); + if (client_ == NULL) client_ = new ::mozilla::safebrowsing::ClientInfo; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client) + return client_; +} +inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::release_client() { + clear_has_client(); + ::mozilla::safebrowsing::ClientInfo* temp = client_; + client_ = NULL; + return temp; +} +inline void FetchThreatListUpdatesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) { + delete client_; + client_ = client; + if (client) { + set_has_client(); + } else { + clear_has_client(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client) +} + +// repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3; +inline int FetchThreatListUpdatesRequest::list_update_requests_size() const { + return list_update_requests_.size(); +} +inline void FetchThreatListUpdatesRequest::clear_list_update_requests() { + list_update_requests_.Clear(); +} +inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest::list_update_requests(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return list_update_requests_.Get(index); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::mutable_list_update_requests(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return list_update_requests_.Mutable(index); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::add_list_update_requests() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return list_update_requests_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >& +FetchThreatListUpdatesRequest::list_update_requests() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return list_update_requests_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >* +FetchThreatListUpdatesRequest::mutable_list_update_requests() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests) + return &list_update_requests_; +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesResponse_ListUpdateResponse + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_threat_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_threat_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_type() { + threat_type_ = 0; + clear_has_threat_type(); +} +inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type) + return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + set_has_threat_type(); + threat_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type) +} + +// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_entry_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_threat_entry_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_threat_entry_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_entry_type() { + threat_entry_type_ = 0; + clear_has_threat_entry_type(); +} +inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_entry_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type) + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + set_has_threat_entry_type(); + threat_entry_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 3; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_platform_type() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_platform_type() { + _has_bits_[0] |= 0x00000004u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_platform_type() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_platform_type() { + platform_type_ = 0; + clear_has_platform_type(); +} +inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesResponse_ListUpdateResponse::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type) + return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + set_has_platform_type(); + platform_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type) +} + +// optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_response_type() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_response_type() { + _has_bits_[0] |= 0x00000008u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_response_type() { + _has_bits_[0] &= ~0x00000008u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_response_type() { + response_type_ = 0; + clear_has_response_type(); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::response_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type) + return static_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType >(response_type_); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value) { + assert(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value)); + set_has_response_type(); + response_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type) +} + +// repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5; +inline int FetchThreatListUpdatesResponse_ListUpdateResponse::additions_size() const { + return additions_.size(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_additions() { + additions_.Clear(); +} +inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::additions(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return additions_.Get(index); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return additions_.Mutable(index); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_additions() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return additions_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >& +FetchThreatListUpdatesResponse_ListUpdateResponse::additions() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return additions_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >* +FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions) + return &additions_; +} + +// repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6; +inline int FetchThreatListUpdatesResponse_ListUpdateResponse::removals_size() const { + return removals_.size(); +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_removals() { + removals_.Clear(); +} +inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::removals(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return removals_.Get(index); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return removals_.Mutable(index); +} +inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_removals() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return removals_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >& +FetchThreatListUpdatesResponse_ListUpdateResponse::removals() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return removals_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >* +FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals) + return &removals_; +} + +// optional bytes new_client_state = 7; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_new_client_state() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_new_client_state() { + _has_bits_[0] |= 0x00000040u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_new_client_state() { + _has_bits_[0] &= ~0x00000040u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_new_client_state() { + if (new_client_state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + new_client_state_->clear(); + } + clear_has_new_client_state(); +} +inline const ::std::string& FetchThreatListUpdatesResponse_ListUpdateResponse::new_client_state() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) + return *new_client_state_; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(const ::std::string& value) { + set_has_new_client_state(); + if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + new_client_state_ = new ::std::string; + } + new_client_state_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(const char* value) { + set_has_new_client_state(); + if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + new_client_state_ = new ::std::string; + } + new_client_state_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(const void* value, size_t size) { + set_has_new_client_state(); + if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + new_client_state_ = new ::std::string; + } + new_client_state_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) +} +inline ::std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_new_client_state() { + set_has_new_client_state(); + if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + new_client_state_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) + return new_client_state_; +} +inline ::std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::release_new_client_state() { + clear_has_new_client_state(); + if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = new_client_state_; + new_client_state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_new_client_state(::std::string* new_client_state) { + if (new_client_state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete new_client_state_; + } + if (new_client_state) { + set_has_new_client_state(); + new_client_state_ = new_client_state; + } else { + clear_has_new_client_state(); + new_client_state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state) +} + +// optional .mozilla.safebrowsing.Checksum checksum = 8; +inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_checksum() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_checksum() { + _has_bits_[0] |= 0x00000080u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_checksum() { + _has_bits_[0] &= ~0x00000080u; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_checksum() { + if (checksum_ != NULL) checksum_->::mozilla::safebrowsing::Checksum::Clear(); + clear_has_checksum(); +} +inline const ::mozilla::safebrowsing::Checksum& FetchThreatListUpdatesResponse_ListUpdateResponse::checksum() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return checksum_ != NULL ? *checksum_ : *default_instance().checksum_; +#else + return checksum_ != NULL ? *checksum_ : *default_instance_->checksum_; +#endif +} +inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_checksum() { + set_has_checksum(); + if (checksum_ == NULL) checksum_ = new ::mozilla::safebrowsing::Checksum; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum) + return checksum_; +} +inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::release_checksum() { + clear_has_checksum(); + ::mozilla::safebrowsing::Checksum* temp = checksum_; + checksum_ = NULL; + return temp; +} +inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum) { + delete checksum_; + checksum_ = checksum; + if (checksum) { + set_has_checksum(); + } else { + clear_has_checksum(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum) +} + +// ------------------------------------------------------------------- + +// FetchThreatListUpdatesResponse + +// repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1; +inline int FetchThreatListUpdatesResponse::list_update_responses_size() const { + return list_update_responses_.size(); +} +inline void FetchThreatListUpdatesResponse::clear_list_update_responses() { + list_update_responses_.Clear(); +} +inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse::list_update_responses(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return list_update_responses_.Get(index); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::mutable_list_update_responses(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return list_update_responses_.Mutable(index); +} +inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::add_list_update_responses() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return list_update_responses_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >& +FetchThreatListUpdatesResponse::list_update_responses() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return list_update_responses_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >* +FetchThreatListUpdatesResponse::mutable_list_update_responses() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses) + return &list_update_responses_; +} + +// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; +inline bool FetchThreatListUpdatesResponse::has_minimum_wait_duration() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FetchThreatListUpdatesResponse::set_has_minimum_wait_duration() { + _has_bits_[0] |= 0x00000002u; +} +inline void FetchThreatListUpdatesResponse::clear_has_minimum_wait_duration() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FetchThreatListUpdatesResponse::clear_minimum_wait_duration() { + if (minimum_wait_duration_ != NULL) minimum_wait_duration_->::mozilla::safebrowsing::Duration::Clear(); + clear_has_minimum_wait_duration(); +} +inline const ::mozilla::safebrowsing::Duration& FetchThreatListUpdatesResponse::minimum_wait_duration() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return minimum_wait_duration_ != NULL ? *minimum_wait_duration_ : *default_instance().minimum_wait_duration_; +#else + return minimum_wait_duration_ != NULL ? *minimum_wait_duration_ : *default_instance_->minimum_wait_duration_; +#endif +} +inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::mutable_minimum_wait_duration() { + set_has_minimum_wait_duration(); + if (minimum_wait_duration_ == NULL) minimum_wait_duration_ = new ::mozilla::safebrowsing::Duration; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration) + return minimum_wait_duration_; +} +inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::release_minimum_wait_duration() { + clear_has_minimum_wait_duration(); + ::mozilla::safebrowsing::Duration* temp = minimum_wait_duration_; + minimum_wait_duration_ = NULL; + return temp; +} +inline void FetchThreatListUpdatesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration) { + delete minimum_wait_duration_; + minimum_wait_duration_ = minimum_wait_duration; + if (minimum_wait_duration) { + set_has_minimum_wait_duration(); + } else { + clear_has_minimum_wait_duration(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration) +} + +// ------------------------------------------------------------------- + +// FindFullHashesRequest + +// optional .mozilla.safebrowsing.ClientInfo client = 1; +inline bool FindFullHashesRequest::has_client() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FindFullHashesRequest::set_has_client() { + _has_bits_[0] |= 0x00000001u; +} +inline void FindFullHashesRequest::clear_has_client() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FindFullHashesRequest::clear_client() { + if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear(); + clear_has_client(); +} +inline const ::mozilla::safebrowsing::ClientInfo& FindFullHashesRequest::client() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return client_ != NULL ? *client_ : *default_instance().client_; +#else + return client_ != NULL ? *client_ : *default_instance_->client_; +#endif +} +inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::mutable_client() { + set_has_client(); + if (client_ == NULL) client_ = new ::mozilla::safebrowsing::ClientInfo; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client) + return client_; +} +inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::release_client() { + clear_has_client(); + ::mozilla::safebrowsing::ClientInfo* temp = client_; + client_ = NULL; + return temp; +} +inline void FindFullHashesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) { + delete client_; + client_ = client; + if (client) { + set_has_client(); + } else { + clear_has_client(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.client) +} + +// repeated bytes client_states = 2; +inline int FindFullHashesRequest::client_states_size() const { + return client_states_.size(); +} +inline void FindFullHashesRequest::clear_client_states() { + client_states_.Clear(); +} +inline const ::std::string& FindFullHashesRequest::client_states(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client_states) + return client_states_.Get(index); +} +inline ::std::string* FindFullHashesRequest::mutable_client_states(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client_states) + return client_states_.Mutable(index); +} +inline void FindFullHashesRequest::set_client_states(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FindFullHashesRequest.client_states) + client_states_.Mutable(index)->assign(value); +} +inline void FindFullHashesRequest::set_client_states(int index, const char* value) { + client_states_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline void FindFullHashesRequest::set_client_states(int index, const void* value, size_t size) { + client_states_.Mutable(index)->assign( + reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline ::std::string* FindFullHashesRequest::add_client_states() { + return client_states_.Add(); +} +inline void FindFullHashesRequest::add_client_states(const ::std::string& value) { + client_states_.Add()->assign(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline void FindFullHashesRequest::add_client_states(const char* value) { + client_states_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline void FindFullHashesRequest::add_client_states(const void* value, size_t size) { + client_states_.Add()->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +FindFullHashesRequest::client_states() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesRequest.client_states) + return client_states_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +FindFullHashesRequest::mutable_client_states() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesRequest.client_states) + return &client_states_; +} + +// optional .mozilla.safebrowsing.ThreatInfo threat_info = 3; +inline bool FindFullHashesRequest::has_threat_info() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FindFullHashesRequest::set_has_threat_info() { + _has_bits_[0] |= 0x00000004u; +} +inline void FindFullHashesRequest::clear_has_threat_info() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FindFullHashesRequest::clear_threat_info() { + if (threat_info_ != NULL) threat_info_->::mozilla::safebrowsing::ThreatInfo::Clear(); + clear_has_threat_info(); +} +inline const ::mozilla::safebrowsing::ThreatInfo& FindFullHashesRequest::threat_info() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.threat_info) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return threat_info_ != NULL ? *threat_info_ : *default_instance().threat_info_; +#else + return threat_info_ != NULL ? *threat_info_ : *default_instance_->threat_info_; +#endif +} +inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::mutable_threat_info() { + set_has_threat_info(); + if (threat_info_ == NULL) threat_info_ = new ::mozilla::safebrowsing::ThreatInfo; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.threat_info) + return threat_info_; +} +inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::release_threat_info() { + clear_has_threat_info(); + ::mozilla::safebrowsing::ThreatInfo* temp = threat_info_; + threat_info_ = NULL; + return temp; +} +inline void FindFullHashesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) { + delete threat_info_; + threat_info_ = threat_info; + if (threat_info) { + set_has_threat_info(); + } else { + clear_has_threat_info(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.threat_info) +} + +// ------------------------------------------------------------------- + +// FindFullHashesResponse + +// repeated .mozilla.safebrowsing.ThreatMatch matches = 1; +inline int FindFullHashesResponse::matches_size() const { + return matches_.size(); +} +inline void FindFullHashesResponse::clear_matches() { + matches_.Clear(); +} +inline const ::mozilla::safebrowsing::ThreatMatch& FindFullHashesResponse::matches(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.matches) + return matches_.Get(index); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::mutable_matches(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.matches) + return matches_.Mutable(index); +} +inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::add_matches() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesResponse.matches) + return matches_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >& +FindFullHashesResponse::matches() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesResponse.matches) + return matches_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >* +FindFullHashesResponse::mutable_matches() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesResponse.matches) + return &matches_; +} + +// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2; +inline bool FindFullHashesResponse::has_minimum_wait_duration() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FindFullHashesResponse::set_has_minimum_wait_duration() { + _has_bits_[0] |= 0x00000002u; +} +inline void FindFullHashesResponse::clear_has_minimum_wait_duration() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FindFullHashesResponse::clear_minimum_wait_duration() { + if (minimum_wait_duration_ != NULL) minimum_wait_duration_->::mozilla::safebrowsing::Duration::Clear(); + clear_has_minimum_wait_duration(); +} +inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::minimum_wait_duration() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return minimum_wait_duration_ != NULL ? *minimum_wait_duration_ : *default_instance().minimum_wait_duration_; +#else + return minimum_wait_duration_ != NULL ? *minimum_wait_duration_ : *default_instance_->minimum_wait_duration_; +#endif +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_minimum_wait_duration() { + set_has_minimum_wait_duration(); + if (minimum_wait_duration_ == NULL) minimum_wait_duration_ = new ::mozilla::safebrowsing::Duration; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration) + return minimum_wait_duration_; +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_minimum_wait_duration() { + clear_has_minimum_wait_duration(); + ::mozilla::safebrowsing::Duration* temp = minimum_wait_duration_; + minimum_wait_duration_ = NULL; + return temp; +} +inline void FindFullHashesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration) { + delete minimum_wait_duration_; + minimum_wait_duration_ = minimum_wait_duration; + if (minimum_wait_duration) { + set_has_minimum_wait_duration(); + } else { + clear_has_minimum_wait_duration(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration) +} + +// optional .mozilla.safebrowsing.Duration negative_cache_duration = 3; +inline bool FindFullHashesResponse::has_negative_cache_duration() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FindFullHashesResponse::set_has_negative_cache_duration() { + _has_bits_[0] |= 0x00000004u; +} +inline void FindFullHashesResponse::clear_has_negative_cache_duration() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FindFullHashesResponse::clear_negative_cache_duration() { + if (negative_cache_duration_ != NULL) negative_cache_duration_->::mozilla::safebrowsing::Duration::Clear(); + clear_has_negative_cache_duration(); +} +inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::negative_cache_duration() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return negative_cache_duration_ != NULL ? *negative_cache_duration_ : *default_instance().negative_cache_duration_; +#else + return negative_cache_duration_ != NULL ? *negative_cache_duration_ : *default_instance_->negative_cache_duration_; +#endif +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_negative_cache_duration() { + set_has_negative_cache_duration(); + if (negative_cache_duration_ == NULL) negative_cache_duration_ = new ::mozilla::safebrowsing::Duration; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration) + return negative_cache_duration_; +} +inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_negative_cache_duration() { + clear_has_negative_cache_duration(); + ::mozilla::safebrowsing::Duration* temp = negative_cache_duration_; + negative_cache_duration_ = NULL; + return temp; +} +inline void FindFullHashesResponse::set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration) { + delete negative_cache_duration_; + negative_cache_duration_ = negative_cache_duration; + if (negative_cache_duration) { + set_has_negative_cache_duration(); + } else { + clear_has_negative_cache_duration(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration) +} + +// ------------------------------------------------------------------- + +// ThreatHit_ThreatSource + +// optional string url = 1; +inline bool ThreatHit_ThreatSource::has_url() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ThreatHit_ThreatSource::set_has_url() { + _has_bits_[0] |= 0x00000001u; +} +inline void ThreatHit_ThreatSource::clear_has_url() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ThreatHit_ThreatSource::clear_url() { + if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_->clear(); + } + clear_has_url(); +} +inline const ::std::string& ThreatHit_ThreatSource::url() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.url) + return *url_; +} +inline void ThreatHit_ThreatSource::set_url(const ::std::string& value) { + set_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_ = new ::std::string; + } + url_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.url) +} +inline void ThreatHit_ThreatSource::set_url(const char* value) { + set_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_ = new ::std::string; + } + url_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.ThreatSource.url) +} +inline void ThreatHit_ThreatSource::set_url(const char* value, size_t size) { + set_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_ = new ::std::string; + } + url_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.ThreatSource.url) +} +inline ::std::string* ThreatHit_ThreatSource::mutable_url() { + set_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.url) + return url_; +} +inline ::std::string* ThreatHit_ThreatSource::release_url() { + clear_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = url_; + url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ThreatHit_ThreatSource::set_allocated_url(::std::string* url) { + if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete url_; + } + if (url) { + set_has_url(); + url_ = url; + } else { + clear_has_url(); + url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.url) +} + +// optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2; +inline bool ThreatHit_ThreatSource::has_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ThreatHit_ThreatSource::set_has_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void ThreatHit_ThreatSource::clear_has_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ThreatHit_ThreatSource::clear_type() { + type_ = 0; + clear_has_type(); +} +inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType ThreatHit_ThreatSource::type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.type) + return static_cast< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType >(type_); +} +inline void ThreatHit_ThreatSource::set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value) { + assert(::mozilla::safebrowsing::ThreatHit_ThreatSourceType_IsValid(value)); + set_has_type(); + type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.type) +} + +// optional string remote_ip = 3; +inline bool ThreatHit_ThreatSource::has_remote_ip() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ThreatHit_ThreatSource::set_has_remote_ip() { + _has_bits_[0] |= 0x00000004u; +} +inline void ThreatHit_ThreatSource::clear_has_remote_ip() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ThreatHit_ThreatSource::clear_remote_ip() { + if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + remote_ip_->clear(); + } + clear_has_remote_ip(); +} +inline const ::std::string& ThreatHit_ThreatSource::remote_ip() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) + return *remote_ip_; +} +inline void ThreatHit_ThreatSource::set_remote_ip(const ::std::string& value) { + set_has_remote_ip(); + if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + remote_ip_ = new ::std::string; + } + remote_ip_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) +} +inline void ThreatHit_ThreatSource::set_remote_ip(const char* value) { + set_has_remote_ip(); + if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + remote_ip_ = new ::std::string; + } + remote_ip_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) +} +inline void ThreatHit_ThreatSource::set_remote_ip(const char* value, size_t size) { + set_has_remote_ip(); + if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + remote_ip_ = new ::std::string; + } + remote_ip_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) +} +inline ::std::string* ThreatHit_ThreatSource::mutable_remote_ip() { + set_has_remote_ip(); + if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + remote_ip_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) + return remote_ip_; +} +inline ::std::string* ThreatHit_ThreatSource::release_remote_ip() { + clear_has_remote_ip(); + if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = remote_ip_; + remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ThreatHit_ThreatSource::set_allocated_remote_ip(::std::string* remote_ip) { + if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete remote_ip_; + } + if (remote_ip) { + set_has_remote_ip(); + remote_ip_ = remote_ip; + } else { + clear_has_remote_ip(); + remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip) +} + +// optional string referrer = 4; +inline bool ThreatHit_ThreatSource::has_referrer() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ThreatHit_ThreatSource::set_has_referrer() { + _has_bits_[0] |= 0x00000008u; +} +inline void ThreatHit_ThreatSource::clear_has_referrer() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ThreatHit_ThreatSource::clear_referrer() { + if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + referrer_->clear(); + } + clear_has_referrer(); +} +inline const ::std::string& ThreatHit_ThreatSource::referrer() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) + return *referrer_; +} +inline void ThreatHit_ThreatSource::set_referrer(const ::std::string& value) { + set_has_referrer(); + if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + referrer_ = new ::std::string; + } + referrer_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) +} +inline void ThreatHit_ThreatSource::set_referrer(const char* value) { + set_has_referrer(); + if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + referrer_ = new ::std::string; + } + referrer_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) +} +inline void ThreatHit_ThreatSource::set_referrer(const char* value, size_t size) { + set_has_referrer(); + if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + referrer_ = new ::std::string; + } + referrer_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) +} +inline ::std::string* ThreatHit_ThreatSource::mutable_referrer() { + set_has_referrer(); + if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + referrer_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) + return referrer_; +} +inline ::std::string* ThreatHit_ThreatSource::release_referrer() { + clear_has_referrer(); + if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = referrer_; + referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ThreatHit_ThreatSource::set_allocated_referrer(::std::string* referrer) { + if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete referrer_; + } + if (referrer) { + set_has_referrer(); + referrer_ = referrer; + } else { + clear_has_referrer(); + referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer) +} + +// ------------------------------------------------------------------- + +// ThreatHit + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool ThreatHit::has_threat_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ThreatHit::set_has_threat_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void ThreatHit::clear_has_threat_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ThreatHit::clear_threat_type() { + threat_type_ = 0; + clear_has_threat_type(); +} +inline ::mozilla::safebrowsing::ThreatType ThreatHit::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.threat_type) + return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_); +} +inline void ThreatHit::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + set_has_threat_type(); + threat_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.threat_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 2; +inline bool ThreatHit::has_platform_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ThreatHit::set_has_platform_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void ThreatHit::clear_has_platform_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ThreatHit::clear_platform_type() { + platform_type_ = 0; + clear_has_platform_type(); +} +inline ::mozilla::safebrowsing::PlatformType ThreatHit::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.platform_type) + return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_); +} +inline void ThreatHit::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + set_has_platform_type(); + platform_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.platform_type) +} + +// optional .mozilla.safebrowsing.ThreatEntry entry = 3; +inline bool ThreatHit::has_entry() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ThreatHit::set_has_entry() { + _has_bits_[0] |= 0x00000004u; +} +inline void ThreatHit::clear_has_entry() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ThreatHit::clear_entry() { + if (entry_ != NULL) entry_->::mozilla::safebrowsing::ThreatEntry::Clear(); + clear_has_entry(); +} +inline const ::mozilla::safebrowsing::ThreatEntry& ThreatHit::entry() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.entry) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return entry_ != NULL ? *entry_ : *default_instance().entry_; +#else + return entry_ != NULL ? *entry_ : *default_instance_->entry_; +#endif +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::mutable_entry() { + set_has_entry(); + if (entry_ == NULL) entry_ = new ::mozilla::safebrowsing::ThreatEntry; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.entry) + return entry_; +} +inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::release_entry() { + clear_has_entry(); + ::mozilla::safebrowsing::ThreatEntry* temp = entry_; + entry_ = NULL; + return temp; +} +inline void ThreatHit::set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry) { + delete entry_; + entry_ = entry; + if (entry) { + set_has_entry(); + } else { + clear_has_entry(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.entry) +} + +// repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4; +inline int ThreatHit::resources_size() const { + return resources_.size(); +} +inline void ThreatHit::clear_resources() { + resources_.Clear(); +} +inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& ThreatHit::resources(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.resources) + return resources_.Get(index); +} +inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::mutable_resources(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.resources) + return resources_.Mutable(index); +} +inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::add_resources() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatHit.resources) + return resources_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >& +ThreatHit::resources() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatHit.resources) + return resources_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >* +ThreatHit::mutable_resources() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatHit.resources) + return &resources_; +} + +// ------------------------------------------------------------------- + +// ClientInfo + +// optional string client_id = 1; +inline bool ClientInfo::has_client_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ClientInfo::set_has_client_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ClientInfo::clear_has_client_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ClientInfo::clear_client_id() { + if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_id_->clear(); + } + clear_has_client_id(); +} +inline const ::std::string& ClientInfo::client_id() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_id) + return *client_id_; +} +inline void ClientInfo::set_client_id(const ::std::string& value) { + set_has_client_id(); + if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_id_ = new ::std::string; + } + client_id_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_id) +} +inline void ClientInfo::set_client_id(const char* value) { + set_has_client_id(); + if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_id_ = new ::std::string; + } + client_id_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ClientInfo.client_id) +} +inline void ClientInfo::set_client_id(const char* value, size_t size) { + set_has_client_id(); + if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_id_ = new ::std::string; + } + client_id_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ClientInfo.client_id) +} +inline ::std::string* ClientInfo::mutable_client_id() { + set_has_client_id(); + if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_id_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_id) + return client_id_; +} +inline ::std::string* ClientInfo::release_client_id() { + clear_has_client_id(); + if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = client_id_; + client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ClientInfo::set_allocated_client_id(::std::string* client_id) { + if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_id_; + } + if (client_id) { + set_has_client_id(); + client_id_ = client_id; + } else { + clear_has_client_id(); + client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_id) +} + +// optional string client_version = 2; +inline bool ClientInfo::has_client_version() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ClientInfo::set_has_client_version() { + _has_bits_[0] |= 0x00000002u; +} +inline void ClientInfo::clear_has_client_version() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ClientInfo::clear_client_version() { + if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_version_->clear(); + } + clear_has_client_version(); +} +inline const ::std::string& ClientInfo::client_version() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_version) + return *client_version_; +} +inline void ClientInfo::set_client_version(const ::std::string& value) { + set_has_client_version(); + if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_version_ = new ::std::string; + } + client_version_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_version) +} +inline void ClientInfo::set_client_version(const char* value) { + set_has_client_version(); + if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_version_ = new ::std::string; + } + client_version_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ClientInfo.client_version) +} +inline void ClientInfo::set_client_version(const char* value, size_t size) { + set_has_client_version(); + if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_version_ = new ::std::string; + } + client_version_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ClientInfo.client_version) +} +inline ::std::string* ClientInfo::mutable_client_version() { + set_has_client_version(); + if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_version_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_version) + return client_version_; +} +inline ::std::string* ClientInfo::release_client_version() { + clear_has_client_version(); + if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = client_version_; + client_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ClientInfo::set_allocated_client_version(::std::string* client_version) { + if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_version_; + } + if (client_version) { + set_has_client_version(); + client_version_ = client_version; + } else { + clear_has_client_version(); + client_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_version) +} + +// ------------------------------------------------------------------- + +// Checksum + +// optional bytes sha256 = 1; +inline bool Checksum::has_sha256() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Checksum::set_has_sha256() { + _has_bits_[0] |= 0x00000001u; +} +inline void Checksum::clear_has_sha256() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Checksum::clear_sha256() { + if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sha256_->clear(); + } + clear_has_sha256(); +} +inline const ::std::string& Checksum::sha256() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Checksum.sha256) + return *sha256_; +} +inline void Checksum::set_sha256(const ::std::string& value) { + set_has_sha256(); + if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sha256_ = new ::std::string; + } + sha256_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Checksum.sha256) +} +inline void Checksum::set_sha256(const char* value) { + set_has_sha256(); + if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sha256_ = new ::std::string; + } + sha256_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.Checksum.sha256) +} +inline void Checksum::set_sha256(const void* value, size_t size) { + set_has_sha256(); + if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sha256_ = new ::std::string; + } + sha256_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.Checksum.sha256) +} +inline ::std::string* Checksum::mutable_sha256() { + set_has_sha256(); + if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sha256_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.Checksum.sha256) + return sha256_; +} +inline ::std::string* Checksum::release_sha256() { + clear_has_sha256(); + if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = sha256_; + sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Checksum::set_allocated_sha256(::std::string* sha256) { + if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sha256_; + } + if (sha256) { + set_has_sha256(); + sha256_ = sha256; + } else { + clear_has_sha256(); + sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.Checksum.sha256) +} + +// ------------------------------------------------------------------- + +// ThreatEntry + +// optional bytes hash = 1; +inline bool ThreatEntry::has_hash() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ThreatEntry::set_has_hash() { + _has_bits_[0] |= 0x00000001u; +} +inline void ThreatEntry::clear_has_hash() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ThreatEntry::clear_hash() { + if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_->clear(); + } + clear_has_hash(); +} +inline const ::std::string& ThreatEntry::hash() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.hash) + return *hash_; +} +inline void ThreatEntry::set_hash(const ::std::string& value) { + set_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_ = new ::std::string; + } + hash_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.hash) +} +inline void ThreatEntry::set_hash(const char* value) { + set_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_ = new ::std::string; + } + hash_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntry.hash) +} +inline void ThreatEntry::set_hash(const void* value, size_t size) { + set_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_ = new ::std::string; + } + hash_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntry.hash) +} +inline ::std::string* ThreatEntry::mutable_hash() { + set_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.hash) + return hash_; +} +inline ::std::string* ThreatEntry::release_hash() { + clear_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = hash_; + hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ThreatEntry::set_allocated_hash(::std::string* hash) { + if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete hash_; + } + if (hash) { + set_has_hash(); + hash_ = hash; + } else { + clear_has_hash(); + hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.hash) +} + +// optional string url = 2; +inline bool ThreatEntry::has_url() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ThreatEntry::set_has_url() { + _has_bits_[0] |= 0x00000002u; +} +inline void ThreatEntry::clear_has_url() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ThreatEntry::clear_url() { + if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_->clear(); + } + clear_has_url(); +} +inline const ::std::string& ThreatEntry::url() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.url) + return *url_; +} +inline void ThreatEntry::set_url(const ::std::string& value) { + set_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_ = new ::std::string; + } + url_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.url) +} +inline void ThreatEntry::set_url(const char* value) { + set_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_ = new ::std::string; + } + url_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntry.url) +} +inline void ThreatEntry::set_url(const char* value, size_t size) { + set_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_ = new ::std::string; + } + url_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntry.url) +} +inline ::std::string* ThreatEntry::mutable_url() { + set_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + url_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.url) + return url_; +} +inline ::std::string* ThreatEntry::release_url() { + clear_has_url(); + if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = url_; + url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ThreatEntry::set_allocated_url(::std::string* url) { + if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete url_; + } + if (url) { + set_has_url(); + url_ = url; + } else { + clear_has_url(); + url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.url) +} + +// ------------------------------------------------------------------- + +// ThreatEntrySet + +// optional .mozilla.safebrowsing.CompressionType compression_type = 1; +inline bool ThreatEntrySet::has_compression_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ThreatEntrySet::set_has_compression_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void ThreatEntrySet::clear_has_compression_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ThreatEntrySet::clear_compression_type() { + compression_type_ = 0; + clear_has_compression_type(); +} +inline ::mozilla::safebrowsing::CompressionType ThreatEntrySet::compression_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.compression_type) + return static_cast< ::mozilla::safebrowsing::CompressionType >(compression_type_); +} +inline void ThreatEntrySet::set_compression_type(::mozilla::safebrowsing::CompressionType value) { + assert(::mozilla::safebrowsing::CompressionType_IsValid(value)); + set_has_compression_type(); + compression_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntrySet.compression_type) +} + +// optional .mozilla.safebrowsing.RawHashes raw_hashes = 2; +inline bool ThreatEntrySet::has_raw_hashes() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ThreatEntrySet::set_has_raw_hashes() { + _has_bits_[0] |= 0x00000002u; +} +inline void ThreatEntrySet::clear_has_raw_hashes() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ThreatEntrySet::clear_raw_hashes() { + if (raw_hashes_ != NULL) raw_hashes_->::mozilla::safebrowsing::RawHashes::Clear(); + clear_has_raw_hashes(); +} +inline const ::mozilla::safebrowsing::RawHashes& ThreatEntrySet::raw_hashes() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_hashes) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return raw_hashes_ != NULL ? *raw_hashes_ : *default_instance().raw_hashes_; +#else + return raw_hashes_ != NULL ? *raw_hashes_ : *default_instance_->raw_hashes_; +#endif +} +inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::mutable_raw_hashes() { + set_has_raw_hashes(); + if (raw_hashes_ == NULL) raw_hashes_ = new ::mozilla::safebrowsing::RawHashes; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_hashes) + return raw_hashes_; +} +inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::release_raw_hashes() { + clear_has_raw_hashes(); + ::mozilla::safebrowsing::RawHashes* temp = raw_hashes_; + raw_hashes_ = NULL; + return temp; +} +inline void ThreatEntrySet::set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes) { + delete raw_hashes_; + raw_hashes_ = raw_hashes; + if (raw_hashes) { + set_has_raw_hashes(); + } else { + clear_has_raw_hashes(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_hashes) +} + +// optional .mozilla.safebrowsing.RawIndices raw_indices = 3; +inline bool ThreatEntrySet::has_raw_indices() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ThreatEntrySet::set_has_raw_indices() { + _has_bits_[0] |= 0x00000004u; +} +inline void ThreatEntrySet::clear_has_raw_indices() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ThreatEntrySet::clear_raw_indices() { + if (raw_indices_ != NULL) raw_indices_->::mozilla::safebrowsing::RawIndices::Clear(); + clear_has_raw_indices(); +} +inline const ::mozilla::safebrowsing::RawIndices& ThreatEntrySet::raw_indices() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_indices) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return raw_indices_ != NULL ? *raw_indices_ : *default_instance().raw_indices_; +#else + return raw_indices_ != NULL ? *raw_indices_ : *default_instance_->raw_indices_; +#endif +} +inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::mutable_raw_indices() { + set_has_raw_indices(); + if (raw_indices_ == NULL) raw_indices_ = new ::mozilla::safebrowsing::RawIndices; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_indices) + return raw_indices_; +} +inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::release_raw_indices() { + clear_has_raw_indices(); + ::mozilla::safebrowsing::RawIndices* temp = raw_indices_; + raw_indices_ = NULL; + return temp; +} +inline void ThreatEntrySet::set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices) { + delete raw_indices_; + raw_indices_ = raw_indices; + if (raw_indices) { + set_has_raw_indices(); + } else { + clear_has_raw_indices(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_indices) +} + +// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4; +inline bool ThreatEntrySet::has_rice_hashes() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ThreatEntrySet::set_has_rice_hashes() { + _has_bits_[0] |= 0x00000008u; +} +inline void ThreatEntrySet::clear_has_rice_hashes() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ThreatEntrySet::clear_rice_hashes() { + if (rice_hashes_ != NULL) rice_hashes_->::mozilla::safebrowsing::RiceDeltaEncoding::Clear(); + clear_has_rice_hashes(); +} +inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_hashes() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_hashes) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return rice_hashes_ != NULL ? *rice_hashes_ : *default_instance().rice_hashes_; +#else + return rice_hashes_ != NULL ? *rice_hashes_ : *default_instance_->rice_hashes_; +#endif +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_hashes() { + set_has_rice_hashes(); + if (rice_hashes_ == NULL) rice_hashes_ = new ::mozilla::safebrowsing::RiceDeltaEncoding; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_hashes) + return rice_hashes_; +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_hashes() { + clear_has_rice_hashes(); + ::mozilla::safebrowsing::RiceDeltaEncoding* temp = rice_hashes_; + rice_hashes_ = NULL; + return temp; +} +inline void ThreatEntrySet::set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes) { + delete rice_hashes_; + rice_hashes_ = rice_hashes; + if (rice_hashes) { + set_has_rice_hashes(); + } else { + clear_has_rice_hashes(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_hashes) +} + +// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5; +inline bool ThreatEntrySet::has_rice_indices() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ThreatEntrySet::set_has_rice_indices() { + _has_bits_[0] |= 0x00000010u; +} +inline void ThreatEntrySet::clear_has_rice_indices() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ThreatEntrySet::clear_rice_indices() { + if (rice_indices_ != NULL) rice_indices_->::mozilla::safebrowsing::RiceDeltaEncoding::Clear(); + clear_has_rice_indices(); +} +inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_indices() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_indices) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return rice_indices_ != NULL ? *rice_indices_ : *default_instance().rice_indices_; +#else + return rice_indices_ != NULL ? *rice_indices_ : *default_instance_->rice_indices_; +#endif +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_indices() { + set_has_rice_indices(); + if (rice_indices_ == NULL) rice_indices_ = new ::mozilla::safebrowsing::RiceDeltaEncoding; + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_indices) + return rice_indices_; +} +inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_indices() { + clear_has_rice_indices(); + ::mozilla::safebrowsing::RiceDeltaEncoding* temp = rice_indices_; + rice_indices_ = NULL; + return temp; +} +inline void ThreatEntrySet::set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices) { + delete rice_indices_; + rice_indices_ = rice_indices; + if (rice_indices) { + set_has_rice_indices(); + } else { + clear_has_rice_indices(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_indices) +} + +// ------------------------------------------------------------------- + +// RawIndices + +// repeated int32 indices = 1; +inline int RawIndices::indices_size() const { + return indices_.size(); +} +inline void RawIndices::clear_indices() { + indices_.Clear(); +} +inline ::google::protobuf::int32 RawIndices::indices(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawIndices.indices) + return indices_.Get(index); +} +inline void RawIndices::set_indices(int index, ::google::protobuf::int32 value) { + indices_.Set(index, value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawIndices.indices) +} +inline void RawIndices::add_indices(::google::protobuf::int32 value) { + indices_.Add(value); + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.RawIndices.indices) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +RawIndices::indices() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.RawIndices.indices) + return indices_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +RawIndices::mutable_indices() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.RawIndices.indices) + return &indices_; +} + +// ------------------------------------------------------------------- + +// RawHashes + +// optional int32 prefix_size = 1; +inline bool RawHashes::has_prefix_size() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RawHashes::set_has_prefix_size() { + _has_bits_[0] |= 0x00000001u; +} +inline void RawHashes::clear_has_prefix_size() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RawHashes::clear_prefix_size() { + prefix_size_ = 0; + clear_has_prefix_size(); +} +inline ::google::protobuf::int32 RawHashes::prefix_size() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.prefix_size) + return prefix_size_; +} +inline void RawHashes::set_prefix_size(::google::protobuf::int32 value) { + set_has_prefix_size(); + prefix_size_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.prefix_size) +} + +// optional bytes raw_hashes = 2; +inline bool RawHashes::has_raw_hashes() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RawHashes::set_has_raw_hashes() { + _has_bits_[0] |= 0x00000002u; +} +inline void RawHashes::clear_has_raw_hashes() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RawHashes::clear_raw_hashes() { + if (raw_hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raw_hashes_->clear(); + } + clear_has_raw_hashes(); +} +inline const ::std::string& RawHashes::raw_hashes() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.raw_hashes) + return *raw_hashes_; +} +inline void RawHashes::set_raw_hashes(const ::std::string& value) { + set_has_raw_hashes(); + if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raw_hashes_ = new ::std::string; + } + raw_hashes_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.raw_hashes) +} +inline void RawHashes::set_raw_hashes(const char* value) { + set_has_raw_hashes(); + if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raw_hashes_ = new ::std::string; + } + raw_hashes_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.RawHashes.raw_hashes) +} +inline void RawHashes::set_raw_hashes(const void* value, size_t size) { + set_has_raw_hashes(); + if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raw_hashes_ = new ::std::string; + } + raw_hashes_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.RawHashes.raw_hashes) +} +inline ::std::string* RawHashes::mutable_raw_hashes() { + set_has_raw_hashes(); + if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raw_hashes_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RawHashes.raw_hashes) + return raw_hashes_; +} +inline ::std::string* RawHashes::release_raw_hashes() { + clear_has_raw_hashes(); + if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = raw_hashes_; + raw_hashes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void RawHashes::set_allocated_raw_hashes(::std::string* raw_hashes) { + if (raw_hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete raw_hashes_; + } + if (raw_hashes) { + set_has_raw_hashes(); + raw_hashes_ = raw_hashes; + } else { + clear_has_raw_hashes(); + raw_hashes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.RawHashes.raw_hashes) +} + +// ------------------------------------------------------------------- + +// RiceDeltaEncoding + +// optional int64 first_value = 1; +inline bool RiceDeltaEncoding::has_first_value() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RiceDeltaEncoding::set_has_first_value() { + _has_bits_[0] |= 0x00000001u; +} +inline void RiceDeltaEncoding::clear_has_first_value() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RiceDeltaEncoding::clear_first_value() { + first_value_ = GOOGLE_LONGLONG(0); + clear_has_first_value(); +} +inline ::google::protobuf::int64 RiceDeltaEncoding::first_value() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.first_value) + return first_value_; +} +inline void RiceDeltaEncoding::set_first_value(::google::protobuf::int64 value) { + set_has_first_value(); + first_value_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.first_value) +} + +// optional int32 rice_parameter = 2; +inline bool RiceDeltaEncoding::has_rice_parameter() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RiceDeltaEncoding::set_has_rice_parameter() { + _has_bits_[0] |= 0x00000002u; +} +inline void RiceDeltaEncoding::clear_has_rice_parameter() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RiceDeltaEncoding::clear_rice_parameter() { + rice_parameter_ = 0; + clear_has_rice_parameter(); +} +inline ::google::protobuf::int32 RiceDeltaEncoding::rice_parameter() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter) + return rice_parameter_; +} +inline void RiceDeltaEncoding::set_rice_parameter(::google::protobuf::int32 value) { + set_has_rice_parameter(); + rice_parameter_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter) +} + +// optional int32 num_entries = 3; +inline bool RiceDeltaEncoding::has_num_entries() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RiceDeltaEncoding::set_has_num_entries() { + _has_bits_[0] |= 0x00000004u; +} +inline void RiceDeltaEncoding::clear_has_num_entries() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RiceDeltaEncoding::clear_num_entries() { + num_entries_ = 0; + clear_has_num_entries(); +} +inline ::google::protobuf::int32 RiceDeltaEncoding::num_entries() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.num_entries) + return num_entries_; +} +inline void RiceDeltaEncoding::set_num_entries(::google::protobuf::int32 value) { + set_has_num_entries(); + num_entries_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.num_entries) +} + +// optional bytes encoded_data = 4; +inline bool RiceDeltaEncoding::has_encoded_data() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void RiceDeltaEncoding::set_has_encoded_data() { + _has_bits_[0] |= 0x00000008u; +} +inline void RiceDeltaEncoding::clear_has_encoded_data() { + _has_bits_[0] &= ~0x00000008u; +} +inline void RiceDeltaEncoding::clear_encoded_data() { + if (encoded_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + encoded_data_->clear(); + } + clear_has_encoded_data(); +} +inline const ::std::string& RiceDeltaEncoding::encoded_data() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) + return *encoded_data_; +} +inline void RiceDeltaEncoding::set_encoded_data(const ::std::string& value) { + set_has_encoded_data(); + if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + encoded_data_ = new ::std::string; + } + encoded_data_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) +} +inline void RiceDeltaEncoding::set_encoded_data(const char* value) { + set_has_encoded_data(); + if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + encoded_data_ = new ::std::string; + } + encoded_data_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) +} +inline void RiceDeltaEncoding::set_encoded_data(const void* value, size_t size) { + set_has_encoded_data(); + if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + encoded_data_ = new ::std::string; + } + encoded_data_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) +} +inline ::std::string* RiceDeltaEncoding::mutable_encoded_data() { + set_has_encoded_data(); + if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + encoded_data_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) + return encoded_data_; +} +inline ::std::string* RiceDeltaEncoding::release_encoded_data() { + clear_has_encoded_data(); + if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = encoded_data_; + encoded_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void RiceDeltaEncoding::set_allocated_encoded_data(::std::string* encoded_data) { + if (encoded_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete encoded_data_; + } + if (encoded_data) { + set_has_encoded_data(); + encoded_data_ = encoded_data; + } else { + clear_has_encoded_data(); + encoded_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data) +} + +// ------------------------------------------------------------------- + +// ThreatEntryMetadata_MetadataEntry + +// optional bytes key = 1; +inline bool ThreatEntryMetadata_MetadataEntry::has_key() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ThreatEntryMetadata_MetadataEntry::set_has_key() { + _has_bits_[0] |= 0x00000001u; +} +inline void ThreatEntryMetadata_MetadataEntry::clear_has_key() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ThreatEntryMetadata_MetadataEntry::clear_key() { + if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_->clear(); + } + clear_has_key(); +} +inline const ::std::string& ThreatEntryMetadata_MetadataEntry::key() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) + return *key_; +} +inline void ThreatEntryMetadata_MetadataEntry::set_key(const ::std::string& value) { + set_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_ = new ::std::string; + } + key_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) +} +inline void ThreatEntryMetadata_MetadataEntry::set_key(const char* value) { + set_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_ = new ::std::string; + } + key_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) +} +inline void ThreatEntryMetadata_MetadataEntry::set_key(const void* value, size_t size) { + set_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_ = new ::std::string; + } + key_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) +} +inline ::std::string* ThreatEntryMetadata_MetadataEntry::mutable_key() { + set_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) + return key_; +} +inline ::std::string* ThreatEntryMetadata_MetadataEntry::release_key() { + clear_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = key_; + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ThreatEntryMetadata_MetadataEntry::set_allocated_key(::std::string* key) { + if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete key_; + } + if (key) { + set_has_key(); + key_ = key; + } else { + clear_has_key(); + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key) +} + +// optional bytes value = 2; +inline bool ThreatEntryMetadata_MetadataEntry::has_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ThreatEntryMetadata_MetadataEntry::set_has_value() { + _has_bits_[0] |= 0x00000002u; +} +inline void ThreatEntryMetadata_MetadataEntry::clear_has_value() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ThreatEntryMetadata_MetadataEntry::clear_value() { + if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + value_->clear(); + } + clear_has_value(); +} +inline const ::std::string& ThreatEntryMetadata_MetadataEntry::value() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) + return *value_; +} +inline void ThreatEntryMetadata_MetadataEntry::set_value(const ::std::string& value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + value_ = new ::std::string; + } + value_->assign(value); + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) +} +inline void ThreatEntryMetadata_MetadataEntry::set_value(const char* value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + value_ = new ::std::string; + } + value_->assign(value); + // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) +} +inline void ThreatEntryMetadata_MetadataEntry::set_value(const void* value, size_t size) { + set_has_value(); + if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + value_ = new ::std::string; + } + value_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) +} +inline ::std::string* ThreatEntryMetadata_MetadataEntry::mutable_value() { + set_has_value(); + if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + value_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) + return value_; +} +inline ::std::string* ThreatEntryMetadata_MetadataEntry::release_value() { + clear_has_value(); + if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = value_; + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ThreatEntryMetadata_MetadataEntry::set_allocated_value(::std::string* value) { + if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete value_; + } + if (value) { + set_has_value(); + value_ = value; + } else { + clear_has_value(); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value) +} + +// ------------------------------------------------------------------- + +// ThreatEntryMetadata + +// repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1; +inline int ThreatEntryMetadata::entries_size() const { + return entries_.size(); +} +inline void ThreatEntryMetadata::clear_entries() { + entries_.Clear(); +} +inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata::entries(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return entries_.Get(index); +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::mutable_entries(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return entries_.Mutable(index); +} +inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::add_entries() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return entries_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >& +ThreatEntryMetadata::entries() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return entries_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >* +ThreatEntryMetadata::mutable_entries() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatEntryMetadata.entries) + return &entries_; +} + +// ------------------------------------------------------------------- + +// ThreatListDescriptor + +// optional .mozilla.safebrowsing.ThreatType threat_type = 1; +inline bool ThreatListDescriptor::has_threat_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ThreatListDescriptor::set_has_threat_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void ThreatListDescriptor::clear_has_threat_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ThreatListDescriptor::clear_threat_type() { + threat_type_ = 0; + clear_has_threat_type(); +} +inline ::mozilla::safebrowsing::ThreatType ThreatListDescriptor::threat_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_type) + return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_); +} +inline void ThreatListDescriptor::set_threat_type(::mozilla::safebrowsing::ThreatType value) { + assert(::mozilla::safebrowsing::ThreatType_IsValid(value)); + set_has_threat_type(); + threat_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_type) +} + +// optional .mozilla.safebrowsing.PlatformType platform_type = 2; +inline bool ThreatListDescriptor::has_platform_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ThreatListDescriptor::set_has_platform_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void ThreatListDescriptor::clear_has_platform_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ThreatListDescriptor::clear_platform_type() { + platform_type_ = 0; + clear_has_platform_type(); +} +inline ::mozilla::safebrowsing::PlatformType ThreatListDescriptor::platform_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.platform_type) + return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_); +} +inline void ThreatListDescriptor::set_platform_type(::mozilla::safebrowsing::PlatformType value) { + assert(::mozilla::safebrowsing::PlatformType_IsValid(value)); + set_has_platform_type(); + platform_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.platform_type) +} + +// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3; +inline bool ThreatListDescriptor::has_threat_entry_type() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ThreatListDescriptor::set_has_threat_entry_type() { + _has_bits_[0] |= 0x00000004u; +} +inline void ThreatListDescriptor::clear_has_threat_entry_type() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ThreatListDescriptor::clear_threat_entry_type() { + threat_entry_type_ = 0; + clear_has_threat_entry_type(); +} +inline ::mozilla::safebrowsing::ThreatEntryType ThreatListDescriptor::threat_entry_type() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type) + return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_); +} +inline void ThreatListDescriptor::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) { + assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value)); + set_has_threat_entry_type(); + threat_entry_type_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type) +} + +// ------------------------------------------------------------------- + +// ListThreatListsResponse + +// repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1; +inline int ListThreatListsResponse::threat_lists_size() const { + return threat_lists_.size(); +} +inline void ListThreatListsResponse::clear_threat_lists() { + threat_lists_.Clear(); +} +inline const ::mozilla::safebrowsing::ThreatListDescriptor& ListThreatListsResponse::threat_lists(int index) const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return threat_lists_.Get(index); +} +inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::mutable_threat_lists(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return threat_lists_.Mutable(index); +} +inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::add_threat_lists() { + // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return threat_lists_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >& +ListThreatListsResponse::threat_lists() const { + // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return threat_lists_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >* +ListThreatListsResponse::mutable_threat_lists() { + // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists) + return &threat_lists_; +} + +// ------------------------------------------------------------------- + +// Duration + +// optional int64 seconds = 1; +inline bool Duration::has_seconds() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Duration::set_has_seconds() { + _has_bits_[0] |= 0x00000001u; +} +inline void Duration::clear_has_seconds() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Duration::clear_seconds() { + seconds_ = GOOGLE_LONGLONG(0); + clear_has_seconds(); +} +inline ::google::protobuf::int64 Duration::seconds() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.seconds) + return seconds_; +} +inline void Duration::set_seconds(::google::protobuf::int64 value) { + set_has_seconds(); + seconds_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.seconds) +} + +// optional int32 nanos = 2; +inline bool Duration::has_nanos() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Duration::set_has_nanos() { + _has_bits_[0] |= 0x00000002u; +} +inline void Duration::clear_has_nanos() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Duration::clear_nanos() { + nanos_ = 0; + clear_has_nanos(); +} +inline ::google::protobuf::int32 Duration::nanos() const { + // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.nanos) + return nanos_; +} +inline void Duration::set_nanos(::google::protobuf::int32 value) { + set_has_nanos(); + nanos_ = value; + // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.nanos) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace safebrowsing +} // namespace mozilla + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_safebrowsing_2eproto__INCLUDED |