nn_classifier.pb.cc | Explore in Territory

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

#include "nn_classifier.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 assist_ranker {
PROTOBUF_CONSTEXPR FloatVector::FloatVector(
    ::_pbi::ConstantInitialized): … { … }
struct FloatVectorDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FloatVectorDefaultTypeInternal _FloatVector_default_instance_;
PROTOBUF_CONSTEXPR NNLayer::NNLayer(
    ::_pbi::ConstantInitialized): … { … }
struct NNLayerDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NNLayerDefaultTypeInternal _NNLayer_default_instance_;
PROTOBUF_CONSTEXPR NNClassifierModel::NNClassifierModel(
    ::_pbi::ConstantInitialized): … { … }
struct NNClassifierModelDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NNClassifierModelDefaultTypeInternal _NNClassifierModel_default_instance_;
}  // namespace assist_ranker
namespace assist_ranker {

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

class FloatVector::_Internal { … };

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

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

FloatVector::~FloatVector() { … }

inline void FloatVector::SharedDtor() { … }

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

void FloatVector::Clear() { … }

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

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

size_t FloatVector::ByteSizeLong() const { … }

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

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

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

bool FloatVector::IsInitialized() const { … }

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

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


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

class NNLayer::_Internal { … };

const ::assist_ranker::FloatVector&
NNLayer::_Internal::biases(const NNLayer* msg) { … }
NNLayer::NNLayer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
NNLayer::NNLayer(const NNLayer& from)
  : … { … }

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

NNLayer::~NNLayer() { … }

inline void NNLayer::SharedDtor() { … }

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

void NNLayer::Clear() { … }

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

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

size_t NNLayer::ByteSizeLong() const { … }

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

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

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

bool NNLayer::IsInitialized() const { … }

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

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


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

class NNClassifierModel::_Internal { … };

const ::assist_ranker::NNLayer&
NNClassifierModel::_Internal::hidden_layer(const NNClassifierModel* msg) { … }
const ::assist_ranker::NNLayer&
NNClassifierModel::_Internal::logits_layer(const NNClassifierModel* msg) { … }
const ::assist_ranker::ExamplePreprocessorConfig&
NNClassifierModel::_Internal::preprocessor_config(const NNClassifierModel* msg) { … }
void NNClassifierModel::clear_preprocessor_config() { … }
NNClassifierModel::NNClassifierModel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
NNClassifierModel::NNClassifierModel(const NNClassifierModel& from)
  : … { … }

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

NNClassifierModel::~NNClassifierModel() { … }

inline void NNClassifierModel::SharedDtor() { … }

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

void NNClassifierModel::Clear() { … }

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

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

size_t NNClassifierModel::ByteSizeLong() const { … }

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

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

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

bool NNClassifierModel::IsInitialized() const { … }

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace assist_ranker
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::assist_ranker::FloatVector*
Arena::CreateMaybeMessage< ::assist_ranker::FloatVector >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::assist_ranker::NNLayer*
Arena::CreateMaybeMessage< ::assist_ranker::NNLayer >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::assist_ranker::NNClassifierModel*
Arena::CreateMaybeMessage< ::assist_ranker::NNClassifierModel >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

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