health.pb.cc | Explore in Territory

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

#include "components/reporting/proto/synced/health.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 StorageDequeue::StorageDequeue(
    ::_pbi::ConstantInitialized): … { … }
struct StorageDequeueDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StorageDequeueDefaultTypeInternal _StorageDequeue_default_instance_;
PROTOBUF_CONSTEXPR StorageEnqueue::StorageEnqueue(
    ::_pbi::ConstantInitialized): … { … }
struct StorageEnqueueDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StorageEnqueueDefaultTypeInternal _StorageEnqueue_default_instance_;
PROTOBUF_CONSTEXPR StorageQueueAction::StorageQueueAction(
    ::_pbi::ConstantInitialized): … { … }
struct StorageQueueActionDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StorageQueueActionDefaultTypeInternal _StorageQueueAction_default_instance_;
PROTOBUF_CONSTEXPR EnqueueRecordCall::EnqueueRecordCall(
    ::_pbi::ConstantInitialized): … { … }
struct EnqueueRecordCallDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnqueueRecordCallDefaultTypeInternal _EnqueueRecordCall_default_instance_;
PROTOBUF_CONSTEXPR FlushPriorityCall::FlushPriorityCall(
    ::_pbi::ConstantInitialized): … { … }
struct FlushPriorityCallDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FlushPriorityCallDefaultTypeInternal _FlushPriorityCall_default_instance_;
PROTOBUF_CONSTEXPR UploadRecordItem::UploadRecordItem(
    ::_pbi::ConstantInitialized): … { … }
struct UploadRecordItemDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UploadRecordItemDefaultTypeInternal _UploadRecordItem_default_instance_;
PROTOBUF_CONSTEXPR UploadGapItem::UploadGapItem(
    ::_pbi::ConstantInitialized): … { … }
struct UploadGapItemDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UploadGapItemDefaultTypeInternal _UploadGapItem_default_instance_;
PROTOBUF_CONSTEXPR UploadItem::UploadItem(
    ::_pbi::ConstantInitialized): … { … }
struct UploadItemDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UploadItemDefaultTypeInternal _UploadItem_default_instance_;
PROTOBUF_CONSTEXPR UploadEncryptedRecordCall::UploadEncryptedRecordCall(
    ::_pbi::ConstantInitialized): … { … }
struct UploadEncryptedRecordCallDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UploadEncryptedRecordCallDefaultTypeInternal _UploadEncryptedRecordCall_default_instance_;
PROTOBUF_CONSTEXPR ConfirmRecordUploadCall::ConfirmRecordUploadCall(
    ::_pbi::ConstantInitialized): … { … }
struct ConfirmRecordUploadCallDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConfirmRecordUploadCallDefaultTypeInternal _ConfirmRecordUploadCall_default_instance_;
PROTOBUF_CONSTEXPR BlockedRecordCall::BlockedRecordCall(
    ::_pbi::ConstantInitialized): … { … }
struct BlockedRecordCallDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockedRecordCallDefaultTypeInternal _BlockedRecordCall_default_instance_;
PROTOBUF_CONSTEXPR BlockedDestinationsUpdatedCall::BlockedDestinationsUpdatedCall(
    ::_pbi::ConstantInitialized): … { … }
struct BlockedDestinationsUpdatedCallDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockedDestinationsUpdatedCallDefaultTypeInternal _BlockedDestinationsUpdatedCall_default_instance_;
PROTOBUF_CONSTEXPR HealthDataHistory::HealthDataHistory(
    ::_pbi::ConstantInitialized): … { … }
struct HealthDataHistoryDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HealthDataHistoryDefaultTypeInternal _HealthDataHistory_default_instance_;
PROTOBUF_CONSTEXPR ERPHealthData::ERPHealthData(
    ::_pbi::ConstantInitialized): … { … }
