chromium/out/Default/gen/components/feed/core/proto/v2/ui.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: components/feed/core/proto/v2/ui.proto

#include "components/feed/core/proto/v2/ui.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 feedui {
PROTOBUF_CONSTEXPR StreamUpdate_SliceUpdate::StreamUpdate_SliceUpdate(
    ::_pbi::ConstantInitialized): … { … }
struct StreamUpdate_SliceUpdateDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StreamUpdate_SliceUpdateDefaultTypeInternal _StreamUpdate_SliceUpdate_default_instance_;
PROTOBUF_CONSTEXPR StreamUpdate::StreamUpdate(
    ::_pbi::ConstantInitialized): … { … }
struct StreamUpdateDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StreamUpdateDefaultTypeInternal _StreamUpdate_default_instance_;
PROTOBUF_CONSTEXPR LoggingParameters::LoggingParameters(
    ::_pbi::ConstantInitialized): … { … }
struct LoggingParametersDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoggingParametersDefaultTypeInternal _LoggingParameters_default_instance_;
PROTOBUF_CONSTEXPR Slice::Slice(
    ::_pbi::ConstantInitialized): … { … }
struct SliceDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SliceDefaultTypeInternal _Slice_default_instance_;
PROTOBUF_CONSTEXPR ZeroStateSlice::ZeroStateSlice(
    ::_pbi::ConstantInitialized): … { … }
struct ZeroStateSliceDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ZeroStateSliceDefaultTypeInternal _ZeroStateSlice_default_instance_;
PROTOBUF_CONSTEXPR LoadingSpinnerSlice::LoadingSpinnerSlice(
    ::_pbi::ConstantInitialized): … { … }
struct LoadingSpinnerSliceDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadingSpinnerSliceDefaultTypeInternal _LoadingSpinnerSlice_default_instance_;
PROTOBUF_CONSTEXPR XSurfaceSlice::XSurfaceSlice(
    ::_pbi::ConstantInitialized): … { … }
struct XSurfaceSliceDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XSurfaceSliceDefaultTypeInternal _XSurfaceSlice_default_instance_;
PROTOBUF_CONSTEXPR SharedState::SharedState(
    ::_pbi::ConstantInitialized): … { … }
