chromium/out/Default/gen/components/reporting/proto/synced/record.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: components/reporting/proto/synced/record.proto

#include "components/reporting/proto/synced/record.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace reporting {
PROTOBUF_CONSTEXPR Record::Record(
    ::_pbi::ConstantInitialized): … { … }
struct RecordDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecordDefaultTypeInternal _Record_default_instance_;
PROTOBUF_CONSTEXPR SourceInfo::SourceInfo(
    ::_pbi::ConstantInitialized): … { … }
struct SourceInfoDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SourceInfoDefaultTypeInternal _SourceInfo_default_instance_;
PROTOBUF_CONSTEXPR WrappedRecord::WrappedRecord(
    ::_pbi::ConstantInitialized): … { … }
struct WrappedRecordDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WrappedRecordDefaultTypeInternal _WrappedRecord_default_instance_;
PROTOBUF_CONSTEXPR EncryptionInfo::EncryptionInfo(
    ::_pbi::ConstantInitialized): … { … }
struct EncryptionInfoDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptionInfoDefaultTypeInternal _EncryptionInfo_default_instance_;
PROTOBUF_CONSTEXPR SequenceInformation::SequenceInformation(
    ::_pbi::ConstantInitialized): … { … }
struct SequenceInformationDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SequenceInformationDefaultTypeInternal _SequenceInformation_default_instance_;
PROTOBUF_CONSTEXPR EncryptedRecord::EncryptedRecord(
    ::_pbi::ConstantInitialized): … { … }
struct EncryptedRecordDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptedRecordDefaultTypeInternal _EncryptedRecord_default_instance_;
PROTOBUF_CONSTEXPR CompressionInformation::CompressionInformation(
    ::_pbi::ConstantInitialized): … { … }
struct CompressionInformationDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompressionInformationDefaultTypeInternal _CompressionInformation_default_instance_;
PROTOBUF_CONSTEXPR SignedEncryptionInfo::SignedEncryptionInfo(
    ::_pbi::ConstantInitialized): … { … }
struct SignedEncryptionInfoDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SignedEncryptionInfoDefaultTypeInternal _SignedEncryptionInfo_default_instance_;
PROTOBUF_CONSTEXPR ListOfBlockedDestinations::ListOfBlockedDestinations(
    ::_pbi::ConstantInitialized): … { … }
struct ListOfBlockedDestinationsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ListOfBlockedDestinationsDefaultTypeInternal _ListOfBlockedDestinations_default_instance_;
}  // namespace reporting
namespace reporting {
bool SourceInfo_Source_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SourceInfo_Source_strings[3] = …;

static const char SourceInfo_Source_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SourceInfo_Source_entries[] = …;

static const int SourceInfo_Source_entries_by_number[] = …;

const std::string& SourceInfo_Source_Name(
    SourceInfo_Source value) { … }
bool SourceInfo_Source_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SourceInfo_Source* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SourceInfo_Source SourceInfo::SOURCE_UNSPECIFIED;
constexpr SourceInfo_Source SourceInfo::ASH;
constexpr SourceInfo_Source SourceInfo::LACROS;
constexpr SourceInfo_Source SourceInfo::Source_MIN;
constexpr SourceInfo_Source SourceInfo::Source_MAX;
constexpr int SourceInfo::Source_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool CompressionInformation_CompressionAlgorithm_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CompressionInformation_CompressionAlgorithm_strings[2] = …;

static const char CompressionInformation_CompressionAlgorithm_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CompressionInformation_CompressionAlgorithm_entries[] = …;

static const int CompressionInformation_CompressionAlgorithm_entries_by_number[] = …;

const std::string& CompressionInformation_CompressionAlgorithm_Name(
    CompressionInformation_CompressionAlgorithm value) { … }
bool CompressionInformation_CompressionAlgorithm_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CompressionInformation_CompressionAlgorithm* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CompressionInformation_CompressionAlgorithm CompressionInformation::COMPRESSION_NONE;
constexpr CompressionInformation_CompressionAlgorithm CompressionInformation::COMPRESSION_SNAPPY;
constexpr CompressionInformation_CompressionAlgorithm CompressionInformation::CompressionAlgorithm_MIN;
constexpr CompressionInformation_CompressionAlgorithm CompressionInformation::CompressionAlgorithm_MAX;
constexpr int CompressionInformation::CompressionAlgorithm_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class Record::_Internal { … };

const ::reporting::SourceInfo&
Record::_Internal::source_info(const Record* msg) { … }
Record::Record(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
Record::Record(const Record& from)
  : … { … }

inline void Record::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

Record::~Record() { … }

inline void Record::SharedDtor() { … }

void Record::SetCachedSize(int size) const { … }

void Record::Clear() { … }

const char* Record::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* Record::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t Record::ByteSizeLong() const { … }

void Record::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void Record::MergeFrom(const Record& from) { … }

void Record::CopyFrom(const Record& from) { … }

bool Record::IsInitialized() const { … }

void Record::InternalSwap(Record* other) { … }

std::string Record::GetTypeName() const { … }


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

class SourceInfo::_Internal { … };

SourceInfo::SourceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
SourceInfo::SourceInfo(const SourceInfo& from)
  : … { … }

inline void SourceInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

SourceInfo::~SourceInfo() { … }

inline void SourceInfo::SharedDtor() { … }

void SourceInfo::SetCachedSize(int size) const { … }

void SourceInfo::Clear() { … }

const char* SourceInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* SourceInfo::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t SourceInfo::ByteSizeLong() const { … }

void SourceInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void SourceInfo::MergeFrom(const SourceInfo& from) { … }

void SourceInfo::CopyFrom(const SourceInfo& from) { … }

bool SourceInfo::IsInitialized() const { … }

void SourceInfo::InternalSwap(SourceInfo* other) { … }

std::string SourceInfo::GetTypeName() const { … }


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

class WrappedRecord::_Internal { … };

const ::reporting::Record&
WrappedRecord::_Internal::record(const WrappedRecord* msg) { … }
WrappedRecord::WrappedRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
WrappedRecord::WrappedRecord(const WrappedRecord& from)
  : … { … }

inline void WrappedRecord::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

WrappedRecord::~WrappedRecord() { … }

inline void WrappedRecord::SharedDtor() { … }

void WrappedRecord::SetCachedSize(int size) const { … }

void WrappedRecord::Clear() { … }

const char* WrappedRecord::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* WrappedRecord::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t WrappedRecord::ByteSizeLong() const { … }

void WrappedRecord::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void WrappedRecord::MergeFrom(const WrappedRecord& from) { … }

void WrappedRecord::CopyFrom(const WrappedRecord& from) { … }

bool WrappedRecord::IsInitialized() const { … }

void WrappedRecord::InternalSwap(WrappedRecord* other) { … }

std::string WrappedRecord::GetTypeName() const { … }


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

class EncryptionInfo::_Internal { … };

EncryptionInfo::EncryptionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
EncryptionInfo::EncryptionInfo(const EncryptionInfo& from)
  : … { … }

inline void EncryptionInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

EncryptionInfo::~EncryptionInfo() { … }

inline void EncryptionInfo::SharedDtor() { … }

void EncryptionInfo::SetCachedSize(int size) const { … }

void EncryptionInfo::Clear() { … }

const char* EncryptionInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* EncryptionInfo::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t EncryptionInfo::ByteSizeLong() const { … }

void EncryptionInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void EncryptionInfo::MergeFrom(const EncryptionInfo& from) { … }

void EncryptionInfo::CopyFrom(const EncryptionInfo& from) { … }

bool EncryptionInfo::IsInitialized() const { … }

void EncryptionInfo::InternalSwap(EncryptionInfo* other) { … }

std::string EncryptionInfo::GetTypeName() const { … }


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

class SequenceInformation::_Internal { … };

SequenceInformation::SequenceInformation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
SequenceInformation::SequenceInformation(const SequenceInformation& from)
  : … { … }

inline void SequenceInformation::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

SequenceInformation::~SequenceInformation() { … }

inline void SequenceInformation::SharedDtor() { … }

void SequenceInformation::SetCachedSize(int size) const { … }

void SequenceInformation::Clear() { … }

const char* SequenceInformation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* SequenceInformation::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t SequenceInformation::ByteSizeLong() const { … }

void SequenceInformation::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void SequenceInformation::MergeFrom(const SequenceInformation& from) { … }

void SequenceInformation::CopyFrom(const SequenceInformation& from) { … }

bool SequenceInformation::IsInitialized() const { … }

void SequenceInformation::InternalSwap(SequenceInformation* other) { … }

std::string SequenceInformation::GetTypeName() const { … }


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

class EncryptedRecord::_Internal { … };

const ::reporting::EncryptionInfo&
EncryptedRecord::_Internal::encryption_info(const EncryptedRecord* msg) { … }
const ::reporting::SequenceInformation&
EncryptedRecord::_Internal::sequence_information(const EncryptedRecord* msg) { … }
const ::reporting::CompressionInformation&
EncryptedRecord::_Internal::compression_information(const EncryptedRecord* msg) { … }
const ::reporting::SequenceInformation&
EncryptedRecord::_Internal::sequencing_information(const EncryptedRecord* msg) { … }
const ::reporting::ERPHealthData&
EncryptedRecord::_Internal::erp_health_data(const EncryptedRecord* msg) { … }
const ::reporting::Record&
EncryptedRecord::_Internal::record_copy(const EncryptedRecord* msg) { … }
void EncryptedRecord::clear_erp_health_data() { … }
EncryptedRecord::EncryptedRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
EncryptedRecord::EncryptedRecord(const EncryptedRecord& from)
  : … { … }

inline void EncryptedRecord::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

EncryptedRecord::~EncryptedRecord() { … }

inline void EncryptedRecord::SharedDtor() { … }

void EncryptedRecord::SetCachedSize(int size) const { … }

void EncryptedRecord::Clear() { … }

const char* EncryptedRecord::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* EncryptedRecord::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t EncryptedRecord::ByteSizeLong() const { … }

void EncryptedRecord::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void EncryptedRecord::MergeFrom(const EncryptedRecord& from) { … }

void EncryptedRecord::CopyFrom(const EncryptedRecord& from) { … }

bool EncryptedRecord::IsInitialized() const { … }

void EncryptedRecord::InternalSwap(EncryptedRecord* other) { … }

std::string EncryptedRecord::GetTypeName() const { … }


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

class CompressionInformation::_Internal { … };

CompressionInformation::CompressionInformation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CompressionInformation::CompressionInformation(const CompressionInformation& from)
  : … { … }

inline void CompressionInformation::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CompressionInformation::~CompressionInformation() { … }

inline void CompressionInformation::SharedDtor() { … }

void CompressionInformation::SetCachedSize(int size) const { … }

void CompressionInformation::Clear() { … }

const char* CompressionInformation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CompressionInformation::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CompressionInformation::ByteSizeLong() const { … }

void CompressionInformation::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CompressionInformation::MergeFrom(const CompressionInformation& from) { … }

void CompressionInformation::CopyFrom(const CompressionInformation& from) { … }

bool CompressionInformation::IsInitialized() const { … }

void CompressionInformation::InternalSwap(CompressionInformation* other) { … }

std::string CompressionInformation::GetTypeName() const { … }


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

class SignedEncryptionInfo::_Internal { … };

SignedEncryptionInfo::SignedEncryptionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
SignedEncryptionInfo::SignedEncryptionInfo(const SignedEncryptionInfo& from)
  : … { … }

inline void SignedEncryptionInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

SignedEncryptionInfo::~SignedEncryptionInfo() { … }

inline void SignedEncryptionInfo::SharedDtor() { … }

void SignedEncryptionInfo::SetCachedSize(int size) const { … }

void SignedEncryptionInfo::Clear() { … }

const char* SignedEncryptionInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* SignedEncryptionInfo::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t SignedEncryptionInfo::ByteSizeLong() const { … }

void SignedEncryptionInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void SignedEncryptionInfo::MergeFrom(const SignedEncryptionInfo& from) { … }

void SignedEncryptionInfo::CopyFrom(const SignedEncryptionInfo& from) { … }

bool SignedEncryptionInfo::IsInitialized() const { … }

void SignedEncryptionInfo::InternalSwap(SignedEncryptionInfo* other) { … }

std::string SignedEncryptionInfo::GetTypeName() const { … }


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

class ListOfBlockedDestinations::_Internal { … };

ListOfBlockedDestinations::ListOfBlockedDestinations(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ListOfBlockedDestinations::ListOfBlockedDestinations(const ListOfBlockedDestinations& from)
  : … { … }

inline void ListOfBlockedDestinations::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ListOfBlockedDestinations::~ListOfBlockedDestinations() { … }

inline void ListOfBlockedDestinations::SharedDtor() { … }

void ListOfBlockedDestinations::SetCachedSize(int size) const { … }

void ListOfBlockedDestinations::Clear() { … }

const char* ListOfBlockedDestinations::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ListOfBlockedDestinations::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ListOfBlockedDestinations::ByteSizeLong() const { … }

void ListOfBlockedDestinations::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ListOfBlockedDestinations::MergeFrom(const ListOfBlockedDestinations& from) { … }

void ListOfBlockedDestinations::CopyFrom(const ListOfBlockedDestinations& from) { … }

bool ListOfBlockedDestinations::IsInitialized() const { … }

void ListOfBlockedDestinations::InternalSwap(ListOfBlockedDestinations* other) { … }

std::string ListOfBlockedDestinations::GetTypeName() const { … }


// @@protoc_insertion_point(namespace_scope)
}  // namespace reporting
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::reporting::Record*
Arena::CreateMaybeMessage< ::reporting::Record >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::SourceInfo*
Arena::CreateMaybeMessage< ::reporting::SourceInfo >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::WrappedRecord*
Arena::CreateMaybeMessage< ::reporting::WrappedRecord >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::EncryptionInfo*
Arena::CreateMaybeMessage< ::reporting::EncryptionInfo >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::SequenceInformation*
Arena::CreateMaybeMessage< ::reporting::SequenceInformation >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::EncryptedRecord*
Arena::CreateMaybeMessage< ::reporting::EncryptedRecord >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::CompressionInformation*
Arena::CreateMaybeMessage< ::reporting::CompressionInformation >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::SignedEncryptionInfo*
Arena::CreateMaybeMessage< ::reporting::SignedEncryptionInfo >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::ListOfBlockedDestinations*
Arena::CreateMaybeMessage< ::reporting::ListOfBlockedDestinations >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>