visual_search_model_metadata.pb.cc | Explore in Territory

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: components/optimization_guide/proto/visual_search_model_metadata.proto

#include "components/optimization_guide/proto/visual_search_model_metadata.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 optimization_guide {
namespace proto {
PROTOBUF_CONSTEXPR FeatureLibrary::FeatureLibrary(
    ::_pbi::ConstantInitialized): … { … }
struct FeatureLibraryDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeatureLibraryDefaultTypeInternal _FeatureLibrary_default_instance_;
PROTOBUF_CONSTEXPR ThresholdingRule::ThresholdingRule(
    ::_pbi::ConstantInitialized): … { … }
struct ThresholdingRuleDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ThresholdingRuleDefaultTypeInternal _ThresholdingRule_default_instance_;
PROTOBUF_CONSTEXPR OrOfThresholdingRules::OrOfThresholdingRules(
    ::_pbi::ConstantInitialized): … { … }
struct OrOfThresholdingRulesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OrOfThresholdingRulesDefaultTypeInternal _OrOfThresholdingRules_default_instance_;
PROTOBUF_CONSTEXPR SortingClause::SortingClause(
    ::_pbi::ConstantInitialized): … { … }
struct SortingClauseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SortingClauseDefaultTypeInternal _SortingClause_default_instance_;
PROTOBUF_CONSTEXPR AdditionalCheapPruningOptions::AdditionalCheapPruningOptions(
    ::_pbi::ConstantInitialized): … { … }
struct AdditionalCheapPruningOptionsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AdditionalCheapPruningOptionsDefaultTypeInternal _AdditionalCheapPruningOptions_default_instance_;
PROTOBUF_CONSTEXPR EligibilitySpec::EligibilitySpec(
    ::_pbi::ConstantInitialized): … { … }
struct EligibilitySpecDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EligibilitySpecDefaultTypeInternal _EligibilitySpec_default_instance_;
PROTOBUF_CONSTEXPR VisualSearchModelMetadata::VisualSearchModelMetadata(
    ::_pbi::ConstantInitialized): … { … }
struct VisualSearchModelMetadataDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VisualSearchModelMetadataDefaultTypeInternal _VisualSearchModelMetadata_default_instance_;
}  // namespace proto
}  // namespace optimization_guide
namespace optimization_guide {
namespace proto {
bool FeatureLibrary_ImageLevelFeatureName_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> FeatureLibrary_ImageLevelFeatureName_strings[16] = …;

static const char FeatureLibrary_ImageLevelFeatureName_names[] = …;

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

static const int FeatureLibrary_ImageLevelFeatureName_entries_by_number[] = …;

const std::string& FeatureLibrary_ImageLevelFeatureName_Name(
    FeatureLibrary_ImageLevelFeatureName value) { … }
bool FeatureLibrary_ImageLevelFeatureName_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FeatureLibrary_ImageLevelFeatureName* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_LEVEL_UNSPECIFIED;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_ORIGINAL_AREA;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_ORIGINAL_ASPECT_RATIO;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_ORIGINAL_HEIGHT;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_ORIGINAL_WIDTH;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_ONPAGE_AREA;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_ONPAGE_HEIGHT;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_ONPAGE_WIDTH;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_ONPAGE_ASPECT_RATIO;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_VISIBLE_AREA;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_FRACTION_VISIBLE;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::IMAGE_DISTANCE_TO_VIEWPORT_CENTER;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::SHOPPING_CLASSIFIER_SCORE;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::SENS_CLASSIFIER_SCORE;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::NAT_WORLD_CLASSIFIER_SCORE;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::PUB_FIGURES_CLASSIFIER_SCORE;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::ImageLevelFeatureName_MIN;
constexpr FeatureLibrary_ImageLevelFeatureName FeatureLibrary::ImageLevelFeatureName_MAX;
constexpr int FeatureLibrary::ImageLevelFeatureName_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool FeatureLibrary_NormalizingOp_IsValid(int value) { … }

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

static const char FeatureLibrary_NormalizingOp_names[] = …;

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

static const int FeatureLibrary_NormalizingOp_entries_by_number[] = …;

const std::string& FeatureLibrary_NormalizingOp_Name(
    FeatureLibrary_NormalizingOp value) { … }
bool FeatureLibrary_NormalizingOp_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FeatureLibrary_NormalizingOp* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr FeatureLibrary_NormalizingOp FeatureLibrary::NORMALIZE_UNSPECIFIED;
constexpr FeatureLibrary_NormalizingOp FeatureLibrary::BY_VIEWPORT_AREA;
constexpr FeatureLibrary_NormalizingOp FeatureLibrary::BY_MAX_VALUE;
constexpr FeatureLibrary_NormalizingOp FeatureLibrary::NormalizingOp_MIN;
constexpr FeatureLibrary_NormalizingOp FeatureLibrary::NormalizingOp_MAX;
constexpr int FeatureLibrary::NormalizingOp_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool FeatureLibrary_ThresholdingOp_IsValid(int value) { … }

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

static const char FeatureLibrary_ThresholdingOp_names[] = …;

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

static const int FeatureLibrary_ThresholdingOp_entries_by_number[] = …;

const std::string& FeatureLibrary_ThresholdingOp_Name(
    FeatureLibrary_ThresholdingOp value) { … }
bool FeatureLibrary_ThresholdingOp_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FeatureLibrary_ThresholdingOp* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr FeatureLibrary_ThresholdingOp FeatureLibrary::THRESHOLDING_UNSPECIFIED;
constexpr FeatureLibrary_ThresholdingOp FeatureLibrary::GT;
constexpr FeatureLibrary_ThresholdingOp FeatureLibrary::LT;
constexpr FeatureLibrary_ThresholdingOp FeatureLibrary::ThresholdingOp_MIN;
constexpr FeatureLibrary_ThresholdingOp FeatureLibrary::ThresholdingOp_MAX;
constexpr int FeatureLibrary::ThresholdingOp_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool FeatureLibrary_SortingOrder_IsValid(int value) { … }

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

static const char FeatureLibrary_SortingOrder_names[] = …;

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

static const int FeatureLibrary_SortingOrder_entries_by_number[] = …;

const std::string& FeatureLibrary_SortingOrder_Name(
    FeatureLibrary_SortingOrder value) { … }
bool FeatureLibrary_SortingOrder_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FeatureLibrary_SortingOrder* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr FeatureLibrary_SortingOrder FeatureLibrary::SORT_UNSPECIFIED;
constexpr FeatureLibrary_SortingOrder FeatureLibrary::SORT_ASCENDING;
constexpr FeatureLibrary_SortingOrder FeatureLibrary::SORT_DESCENDING;
constexpr FeatureLibrary_SortingOrder FeatureLibrary::SortingOrder_MIN;
constexpr FeatureLibrary_SortingOrder FeatureLibrary::SortingOrder_MAX;
constexpr int FeatureLibrary::SortingOrder_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class FeatureLibrary::_Internal { … };

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

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

FeatureLibrary::~FeatureLibrary() { … }

inline void FeatureLibrary::SharedDtor() { … }

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

void FeatureLibrary::Clear() { … }

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

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

size_t FeatureLibrary::ByteSizeLong() const { … }

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

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

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

bool FeatureLibrary::IsInitialized() const { … }

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

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


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

class ThresholdingRule::_Internal { … };

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

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

ThresholdingRule::~ThresholdingRule() { … }

inline void ThresholdingRule::SharedDtor() { … }

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

void ThresholdingRule::Clear() { … }

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

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

size_t ThresholdingRule::ByteSizeLong() const { … }

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

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

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

bool ThresholdingRule::IsInitialized() const { … }

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

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


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

class OrOfThresholdingRules::_Internal { … };

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

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

OrOfThresholdingRules::~OrOfThresholdingRules() { … }

inline void OrOfThresholdingRules::SharedDtor() { … }

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

void OrOfThresholdingRules::Clear() { … }

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

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

size_t OrOfThresholdingRules::ByteSizeLong() const { … }

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

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

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

bool OrOfThresholdingRules::IsInitialized() const { … }

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

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


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

class SortingClause::_Internal { … };

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

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

SortingClause::~SortingClause() { … }

inline void SortingClause::SharedDtor() { … }

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

void SortingClause::Clear() { … }

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

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

size_t SortingClause::ByteSizeLong() const { … }

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

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

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

bool SortingClause::IsInitialized() const { … }

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

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


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

class AdditionalCheapPruningOptions::_Internal { … };

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

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

AdditionalCheapPruningOptions::~AdditionalCheapPruningOptions() { … }

inline void AdditionalCheapPruningOptions::SharedDtor() { … }

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

void AdditionalCheapPruningOptions::Clear() { … }

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

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

size_t AdditionalCheapPruningOptions::ByteSizeLong() const { … }

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

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

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

bool AdditionalCheapPruningOptions::IsInitialized() const { … }

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

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


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

class EligibilitySpec::_Internal { … };

const ::optimization_guide::proto::AdditionalCheapPruningOptions&
EligibilitySpec::_Internal::additional_cheap_pruning_options(const EligibilitySpec* msg) { … }
EligibilitySpec::EligibilitySpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
EligibilitySpec::EligibilitySpec(const EligibilitySpec& from)
  : … { … }

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

EligibilitySpec::~EligibilitySpec() { … }

inline void EligibilitySpec::SharedDtor() { … }

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

void EligibilitySpec::Clear() { … }

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

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

size_t EligibilitySpec::ByteSizeLong() const { … }

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

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

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

bool EligibilitySpec::IsInitialized() const { … }

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

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


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

class VisualSearchModelMetadata::_Internal { … };

const ::optimization_guide::proto::EligibilitySpec&
VisualSearchModelMetadata::_Internal::eligibility_spec(const VisualSearchModelMetadata* msg) { … }
VisualSearchModelMetadata::VisualSearchModelMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
VisualSearchModelMetadata::VisualSearchModelMetadata(const VisualSearchModelMetadata& from)
  : … { … }

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

VisualSearchModelMetadata::~VisualSearchModelMetadata() { … }

inline void VisualSearchModelMetadata::SharedDtor() { … }

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

void VisualSearchModelMetadata::Clear() { … }

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

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

size_t VisualSearchModelMetadata::ByteSizeLong() const { … }

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

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

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

bool VisualSearchModelMetadata::IsInitialized() const { … }

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace proto
}  // namespace optimization_guide
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::optimization_guide::proto::FeatureLibrary*
Arena::CreateMaybeMessage< ::optimization_guide::proto::FeatureLibrary >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::optimization_guide::proto::ThresholdingRule*
Arena::CreateMaybeMessage< ::optimization_guide::proto::ThresholdingRule >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::optimization_guide::proto::OrOfThresholdingRules*
Arena::CreateMaybeMessage< ::optimization_guide::proto::OrOfThresholdingRules >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::optimization_guide::proto::SortingClause*
Arena::CreateMaybeMessage< ::optimization_guide::proto::SortingClause >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::optimization_guide::proto::AdditionalCheapPruningOptions*
Arena::CreateMaybeMessage< ::optimization_guide::proto::AdditionalCheapPruningOptions >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::optimization_guide::proto::EligibilitySpec*
Arena::CreateMaybeMessage< ::optimization_guide::proto::EligibilitySpec >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::optimization_guide::proto::VisualSearchModelMetadata*
Arena::CreateMaybeMessage< ::optimization_guide::proto::VisualSearchModelMetadata >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

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