struct SharedStateDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SharedStateDefaultTypeInternal _SharedState_default_instance_;
}  // namespace feedui
namespace feedui {
bool ZeroStateSlice_Type_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ZeroStateSlice_Type_strings[4] = …;

static const char ZeroStateSlice_Type_names[] = …;

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

static const int ZeroStateSlice_Type_entries_by_number[] = …;

const std::string& ZeroStateSlice_Type_Name(
    ZeroStateSlice_Type value) { … }
bool ZeroStateSlice_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ZeroStateSlice_Type* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr ZeroStateSlice_Type ZeroStateSlice::UNKNOWN;
constexpr ZeroStateSlice_Type ZeroStateSlice::NO_CARDS_AVAILABLE;
constexpr ZeroStateSlice_Type ZeroStateSlice::CANT_REFRESH;
constexpr ZeroStateSlice_Type ZeroStateSlice::NO_WEB_FEED_SUBSCRIPTIONS;
constexpr ZeroStateSlice_Type ZeroStateSlice::Type_MIN;
constexpr ZeroStateSlice_Type ZeroStateSlice::Type_MAX;
constexpr int ZeroStateSlice::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class StreamUpdate_SliceUpdate::_Internal { … };

const ::feedui::Slice&
StreamUpdate_SliceUpdate::_Internal::slice(const StreamUpdate_SliceUpdate* msg) { … }
void StreamUpdate_SliceUpdate::set_allocated_slice(::feedui::Slice* slice) { … }
StreamUpdate_SliceUpdate::StreamUpdate_SliceUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
StreamUpdate_SliceUpdate::StreamUpdate_SliceUpdate(const StreamUpdate_SliceUpdate& from)
  : … { … }

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

StreamUpdate_SliceUpdate::~StreamUpdate_SliceUpdate() { … }

inline void StreamUpdate_SliceUpdate::SharedDtor() { … }

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

void StreamUpdate_SliceUpdate::clear_update() { … }


void StreamUpdate_SliceUpdate::Clear() { … }

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

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

size_t StreamUpdate_SliceUpdate::ByteSizeLong() const { … }

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

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

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

bool StreamUpdate_SliceUpdate::IsInitialized() const { … }

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

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


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

class StreamUpdate::_Internal { … };

const ::feedui::LoggingParameters&
StreamUpdate::_Internal::logging_parameters(const StreamUpdate* msg) { … }
StreamUpdate::StreamUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
StreamUpdate::StreamUpdate(const StreamUpdate& from)
  : … { … }

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

StreamUpdate::~StreamUpdate() { … }

inline void StreamUpdate::SharedDtor() { … }

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

void StreamUpdate::Clear() { … }

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

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

size_t StreamUpdate::ByteSizeLong() const { … }

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

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

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

bool StreamUpdate::IsInitialized() const { … }

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

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


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

class LoggingParameters::_Internal { … };

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

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

LoggingParameters::~LoggingParameters() { … }

inline void LoggingParameters::SharedDtor() { … }

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

void LoggingParameters::Clear() { … }

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

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

size_t LoggingParameters::ByteSizeLong() const { … }

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

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

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

bool LoggingParameters::IsInitialized() const { … }

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

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


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

class Slice::_Internal { … };

const ::feedui::XSurfaceSlice&
Slice::_Internal::xsurface_slice(const Slice* msg) { … }
const ::feedui::ZeroStateSlice&
Slice::_Internal::zero_state_slice(const Slice* msg) { … }
const ::feedui::LoadingSpinnerSlice&
Slice::_Internal::loading_spinner_slice(const Slice* msg) { … }
void Slice::set_allocated_xsurface_slice(::feedui::XSurfaceSlice* xsurface_slice) { … }
void Slice::set_allocated_zero_state_slice(::feedui::ZeroStateSlice* zero_state_slice) { … }
void Slice::set_allocated_loading_spinner_slice(::feedui::LoadingSpinnerSlice* loading_spinner_slice) { … }
Slice::Slice(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
Slice::Slice(const Slice& from)
  : … { … }

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

Slice::~Slice() { … }

inline void Slice::SharedDtor() { … }

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

void Slice::clear_SliceData() { … }


void Slice::Clear() { … }

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

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

size_t Slice::ByteSizeLong() const { … }

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

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

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

bool Slice::IsInitialized() const { … }

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

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


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

class ZeroStateSlice::_Internal { … };

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

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

ZeroStateSlice::~ZeroStateSlice() { … }

inline void ZeroStateSlice::SharedDtor() { … }

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

void ZeroStateSlice::Clear() { … }

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

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

size_t ZeroStateSlice::ByteSizeLong() const { … }

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

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

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

bool ZeroStateSlice::IsInitialized() const { … }

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

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


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

class LoadingSpinnerSlice::_Internal { … };

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

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

LoadingSpinnerSlice::~LoadingSpinnerSlice() { … }

inline void LoadingSpinnerSlice::SharedDtor() { … }

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

void LoadingSpinnerSlice::Clear() { … }

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

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

size_t LoadingSpinnerSlice::ByteSizeLong() const { … }

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

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

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

bool LoadingSpinnerSlice::IsInitialized() const { … }

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

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


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

class XSurfaceSlice::_Internal { … };

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

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

XSurfaceSlice::~XSurfaceSlice() { … }

inline void XSurfaceSlice::SharedDtor() { … }

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

void XSurfaceSlice::Clear() { … }

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

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

size_t XSurfaceSlice::ByteSizeLong() const { … }

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

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

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

bool XSurfaceSlice::IsInitialized() const { … }

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

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


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

class SharedState::_Internal { … };

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

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

SharedState::~SharedState() { … }

inline void SharedState::SharedDtor() { … }

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

void SharedState::Clear() { … }

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

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

size_t SharedState::ByteSizeLong() const { … }

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

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

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

bool SharedState::IsInitialized() const { … }

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace feedui
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::feedui::StreamUpdate_SliceUpdate*
Arena::CreateMaybeMessage< ::feedui::StreamUpdate_SliceUpdate >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::feedui::StreamUpdate*
Arena::CreateMaybeMessage< ::feedui::StreamUpdate >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::feedui::LoggingParameters*
Arena::CreateMaybeMessage< ::feedui::LoggingParameters >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::feedui::Slice*
Arena::CreateMaybeMessage< ::feedui::Slice >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::feedui::ZeroStateSlice*
Arena::CreateMaybeMessage< ::feedui::ZeroStateSlice >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::feedui::LoadingSpinnerSlice*
Arena::CreateMaybeMessage< ::feedui::LoadingSpinnerSlice >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::feedui::XSurfaceSlice*
Arena::CreateMaybeMessage< ::feedui::XSurfaceSlice >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::feedui::SharedState*
Arena::CreateMaybeMessage< ::feedui::SharedState >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

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