struct ERPHealthDataDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ERPHealthDataDefaultTypeInternal _ERPHealthData_default_instance_;
}  // namespace reporting
namespace reporting {

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

class StorageDequeue::_Internal { … };

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

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

StorageDequeue::~StorageDequeue() { … }

inline void StorageDequeue::SharedDtor() { … }

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

void StorageDequeue::Clear() { … }

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

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

size_t StorageDequeue::ByteSizeLong() const { … }

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

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

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

bool StorageDequeue::IsInitialized() const { … }

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

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


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

class StorageEnqueue::_Internal { … };

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

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

StorageEnqueue::~StorageEnqueue() { … }

inline void StorageEnqueue::SharedDtor() { … }

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

void StorageEnqueue::Clear() { … }

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

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

size_t StorageEnqueue::ByteSizeLong() const { … }

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

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

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

bool StorageEnqueue::IsInitialized() const { … }

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

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


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

class StorageQueueAction::_Internal { … };

const ::reporting::StorageDequeue&
StorageQueueAction::_Internal::storage_dequeue(const StorageQueueAction* msg) { … }
const ::reporting::StorageEnqueue&
StorageQueueAction::_Internal::storage_enqueue(const StorageQueueAction* msg) { … }
const ::reporting::StatusProto&
StorageQueueAction::_Internal::status(const StorageQueueAction* msg) { … }
void StorageQueueAction::set_allocated_storage_dequeue(::reporting::StorageDequeue* storage_dequeue) { … }
void StorageQueueAction::set_allocated_storage_enqueue(::reporting::StorageEnqueue* storage_enqueue) { … }
void StorageQueueAction::clear_status() { … }
StorageQueueAction::StorageQueueAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
StorageQueueAction::StorageQueueAction(const StorageQueueAction& from)
  : … { … }

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

StorageQueueAction::~StorageQueueAction() { … }

inline void StorageQueueAction::SharedDtor() { … }

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

void StorageQueueAction::clear_action() { … }


void StorageQueueAction::Clear() { … }

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

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

size_t StorageQueueAction::ByteSizeLong() const { … }

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

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

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

bool StorageQueueAction::IsInitialized() const { … }

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

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


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

class EnqueueRecordCall::_Internal { … };

const ::reporting::StatusProto&
EnqueueRecordCall::_Internal::status(const EnqueueRecordCall* msg) { … }
void EnqueueRecordCall::clear_status() { … }
EnqueueRecordCall::EnqueueRecordCall(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
EnqueueRecordCall::EnqueueRecordCall(const EnqueueRecordCall& from)
  : … { … }

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

EnqueueRecordCall::~EnqueueRecordCall() { … }

inline void EnqueueRecordCall::SharedDtor() { … }

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

void EnqueueRecordCall::Clear() { … }

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

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

size_t EnqueueRecordCall::ByteSizeLong() const { … }

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

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

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

bool EnqueueRecordCall::IsInitialized() const { … }

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

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


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

class FlushPriorityCall::_Internal { … };

const ::reporting::StatusProto&
FlushPriorityCall::_Internal::status(const FlushPriorityCall* msg) { … }
void FlushPriorityCall::clear_status() { … }
FlushPriorityCall::FlushPriorityCall(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
FlushPriorityCall::FlushPriorityCall(const FlushPriorityCall& from)
  : … { … }

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

FlushPriorityCall::~FlushPriorityCall() { … }

inline void FlushPriorityCall::SharedDtor() { … }

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

void FlushPriorityCall::Clear() { … }

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

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

size_t FlushPriorityCall::ByteSizeLong() const { … }

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

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

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

bool FlushPriorityCall::IsInitialized() const { … }

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

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


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

class UploadRecordItem::_Internal { … };

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

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

UploadRecordItem::~UploadRecordItem() { … }

inline void UploadRecordItem::SharedDtor() { … }

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

void UploadRecordItem::Clear() { … }

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

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

size_t UploadRecordItem::ByteSizeLong() const { … }

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

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

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

bool UploadRecordItem::IsInitialized() const { … }

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

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


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

class UploadGapItem::_Internal { … };

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

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

UploadGapItem::~UploadGapItem() { … }

inline void UploadGapItem::SharedDtor() { … }

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

void UploadGapItem::Clear() { … }

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

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

size_t UploadGapItem::ByteSizeLong() const { … }

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

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

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

bool UploadGapItem::IsInitialized() const { … }

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

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


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

class UploadItem::_Internal { … };

const ::reporting::UploadRecordItem&
UploadItem::_Internal::record(const UploadItem* msg) { … }
const ::reporting::UploadGapItem&
UploadItem::_Internal::gap(const UploadItem* msg) { … }
void UploadItem::set_allocated_record(::reporting::UploadRecordItem* record) { … }
void UploadItem::set_allocated_gap(::reporting::UploadGapItem* gap) { … }
UploadItem::UploadItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
UploadItem::UploadItem(const UploadItem& from)
  : … { … }

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

UploadItem::~UploadItem() { … }

inline void UploadItem::SharedDtor() { … }

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

void UploadItem::clear_item() { … }


void UploadItem::Clear() { … }

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

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

size_t UploadItem::ByteSizeLong() const { … }

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

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

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

bool UploadItem::IsInitialized() const { … }

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

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


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

class UploadEncryptedRecordCall::_Internal { … };

const ::reporting::StatusProto&
UploadEncryptedRecordCall::_Internal::status(const UploadEncryptedRecordCall* msg) { … }
void UploadEncryptedRecordCall::clear_status() { … }
UploadEncryptedRecordCall::UploadEncryptedRecordCall(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
UploadEncryptedRecordCall::UploadEncryptedRecordCall(const UploadEncryptedRecordCall& from)
  : … { … }

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

UploadEncryptedRecordCall::~UploadEncryptedRecordCall() { … }

inline void UploadEncryptedRecordCall::SharedDtor() { … }

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

void UploadEncryptedRecordCall::Clear() { … }

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

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

size_t UploadEncryptedRecordCall::ByteSizeLong() const { … }

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

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

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

bool UploadEncryptedRecordCall::IsInitialized() const { … }

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

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


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

class ConfirmRecordUploadCall::_Internal { … };

const ::reporting::StatusProto&
ConfirmRecordUploadCall::_Internal::status(const ConfirmRecordUploadCall* msg) { … }
void ConfirmRecordUploadCall::clear_status() { … }
ConfirmRecordUploadCall::ConfirmRecordUploadCall(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ConfirmRecordUploadCall::ConfirmRecordUploadCall(const ConfirmRecordUploadCall& from)
  : … { … }

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

ConfirmRecordUploadCall::~ConfirmRecordUploadCall() { … }

inline void ConfirmRecordUploadCall::SharedDtor() { … }

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

void ConfirmRecordUploadCall::Clear() { … }

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

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

size_t ConfirmRecordUploadCall::ByteSizeLong() const { … }

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

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

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

bool ConfirmRecordUploadCall::IsInitialized() const { … }

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

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


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

class BlockedRecordCall::_Internal { … };

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

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

BlockedRecordCall::~BlockedRecordCall() { … }

inline void BlockedRecordCall::SharedDtor() { … }

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

void BlockedRecordCall::Clear() { … }

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

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

size_t BlockedRecordCall::ByteSizeLong() const { … }

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

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

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

bool BlockedRecordCall::IsInitialized() const { … }

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

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


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

class BlockedDestinationsUpdatedCall::_Internal { … };

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

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

BlockedDestinationsUpdatedCall::~BlockedDestinationsUpdatedCall() { … }

inline void BlockedDestinationsUpdatedCall::SharedDtor() { … }

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

void BlockedDestinationsUpdatedCall::Clear() { … }

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

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

size_t BlockedDestinationsUpdatedCall::ByteSizeLong() const { … }

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

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

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

bool BlockedDestinationsUpdatedCall::IsInitialized() const { … }

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

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


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

class HealthDataHistory::_Internal { … };

const ::reporting::EnqueueRecordCall&
HealthDataHistory::_Internal::enqueue_record_call(const HealthDataHistory* msg) { … }
const ::reporting::FlushPriorityCall&
HealthDataHistory::_Internal::flush_priority_call(const HealthDataHistory* msg) { … }
const ::reporting::UploadEncryptedRecordCall&
HealthDataHistory::_Internal::upload_encrypted_record_call(const HealthDataHistory* msg) { … }
const ::reporting::ConfirmRecordUploadCall&
HealthDataHistory::_Internal::confirm_record_upload_call(const HealthDataHistory* msg) { … }
const ::reporting::StorageQueueAction&
HealthDataHistory::_Internal::storage_queue_action(const HealthDataHistory* msg) { … }
const ::reporting::BlockedRecordCall&
HealthDataHistory::_Internal::blocked_record_call(const HealthDataHistory* msg) { … }
const ::reporting::BlockedDestinationsUpdatedCall&
HealthDataHistory::_Internal::blocked_destinations_updated_call(const HealthDataHistory* msg) { … }
void HealthDataHistory::set_allocated_enqueue_record_call(::reporting::EnqueueRecordCall* enqueue_record_call) { … }
void HealthDataHistory::set_allocated_flush_priority_call(::reporting::FlushPriorityCall* flush_priority_call) { … }
void HealthDataHistory::set_allocated_upload_encrypted_record_call(::reporting::UploadEncryptedRecordCall* upload_encrypted_record_call) { … }
void HealthDataHistory::set_allocated_confirm_record_upload_call(::reporting::ConfirmRecordUploadCall* confirm_record_upload_call) { … }
void HealthDataHistory::set_allocated_storage_queue_action(::reporting::StorageQueueAction* storage_queue_action) { … }
void HealthDataHistory::set_allocated_blocked_record_call(::reporting::BlockedRecordCall* blocked_record_call) { … }
void HealthDataHistory::set_allocated_blocked_destinations_updated_call(::reporting::BlockedDestinationsUpdatedCall* blocked_destinations_updated_call) { … }
HealthDataHistory::HealthDataHistory(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
HealthDataHistory::HealthDataHistory(const HealthDataHistory& from)
  : … { … }

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

HealthDataHistory::~HealthDataHistory() { … }

inline void HealthDataHistory::SharedDtor() { … }

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

void HealthDataHistory::clear_record() { … }


void HealthDataHistory::Clear() { … }

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

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

size_t HealthDataHistory::ByteSizeLong() const { … }

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

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

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

bool HealthDataHistory::IsInitialized() const { … }

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

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


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

class ERPHealthData::_Internal { … };

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

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

ERPHealthData::~ERPHealthData() { … }

inline void ERPHealthData::SharedDtor() { … }

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

void ERPHealthData::Clear() { … }

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

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

size_t ERPHealthData::ByteSizeLong() const { … }

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

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

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

bool ERPHealthData::IsInitialized() const { … }

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace reporting
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::reporting::StorageDequeue*
Arena::CreateMaybeMessage< ::reporting::StorageDequeue >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::StorageEnqueue*
Arena::CreateMaybeMessage< ::reporting::StorageEnqueue >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::StorageQueueAction*
Arena::CreateMaybeMessage< ::reporting::StorageQueueAction >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::EnqueueRecordCall*
Arena::CreateMaybeMessage< ::reporting::EnqueueRecordCall >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::FlushPriorityCall*
Arena::CreateMaybeMessage< ::reporting::FlushPriorityCall >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::UploadRecordItem*
Arena::CreateMaybeMessage< ::reporting::UploadRecordItem >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::UploadGapItem*
Arena::CreateMaybeMessage< ::reporting::UploadGapItem >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::UploadItem*
Arena::CreateMaybeMessage< ::reporting::UploadItem >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::UploadEncryptedRecordCall*
Arena::CreateMaybeMessage< ::reporting::UploadEncryptedRecordCall >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::ConfirmRecordUploadCall*
Arena::CreateMaybeMessage< ::reporting::ConfirmRecordUploadCall >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::BlockedRecordCall*
Arena::CreateMaybeMessage< ::reporting::BlockedRecordCall >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::BlockedDestinationsUpdatedCall*
Arena::CreateMaybeMessage< ::reporting::BlockedDestinationsUpdatedCall >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::HealthDataHistory*
Arena::CreateMaybeMessage< ::reporting::HealthDataHistory >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::reporting::ERPHealthData*
Arena::CreateMaybeMessage< ::reporting::ERPHealthData >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
chromium/out/Default/gen/components/reporting/proto/synced/health.pb.cc
