wehub/alibaba--mnn
1
0
Fork 0
Code Issues Pull Requests Actions Deployments Models Agent Notes Packages Projects Releases Wiki Activity
Files
main
alibaba--mnn/tools/converter/source/caffe/generated/caffe.pb.h
T
wehub-resource-sync 5b57521aa1 chore: import upstream snapshot with attribution
2026-07-13 13:33:03 +08:00

61065 lines
2.2 MiB
Plaintext
Raw Permalink Blame History

// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: caffe.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_caffe_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_caffe_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_bases.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_caffe_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_caffe_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[99]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_caffe_2eproto;
namespace caffe {
class AccuracyParameter;
struct AccuracyParameterDefaultTypeInternal;
extern AccuracyParameterDefaultTypeInternal _AccuracyParameter_default_instance_;
class AnnotatedDataParameter;
struct AnnotatedDataParameterDefaultTypeInternal;
extern AnnotatedDataParameterDefaultTypeInternal _AnnotatedDataParameter_default_instance_;
class AnnotatedDatum;
struct AnnotatedDatumDefaultTypeInternal;
extern AnnotatedDatumDefaultTypeInternal _AnnotatedDatum_default_instance_;
class Annotation;
struct AnnotationDefaultTypeInternal;
extern AnnotationDefaultTypeInternal _Annotation_default_instance_;
class AnnotationGroup;
struct AnnotationGroupDefaultTypeInternal;
extern AnnotationGroupDefaultTypeInternal _AnnotationGroup_default_instance_;
class ArgMaxParameter;
struct ArgMaxParameterDefaultTypeInternal;
extern ArgMaxParameterDefaultTypeInternal _ArgMaxParameter_default_instance_;
class BatchNormParameter;
struct BatchNormParameterDefaultTypeInternal;
extern BatchNormParameterDefaultTypeInternal _BatchNormParameter_default_instance_;
class BatchSampler;
struct BatchSamplerDefaultTypeInternal;
extern BatchSamplerDefaultTypeInternal _BatchSampler_default_instance_;
class BiasParameter;
struct BiasParameterDefaultTypeInternal;
extern BiasParameterDefaultTypeInternal _BiasParameter_default_instance_;
class BlobProto;
struct BlobProtoDefaultTypeInternal;
extern BlobProtoDefaultTypeInternal _BlobProto_default_instance_;
class BlobProtoVector;
struct BlobProtoVectorDefaultTypeInternal;
extern BlobProtoVectorDefaultTypeInternal _BlobProtoVector_default_instance_;
class BlobShape;
struct BlobShapeDefaultTypeInternal;
extern BlobShapeDefaultTypeInternal _BlobShape_default_instance_;
class CenterLossParameter;
struct CenterLossParameterDefaultTypeInternal;
extern CenterLossParameterDefaultTypeInternal _CenterLossParameter_default_instance_;
class ClipParameter;
struct ClipParameterDefaultTypeInternal;
extern ClipParameterDefaultTypeInternal _ClipParameter_default_instance_;
class ConcatParameter;
struct ConcatParameterDefaultTypeInternal;
extern ConcatParameterDefaultTypeInternal _ConcatParameter_default_instance_;
class ContrastiveLossParameter;
struct ContrastiveLossParameterDefaultTypeInternal;
extern ContrastiveLossParameterDefaultTypeInternal _ContrastiveLossParameter_default_instance_;
class Convolution3DParameter;
struct Convolution3DParameterDefaultTypeInternal;
extern Convolution3DParameterDefaultTypeInternal _Convolution3DParameter_default_instance_;
class ConvolutionParameter;
struct ConvolutionParameterDefaultTypeInternal;
extern ConvolutionParameterDefaultTypeInternal _ConvolutionParameter_default_instance_;
class CropParameter;
struct CropParameterDefaultTypeInternal;
extern CropParameterDefaultTypeInternal _CropParameter_default_instance_;
class DataParameter;
struct DataParameterDefaultTypeInternal;
extern DataParameterDefaultTypeInternal _DataParameter_default_instance_;
class Datum;
struct DatumDefaultTypeInternal;
extern DatumDefaultTypeInternal _Datum_default_instance_;
class DetectionEvaluateParameter;
struct DetectionEvaluateParameterDefaultTypeInternal;
extern DetectionEvaluateParameterDefaultTypeInternal _DetectionEvaluateParameter_default_instance_;
class DetectionOutputParameter;
struct DetectionOutputParameterDefaultTypeInternal;
extern DetectionOutputParameterDefaultTypeInternal _DetectionOutputParameter_default_instance_;
class DistortionParameter;
struct DistortionParameterDefaultTypeInternal;
extern DistortionParameterDefaultTypeInternal _DistortionParameter_default_instance_;
class DropoutParameter;
struct DropoutParameterDefaultTypeInternal;
extern DropoutParameterDefaultTypeInternal _DropoutParameter_default_instance_;
class DummyDataParameter;
struct DummyDataParameterDefaultTypeInternal;
extern DummyDataParameterDefaultTypeInternal _DummyDataParameter_default_instance_;
class ELUParameter;
struct ELUParameterDefaultTypeInternal;
extern ELUParameterDefaultTypeInternal _ELUParameter_default_instance_;
class EltwiseParameter;
struct EltwiseParameterDefaultTypeInternal;
extern EltwiseParameterDefaultTypeInternal _EltwiseParameter_default_instance_;
class EmbedParameter;
struct EmbedParameterDefaultTypeInternal;
extern EmbedParameterDefaultTypeInternal _EmbedParameter_default_instance_;
class EmitConstraint;
struct EmitConstraintDefaultTypeInternal;
extern EmitConstraintDefaultTypeInternal _EmitConstraint_default_instance_;
class ExpParameter;
struct ExpParameterDefaultTypeInternal;
extern ExpParameterDefaultTypeInternal _ExpParameter_default_instance_;
class ExpansionParameter;
struct ExpansionParameterDefaultTypeInternal;
extern ExpansionParameterDefaultTypeInternal _ExpansionParameter_default_instance_;
class FillerParameter;
struct FillerParameterDefaultTypeInternal;
extern FillerParameterDefaultTypeInternal _FillerParameter_default_instance_;
class FlattenParameter;
struct FlattenParameterDefaultTypeInternal;
extern FlattenParameterDefaultTypeInternal _FlattenParameter_default_instance_;
class HDF5DataParameter;
struct HDF5DataParameterDefaultTypeInternal;
extern HDF5DataParameterDefaultTypeInternal _HDF5DataParameter_default_instance_;
class HDF5OutputParameter;
struct HDF5OutputParameterDefaultTypeInternal;
extern HDF5OutputParameterDefaultTypeInternal _HDF5OutputParameter_default_instance_;
class HingeLossParameter;
struct HingeLossParameterDefaultTypeInternal;
extern HingeLossParameterDefaultTypeInternal _HingeLossParameter_default_instance_;
class Im2seqParameter;
struct Im2seqParameterDefaultTypeInternal;
extern Im2seqParameterDefaultTypeInternal _Im2seqParameter_default_instance_;
class ImageDataParameter;
struct ImageDataParameterDefaultTypeInternal;
extern ImageDataParameterDefaultTypeInternal _ImageDataParameter_default_instance_;
class ImgSizeParameter;
struct ImgSizeParameterDefaultTypeInternal;
extern ImgSizeParameterDefaultTypeInternal _ImgSizeParameter_default_instance_;
class InfogainLossParameter;
struct InfogainLossParameterDefaultTypeInternal;
extern InfogainLossParameterDefaultTypeInternal _InfogainLossParameter_default_instance_;
class InnerProductParameter;
struct InnerProductParameterDefaultTypeInternal;
extern InnerProductParameterDefaultTypeInternal _InnerProductParameter_default_instance_;
class InputParameter;
struct InputParameterDefaultTypeInternal;
extern InputParameterDefaultTypeInternal _InputParameter_default_instance_;
class InterpParameter;
struct InterpParameterDefaultTypeInternal;
extern InterpParameterDefaultTypeInternal _InterpParameter_default_instance_;
class LRNParameter;
struct LRNParameterDefaultTypeInternal;
extern LRNParameterDefaultTypeInternal _LRNParameter_default_instance_;
class LSTMParameter;
struct LSTMParameterDefaultTypeInternal;
extern LSTMParameterDefaultTypeInternal _LSTMParameter_default_instance_;
class LabelMap;
struct LabelMapDefaultTypeInternal;
extern LabelMapDefaultTypeInternal _LabelMap_default_instance_;
class LabelMapItem;
struct LabelMapItemDefaultTypeInternal;
extern LabelMapItemDefaultTypeInternal _LabelMapItem_default_instance_;
class LayerParameter;
struct LayerParameterDefaultTypeInternal;
extern LayerParameterDefaultTypeInternal _LayerParameter_default_instance_;
class LogParameter;
struct LogParameterDefaultTypeInternal;
extern LogParameterDefaultTypeInternal _LogParameter_default_instance_;
class LossParameter;
struct LossParameterDefaultTypeInternal;
extern LossParameterDefaultTypeInternal _LossParameter_default_instance_;
class MTCNNBBox;
struct MTCNNBBoxDefaultTypeInternal;
extern MTCNNBBoxDefaultTypeInternal _MTCNNBBox_default_instance_;
class MTCNNDatum;
struct MTCNNDatumDefaultTypeInternal;
extern MTCNNDatumDefaultTypeInternal _MTCNNDatum_default_instance_;
class MVNParameter;
struct MVNParameterDefaultTypeInternal;
extern MVNParameterDefaultTypeInternal _MVNParameter_default_instance_;
class MemoryDataParameter;
struct MemoryDataParameterDefaultTypeInternal;
extern MemoryDataParameterDefaultTypeInternal _MemoryDataParameter_default_instance_;
class MultiBoxLossParameter;
struct MultiBoxLossParameterDefaultTypeInternal;
extern MultiBoxLossParameterDefaultTypeInternal _MultiBoxLossParameter_default_instance_;
class NetParameter;
struct NetParameterDefaultTypeInternal;
extern NetParameterDefaultTypeInternal _NetParameter_default_instance_;
class NetState;
struct NetStateDefaultTypeInternal;
extern NetStateDefaultTypeInternal _NetState_default_instance_;
class NetStateRule;
struct NetStateRuleDefaultTypeInternal;
extern NetStateRuleDefaultTypeInternal _NetStateRule_default_instance_;
class NoiseParameter;
struct NoiseParameterDefaultTypeInternal;
extern NoiseParameterDefaultTypeInternal _NoiseParameter_default_instance_;
class NonMaximumSuppressionParameter;
struct NonMaximumSuppressionParameterDefaultTypeInternal;
extern NonMaximumSuppressionParameterDefaultTypeInternal _NonMaximumSuppressionParameter_default_instance_;
class NormalizeParameter;
struct NormalizeParameterDefaultTypeInternal;
extern NormalizeParameterDefaultTypeInternal _NormalizeParameter_default_instance_;
class NormalizedBBox;
struct NormalizedBBoxDefaultTypeInternal;
extern NormalizedBBoxDefaultTypeInternal _NormalizedBBox_default_instance_;
class PReLUParameter;
struct PReLUParameterDefaultTypeInternal;
extern PReLUParameterDefaultTypeInternal _PReLUParameter_default_instance_;
class ParamSpec;
struct ParamSpecDefaultTypeInternal;
extern ParamSpecDefaultTypeInternal _ParamSpec_default_instance_;
class ParameterParameter;
struct ParameterParameterDefaultTypeInternal;
extern ParameterParameterDefaultTypeInternal _ParameterParameter_default_instance_;
class PermuteParameter;
struct PermuteParameterDefaultTypeInternal;
extern PermuteParameterDefaultTypeInternal _PermuteParameter_default_instance_;
class Pooling3DParameter;
struct Pooling3DParameterDefaultTypeInternal;
extern Pooling3DParameterDefaultTypeInternal _Pooling3DParameter_default_instance_;
class PoolingParameter;
struct PoolingParameterDefaultTypeInternal;
extern PoolingParameterDefaultTypeInternal _PoolingParameter_default_instance_;
class PowerParameter;
struct PowerParameterDefaultTypeInternal;
extern PowerParameterDefaultTypeInternal _PowerParameter_default_instance_;
class PriorBoxParameter;
struct PriorBoxParameterDefaultTypeInternal;
extern PriorBoxParameterDefaultTypeInternal _PriorBoxParameter_default_instance_;
class PythonParameter;
struct PythonParameterDefaultTypeInternal;
extern PythonParameterDefaultTypeInternal _PythonParameter_default_instance_;
class ROIPoolingParameter;
struct ROIPoolingParameterDefaultTypeInternal;
extern ROIPoolingParameterDefaultTypeInternal _ROIPoolingParameter_default_instance_;
class ReLUParameter;
struct ReLUParameterDefaultTypeInternal;
extern ReLUParameterDefaultTypeInternal _ReLUParameter_default_instance_;
class RecurrentParameter;
struct RecurrentParameterDefaultTypeInternal;
extern RecurrentParameterDefaultTypeInternal _RecurrentParameter_default_instance_;
class ReductionParameter;
struct ReductionParameterDefaultTypeInternal;
extern ReductionParameterDefaultTypeInternal _ReductionParameter_default_instance_;
class ReshapeParameter;
struct ReshapeParameterDefaultTypeInternal;
extern ReshapeParameterDefaultTypeInternal _ReshapeParameter_default_instance_;
class ResizeParameter;
struct ResizeParameterDefaultTypeInternal;
extern ResizeParameterDefaultTypeInternal _ResizeParameter_default_instance_;
class SPPParameter;
struct SPPParameterDefaultTypeInternal;
extern SPPParameterDefaultTypeInternal _SPPParameter_default_instance_;
class SaltPepperParameter;
struct SaltPepperParameterDefaultTypeInternal;
extern SaltPepperParameterDefaultTypeInternal _SaltPepperParameter_default_instance_;
class SampleConstraint;
struct SampleConstraintDefaultTypeInternal;
extern SampleConstraintDefaultTypeInternal _SampleConstraint_default_instance_;
class Sampler;
struct SamplerDefaultTypeInternal;
extern SamplerDefaultTypeInternal _Sampler_default_instance_;
class SaveOutputParameter;
struct SaveOutputParameterDefaultTypeInternal;
extern SaveOutputParameterDefaultTypeInternal _SaveOutputParameter_default_instance_;
class ScaleParameter;
struct ScaleParameterDefaultTypeInternal;
extern ScaleParameterDefaultTypeInternal _ScaleParameter_default_instance_;
class Seq2outParameter;
struct Seq2outParameterDefaultTypeInternal;
extern Seq2outParameterDefaultTypeInternal _Seq2outParameter_default_instance_;
class ShuffleChannelParameter;
struct ShuffleChannelParameterDefaultTypeInternal;
extern ShuffleChannelParameterDefaultTypeInternal _ShuffleChannelParameter_default_instance_;
class SigmoidParameter;
struct SigmoidParameterDefaultTypeInternal;
extern SigmoidParameterDefaultTypeInternal _SigmoidParameter_default_instance_;
class SliceParameter;
struct SliceParameterDefaultTypeInternal;
extern SliceParameterDefaultTypeInternal _SliceParameter_default_instance_;
class SoftmaxParameter;
struct SoftmaxParameterDefaultTypeInternal;
extern SoftmaxParameterDefaultTypeInternal _SoftmaxParameter_default_instance_;
class SolverParameter;
struct SolverParameterDefaultTypeInternal;
extern SolverParameterDefaultTypeInternal _SolverParameter_default_instance_;
class SolverState;
struct SolverStateDefaultTypeInternal;
extern SolverStateDefaultTypeInternal _SolverState_default_instance_;
class TanHParameter;
struct TanHParameterDefaultTypeInternal;
extern TanHParameterDefaultTypeInternal _TanHParameter_default_instance_;
class ThresholdParameter;
struct ThresholdParameterDefaultTypeInternal;
extern ThresholdParameterDefaultTypeInternal _ThresholdParameter_default_instance_;
class TileParameter;
struct TileParameterDefaultTypeInternal;
extern TileParameterDefaultTypeInternal _TileParameter_default_instance_;
class TransformationParameter;
struct TransformationParameterDefaultTypeInternal;
extern TransformationParameterDefaultTypeInternal _TransformationParameter_default_instance_;
class UpsampleParameter;
struct UpsampleParameterDefaultTypeInternal;
extern UpsampleParameterDefaultTypeInternal _UpsampleParameter_default_instance_;
class V0LayerParameter;
struct V0LayerParameterDefaultTypeInternal;
extern V0LayerParameterDefaultTypeInternal _V0LayerParameter_default_instance_;
class V1LayerParameter;
struct V1LayerParameterDefaultTypeInternal;
extern V1LayerParameterDefaultTypeInternal _V1LayerParameter_default_instance_;
class WindowDataParameter;
struct WindowDataParameterDefaultTypeInternal;
extern WindowDataParameterDefaultTypeInternal _WindowDataParameter_default_instance_;
} // namespace caffe
PROTOBUF_NAMESPACE_OPEN
template<> ::caffe::AccuracyParameter* Arena::CreateMaybeMessage<::caffe::AccuracyParameter>(Arena*);
template<> ::caffe::AnnotatedDataParameter* Arena::CreateMaybeMessage<::caffe::AnnotatedDataParameter>(Arena*);
template<> ::caffe::AnnotatedDatum* Arena::CreateMaybeMessage<::caffe::AnnotatedDatum>(Arena*);
template<> ::caffe::Annotation* Arena::CreateMaybeMessage<::caffe::Annotation>(Arena*);
template<> ::caffe::AnnotationGroup* Arena::CreateMaybeMessage<::caffe::AnnotationGroup>(Arena*);
template<> ::caffe::ArgMaxParameter* Arena::CreateMaybeMessage<::caffe::ArgMaxParameter>(Arena*);
template<> ::caffe::BatchNormParameter* Arena::CreateMaybeMessage<::caffe::BatchNormParameter>(Arena*);
template<> ::caffe::BatchSampler* Arena::CreateMaybeMessage<::caffe::BatchSampler>(Arena*);
template<> ::caffe::BiasParameter* Arena::CreateMaybeMessage<::caffe::BiasParameter>(Arena*);
template<> ::caffe::BlobProto* Arena::CreateMaybeMessage<::caffe::BlobProto>(Arena*);
template<> ::caffe::BlobProtoVector* Arena::CreateMaybeMessage<::caffe::BlobProtoVector>(Arena*);
template<> ::caffe::BlobShape* Arena::CreateMaybeMessage<::caffe::BlobShape>(Arena*);
template<> ::caffe::CenterLossParameter* Arena::CreateMaybeMessage<::caffe::CenterLossParameter>(Arena*);
template<> ::caffe::ClipParameter* Arena::CreateMaybeMessage<::caffe::ClipParameter>(Arena*);
template<> ::caffe::ConcatParameter* Arena::CreateMaybeMessage<::caffe::ConcatParameter>(Arena*);
template<> ::caffe::ContrastiveLossParameter* Arena::CreateMaybeMessage<::caffe::ContrastiveLossParameter>(Arena*);
template<> ::caffe::Convolution3DParameter* Arena::CreateMaybeMessage<::caffe::Convolution3DParameter>(Arena*);
template<> ::caffe::ConvolutionParameter* Arena::CreateMaybeMessage<::caffe::ConvolutionParameter>(Arena*);
template<> ::caffe::CropParameter* Arena::CreateMaybeMessage<::caffe::CropParameter>(Arena*);
template<> ::caffe::DataParameter* Arena::CreateMaybeMessage<::caffe::DataParameter>(Arena*);
template<> ::caffe::Datum* Arena::CreateMaybeMessage<::caffe::Datum>(Arena*);
template<> ::caffe::DetectionEvaluateParameter* Arena::CreateMaybeMessage<::caffe::DetectionEvaluateParameter>(Arena*);
template<> ::caffe::DetectionOutputParameter* Arena::CreateMaybeMessage<::caffe::DetectionOutputParameter>(Arena*);
template<> ::caffe::DistortionParameter* Arena::CreateMaybeMessage<::caffe::DistortionParameter>(Arena*);
template<> ::caffe::DropoutParameter* Arena::CreateMaybeMessage<::caffe::DropoutParameter>(Arena*);
template<> ::caffe::DummyDataParameter* Arena::CreateMaybeMessage<::caffe::DummyDataParameter>(Arena*);
template<> ::caffe::ELUParameter* Arena::CreateMaybeMessage<::caffe::ELUParameter>(Arena*);
template<> ::caffe::EltwiseParameter* Arena::CreateMaybeMessage<::caffe::EltwiseParameter>(Arena*);
template<> ::caffe::EmbedParameter* Arena::CreateMaybeMessage<::caffe::EmbedParameter>(Arena*);
template<> ::caffe::EmitConstraint* Arena::CreateMaybeMessage<::caffe::EmitConstraint>(Arena*);
template<> ::caffe::ExpParameter* Arena::CreateMaybeMessage<::caffe::ExpParameter>(Arena*);
template<> ::caffe::ExpansionParameter* Arena::CreateMaybeMessage<::caffe::ExpansionParameter>(Arena*);
template<> ::caffe::FillerParameter* Arena::CreateMaybeMessage<::caffe::FillerParameter>(Arena*);
template<> ::caffe::FlattenParameter* Arena::CreateMaybeMessage<::caffe::FlattenParameter>(Arena*);
template<> ::caffe::HDF5DataParameter* Arena::CreateMaybeMessage<::caffe::HDF5DataParameter>(Arena*);
template<> ::caffe::HDF5OutputParameter* Arena::CreateMaybeMessage<::caffe::HDF5OutputParameter>(Arena*);
template<> ::caffe::HingeLossParameter* Arena::CreateMaybeMessage<::caffe::HingeLossParameter>(Arena*);
template<> ::caffe::Im2seqParameter* Arena::CreateMaybeMessage<::caffe::Im2seqParameter>(Arena*);
template<> ::caffe::ImageDataParameter* Arena::CreateMaybeMessage<::caffe::ImageDataParameter>(Arena*);
template<> ::caffe::ImgSizeParameter* Arena::CreateMaybeMessage<::caffe::ImgSizeParameter>(Arena*);
template<> ::caffe::InfogainLossParameter* Arena::CreateMaybeMessage<::caffe::InfogainLossParameter>(Arena*);
template<> ::caffe::InnerProductParameter* Arena::CreateMaybeMessage<::caffe::InnerProductParameter>(Arena*);
template<> ::caffe::InputParameter* Arena::CreateMaybeMessage<::caffe::InputParameter>(Arena*);
template<> ::caffe::InterpParameter* Arena::CreateMaybeMessage<::caffe::InterpParameter>(Arena*);
template<> ::caffe::LRNParameter* Arena::CreateMaybeMessage<::caffe::LRNParameter>(Arena*);
template<> ::caffe::LSTMParameter* Arena::CreateMaybeMessage<::caffe::LSTMParameter>(Arena*);
template<> ::caffe::LabelMap* Arena::CreateMaybeMessage<::caffe::LabelMap>(Arena*);
template<> ::caffe::LabelMapItem* Arena::CreateMaybeMessage<::caffe::LabelMapItem>(Arena*);
template<> ::caffe::LayerParameter* Arena::CreateMaybeMessage<::caffe::LayerParameter>(Arena*);
template<> ::caffe::LogParameter* Arena::CreateMaybeMessage<::caffe::LogParameter>(Arena*);
template<> ::caffe::LossParameter* Arena::CreateMaybeMessage<::caffe::LossParameter>(Arena*);
template<> ::caffe::MTCNNBBox* Arena::CreateMaybeMessage<::caffe::MTCNNBBox>(Arena*);
template<> ::caffe::MTCNNDatum* Arena::CreateMaybeMessage<::caffe::MTCNNDatum>(Arena*);
template<> ::caffe::MVNParameter* Arena::CreateMaybeMessage<::caffe::MVNParameter>(Arena*);
template<> ::caffe::MemoryDataParameter* Arena::CreateMaybeMessage<::caffe::MemoryDataParameter>(Arena*);
template<> ::caffe::MultiBoxLossParameter* Arena::CreateMaybeMessage<::caffe::MultiBoxLossParameter>(Arena*);
template<> ::caffe::NetParameter* Arena::CreateMaybeMessage<::caffe::NetParameter>(Arena*);
template<> ::caffe::NetState* Arena::CreateMaybeMessage<::caffe::NetState>(Arena*);
template<> ::caffe::NetStateRule* Arena::CreateMaybeMessage<::caffe::NetStateRule>(Arena*);
template<> ::caffe::NoiseParameter* Arena::CreateMaybeMessage<::caffe::NoiseParameter>(Arena*);
template<> ::caffe::NonMaximumSuppressionParameter* Arena::CreateMaybeMessage<::caffe::NonMaximumSuppressionParameter>(Arena*);
template<> ::caffe::NormalizeParameter* Arena::CreateMaybeMessage<::caffe::NormalizeParameter>(Arena*);
template<> ::caffe::NormalizedBBox* Arena::CreateMaybeMessage<::caffe::NormalizedBBox>(Arena*);
template<> ::caffe::PReLUParameter* Arena::CreateMaybeMessage<::caffe::PReLUParameter>(Arena*);
template<> ::caffe::ParamSpec* Arena::CreateMaybeMessage<::caffe::ParamSpec>(Arena*);
template<> ::caffe::ParameterParameter* Arena::CreateMaybeMessage<::caffe::ParameterParameter>(Arena*);
template<> ::caffe::PermuteParameter* Arena::CreateMaybeMessage<::caffe::PermuteParameter>(Arena*);
template<> ::caffe::Pooling3DParameter* Arena::CreateMaybeMessage<::caffe::Pooling3DParameter>(Arena*);
template<> ::caffe::PoolingParameter* Arena::CreateMaybeMessage<::caffe::PoolingParameter>(Arena*);
template<> ::caffe::PowerParameter* Arena::CreateMaybeMessage<::caffe::PowerParameter>(Arena*);
template<> ::caffe::PriorBoxParameter* Arena::CreateMaybeMessage<::caffe::PriorBoxParameter>(Arena*);
template<> ::caffe::PythonParameter* Arena::CreateMaybeMessage<::caffe::PythonParameter>(Arena*);
template<> ::caffe::ROIPoolingParameter* Arena::CreateMaybeMessage<::caffe::ROIPoolingParameter>(Arena*);
template<> ::caffe::ReLUParameter* Arena::CreateMaybeMessage<::caffe::ReLUParameter>(Arena*);
template<> ::caffe::RecurrentParameter* Arena::CreateMaybeMessage<::caffe::RecurrentParameter>(Arena*);
template<> ::caffe::ReductionParameter* Arena::CreateMaybeMessage<::caffe::ReductionParameter>(Arena*);
template<> ::caffe::ReshapeParameter* Arena::CreateMaybeMessage<::caffe::ReshapeParameter>(Arena*);
template<> ::caffe::ResizeParameter* Arena::CreateMaybeMessage<::caffe::ResizeParameter>(Arena*);
template<> ::caffe::SPPParameter* Arena::CreateMaybeMessage<::caffe::SPPParameter>(Arena*);
template<> ::caffe::SaltPepperParameter* Arena::CreateMaybeMessage<::caffe::SaltPepperParameter>(Arena*);
template<> ::caffe::SampleConstraint* Arena::CreateMaybeMessage<::caffe::SampleConstraint>(Arena*);
template<> ::caffe::Sampler* Arena::CreateMaybeMessage<::caffe::Sampler>(Arena*);
template<> ::caffe::SaveOutputParameter* Arena::CreateMaybeMessage<::caffe::SaveOutputParameter>(Arena*);
template<> ::caffe::ScaleParameter* Arena::CreateMaybeMessage<::caffe::ScaleParameter>(Arena*);
template<> ::caffe::Seq2outParameter* Arena::CreateMaybeMessage<::caffe::Seq2outParameter>(Arena*);
template<> ::caffe::ShuffleChannelParameter* Arena::CreateMaybeMessage<::caffe::ShuffleChannelParameter>(Arena*);
template<> ::caffe::SigmoidParameter* Arena::CreateMaybeMessage<::caffe::SigmoidParameter>(Arena*);
template<> ::caffe::SliceParameter* Arena::CreateMaybeMessage<::caffe::SliceParameter>(Arena*);
template<> ::caffe::SoftmaxParameter* Arena::CreateMaybeMessage<::caffe::SoftmaxParameter>(Arena*);
template<> ::caffe::SolverParameter* Arena::CreateMaybeMessage<::caffe::SolverParameter>(Arena*);
template<> ::caffe::SolverState* Arena::CreateMaybeMessage<::caffe::SolverState>(Arena*);
template<> ::caffe::TanHParameter* Arena::CreateMaybeMessage<::caffe::TanHParameter>(Arena*);
template<> ::caffe::ThresholdParameter* Arena::CreateMaybeMessage<::caffe::ThresholdParameter>(Arena*);
template<> ::caffe::TileParameter* Arena::CreateMaybeMessage<::caffe::TileParameter>(Arena*);
template<> ::caffe::TransformationParameter* Arena::CreateMaybeMessage<::caffe::TransformationParameter>(Arena*);
template<> ::caffe::UpsampleParameter* Arena::CreateMaybeMessage<::caffe::UpsampleParameter>(Arena*);
template<> ::caffe::V0LayerParameter* Arena::CreateMaybeMessage<::caffe::V0LayerParameter>(Arena*);
template<> ::caffe::V1LayerParameter* Arena::CreateMaybeMessage<::caffe::V1LayerParameter>(Arena*);
template<> ::caffe::WindowDataParameter* Arena::CreateMaybeMessage<::caffe::WindowDataParameter>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace caffe {
enum EmitConstraint_EmitType : int {
EmitConstraint_EmitType_CENTER = 0,
EmitConstraint_EmitType_MIN_OVERLAP = 1
};
bool EmitConstraint_EmitType_IsValid(int value);
constexpr EmitConstraint_EmitType EmitConstraint_EmitType_EmitType_MIN = EmitConstraint_EmitType_CENTER;
constexpr EmitConstraint_EmitType EmitConstraint_EmitType_EmitType_MAX = EmitConstraint_EmitType_MIN_OVERLAP;
constexpr int EmitConstraint_EmitType_EmitType_ARRAYSIZE = EmitConstraint_EmitType_EmitType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EmitConstraint_EmitType_descriptor();
template<typename T>
inline const std::string& EmitConstraint_EmitType_Name(T enum_t_value) {
static_assert(::std::is_same<T, EmitConstraint_EmitType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function EmitConstraint_EmitType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
EmitConstraint_EmitType_descriptor(), enum_t_value);
}
inline bool EmitConstraint_EmitType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EmitConstraint_EmitType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EmitConstraint_EmitType>(
EmitConstraint_EmitType_descriptor(), name, value);
}
enum AnnotatedDatum_AnnotationType : int {
AnnotatedDatum_AnnotationType_BBOX = 0
};
bool AnnotatedDatum_AnnotationType_IsValid(int value);
constexpr AnnotatedDatum_AnnotationType AnnotatedDatum_AnnotationType_AnnotationType_MIN = AnnotatedDatum_AnnotationType_BBOX;
constexpr AnnotatedDatum_AnnotationType AnnotatedDatum_AnnotationType_AnnotationType_MAX = AnnotatedDatum_AnnotationType_BBOX;
constexpr int AnnotatedDatum_AnnotationType_AnnotationType_ARRAYSIZE = AnnotatedDatum_AnnotationType_AnnotationType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AnnotatedDatum_AnnotationType_descriptor();
template<typename T>
inline const std::string& AnnotatedDatum_AnnotationType_Name(T enum_t_value) {
static_assert(::std::is_same<T, AnnotatedDatum_AnnotationType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function AnnotatedDatum_AnnotationType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
AnnotatedDatum_AnnotationType_descriptor(), enum_t_value);
}
inline bool AnnotatedDatum_AnnotationType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AnnotatedDatum_AnnotationType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AnnotatedDatum_AnnotationType>(
AnnotatedDatum_AnnotationType_descriptor(), name, value);
}
enum FillerParameter_VarianceNorm : int {
FillerParameter_VarianceNorm_FAN_IN = 0,
FillerParameter_VarianceNorm_FAN_OUT = 1,
FillerParameter_VarianceNorm_AVERAGE = 2
};
bool FillerParameter_VarianceNorm_IsValid(int value);
constexpr FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MIN = FillerParameter_VarianceNorm_FAN_IN;
constexpr FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MAX = FillerParameter_VarianceNorm_AVERAGE;
constexpr int FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE = FillerParameter_VarianceNorm_VarianceNorm_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FillerParameter_VarianceNorm_descriptor();
template<typename T>
inline const std::string& FillerParameter_VarianceNorm_Name(T enum_t_value) {
static_assert(::std::is_same<T, FillerParameter_VarianceNorm>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function FillerParameter_VarianceNorm_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
FillerParameter_VarianceNorm_descriptor(), enum_t_value);
}
inline bool FillerParameter_VarianceNorm_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FillerParameter_VarianceNorm* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FillerParameter_VarianceNorm>(
FillerParameter_VarianceNorm_descriptor(), name, value);
}
enum SolverParameter_SnapshotFormat : int {
SolverParameter_SnapshotFormat_HDF5 = 0,
SolverParameter_SnapshotFormat_BINARYPROTO = 1
};
bool SolverParameter_SnapshotFormat_IsValid(int value);
constexpr SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MIN = SolverParameter_SnapshotFormat_HDF5;
constexpr SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MAX = SolverParameter_SnapshotFormat_BINARYPROTO;
constexpr int SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE = SolverParameter_SnapshotFormat_SnapshotFormat_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor();
template<typename T>
inline const std::string& SolverParameter_SnapshotFormat_Name(T enum_t_value) {
static_assert(::std::is_same<T, SolverParameter_SnapshotFormat>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SolverParameter_SnapshotFormat_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
SolverParameter_SnapshotFormat_descriptor(), enum_t_value);
}
inline bool SolverParameter_SnapshotFormat_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SolverParameter_SnapshotFormat* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SolverParameter_SnapshotFormat>(
SolverParameter_SnapshotFormat_descriptor(), name, value);
}
enum SolverParameter_SolverMode : int {
SolverParameter_SolverMode_CPU = 0,
SolverParameter_SolverMode_GPU = 1
};
bool SolverParameter_SolverMode_IsValid(int value);
constexpr SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MIN = SolverParameter_SolverMode_CPU;
constexpr SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MAX = SolverParameter_SolverMode_GPU;
constexpr int SolverParameter_SolverMode_SolverMode_ARRAYSIZE = SolverParameter_SolverMode_SolverMode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverMode_descriptor();
template<typename T>
inline const std::string& SolverParameter_SolverMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, SolverParameter_SolverMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SolverParameter_SolverMode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
SolverParameter_SolverMode_descriptor(), enum_t_value);
}
inline bool SolverParameter_SolverMode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SolverParameter_SolverMode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SolverParameter_SolverMode>(
SolverParameter_SolverMode_descriptor(), name, value);
}
enum SolverParameter_SolverType : int {
SolverParameter_SolverType_SGD = 0,
SolverParameter_SolverType_NESTEROV = 1,
SolverParameter_SolverType_ADAGRAD = 2,
SolverParameter_SolverType_RMSPROP = 3,
SolverParameter_SolverType_ADADELTA = 4,
SolverParameter_SolverType_ADAM = 5
};
bool SolverParameter_SolverType_IsValid(int value);
constexpr SolverParameter_SolverType SolverParameter_SolverType_SolverType_MIN = SolverParameter_SolverType_SGD;
constexpr SolverParameter_SolverType SolverParameter_SolverType_SolverType_MAX = SolverParameter_SolverType_ADAM;
constexpr int SolverParameter_SolverType_SolverType_ARRAYSIZE = SolverParameter_SolverType_SolverType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverType_descriptor();
template<typename T>
inline const std::string& SolverParameter_SolverType_Name(T enum_t_value) {
static_assert(::std::is_same<T, SolverParameter_SolverType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SolverParameter_SolverType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
SolverParameter_SolverType_descriptor(), enum_t_value);
}
inline bool SolverParameter_SolverType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SolverParameter_SolverType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SolverParameter_SolverType>(
SolverParameter_SolverType_descriptor(), name, value);
}
enum ParamSpec_DimCheckMode : int {
ParamSpec_DimCheckMode_STRICT = 0,
ParamSpec_DimCheckMode_PERMISSIVE = 1
};
bool ParamSpec_DimCheckMode_IsValid(int value);
constexpr ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MIN = ParamSpec_DimCheckMode_STRICT;
constexpr ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MAX = ParamSpec_DimCheckMode_PERMISSIVE;
constexpr int ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE = ParamSpec_DimCheckMode_DimCheckMode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ParamSpec_DimCheckMode_descriptor();
template<typename T>
inline const std::string& ParamSpec_DimCheckMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, ParamSpec_DimCheckMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ParamSpec_DimCheckMode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ParamSpec_DimCheckMode_descriptor(), enum_t_value);
}
inline bool ParamSpec_DimCheckMode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ParamSpec_DimCheckMode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ParamSpec_DimCheckMode>(
ParamSpec_DimCheckMode_descriptor(), name, value);
}
enum Im2seqParameter_Direction : int {
Im2seqParameter_Direction_FORWARD = 0,
Im2seqParameter_Direction_REVERSED = 1,
Im2seqParameter_Direction_TOPDOWN = 2,
Im2seqParameter_Direction_BOTTOMUP = 3
};
bool Im2seqParameter_Direction_IsValid(int value);
constexpr Im2seqParameter_Direction Im2seqParameter_Direction_Direction_MIN = Im2seqParameter_Direction_FORWARD;
constexpr Im2seqParameter_Direction Im2seqParameter_Direction_Direction_MAX = Im2seqParameter_Direction_BOTTOMUP;
constexpr int Im2seqParameter_Direction_Direction_ARRAYSIZE = Im2seqParameter_Direction_Direction_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Im2seqParameter_Direction_descriptor();
template<typename T>
inline const std::string& Im2seqParameter_Direction_Name(T enum_t_value) {
static_assert(::std::is_same<T, Im2seqParameter_Direction>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Im2seqParameter_Direction_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
Im2seqParameter_Direction_descriptor(), enum_t_value);
}
inline bool Im2seqParameter_Direction_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Im2seqParameter_Direction* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Im2seqParameter_Direction>(
Im2seqParameter_Direction_descriptor(), name, value);
}
enum ResizeParameter_Resize_mode : int {
ResizeParameter_Resize_mode_WARP = 1,
ResizeParameter_Resize_mode_FIT_SMALL_SIZE = 2,
ResizeParameter_Resize_mode_FIT_LARGE_SIZE_AND_PAD = 3
};
bool ResizeParameter_Resize_mode_IsValid(int value);
constexpr ResizeParameter_Resize_mode ResizeParameter_Resize_mode_Resize_mode_MIN = ResizeParameter_Resize_mode_WARP;
constexpr ResizeParameter_Resize_mode ResizeParameter_Resize_mode_Resize_mode_MAX = ResizeParameter_Resize_mode_FIT_LARGE_SIZE_AND_PAD;
constexpr int ResizeParameter_Resize_mode_Resize_mode_ARRAYSIZE = ResizeParameter_Resize_mode_Resize_mode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResizeParameter_Resize_mode_descriptor();
template<typename T>
inline const std::string& ResizeParameter_Resize_mode_Name(T enum_t_value) {
static_assert(::std::is_same<T, ResizeParameter_Resize_mode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ResizeParameter_Resize_mode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ResizeParameter_Resize_mode_descriptor(), enum_t_value);
}
inline bool ResizeParameter_Resize_mode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ResizeParameter_Resize_mode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ResizeParameter_Resize_mode>(
ResizeParameter_Resize_mode_descriptor(), name, value);
}
enum ResizeParameter_Pad_mode : int {
ResizeParameter_Pad_mode_CONSTANT = 1,
ResizeParameter_Pad_mode_MIRRORED = 2,
ResizeParameter_Pad_mode_REPEAT_NEAREST = 3
};
bool ResizeParameter_Pad_mode_IsValid(int value);
constexpr ResizeParameter_Pad_mode ResizeParameter_Pad_mode_Pad_mode_MIN = ResizeParameter_Pad_mode_CONSTANT;
constexpr ResizeParameter_Pad_mode ResizeParameter_Pad_mode_Pad_mode_MAX = ResizeParameter_Pad_mode_REPEAT_NEAREST;
constexpr int ResizeParameter_Pad_mode_Pad_mode_ARRAYSIZE = ResizeParameter_Pad_mode_Pad_mode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResizeParameter_Pad_mode_descriptor();
template<typename T>
inline const std::string& ResizeParameter_Pad_mode_Name(T enum_t_value) {
static_assert(::std::is_same<T, ResizeParameter_Pad_mode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ResizeParameter_Pad_mode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ResizeParameter_Pad_mode_descriptor(), enum_t_value);
}
inline bool ResizeParameter_Pad_mode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ResizeParameter_Pad_mode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ResizeParameter_Pad_mode>(
ResizeParameter_Pad_mode_descriptor(), name, value);
}
enum ResizeParameter_Interp_mode : int {
ResizeParameter_Interp_mode_LINEAR = 1,
ResizeParameter_Interp_mode_AREA = 2,
ResizeParameter_Interp_mode_NEAREST = 3,
ResizeParameter_Interp_mode_CUBIC = 4,
ResizeParameter_Interp_mode_LANCZOS4 = 5
};
bool ResizeParameter_Interp_mode_IsValid(int value);
constexpr ResizeParameter_Interp_mode ResizeParameter_Interp_mode_Interp_mode_MIN = ResizeParameter_Interp_mode_LINEAR;
constexpr ResizeParameter_Interp_mode ResizeParameter_Interp_mode_Interp_mode_MAX = ResizeParameter_Interp_mode_LANCZOS4;
constexpr int ResizeParameter_Interp_mode_Interp_mode_ARRAYSIZE = ResizeParameter_Interp_mode_Interp_mode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResizeParameter_Interp_mode_descriptor();
template<typename T>
inline const std::string& ResizeParameter_Interp_mode_Name(T enum_t_value) {
static_assert(::std::is_same<T, ResizeParameter_Interp_mode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ResizeParameter_Interp_mode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ResizeParameter_Interp_mode_descriptor(), enum_t_value);
}
inline bool ResizeParameter_Interp_mode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ResizeParameter_Interp_mode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ResizeParameter_Interp_mode>(
ResizeParameter_Interp_mode_descriptor(), name, value);
}
enum LossParameter_NormalizationMode : int {
LossParameter_NormalizationMode_FULL = 0,
LossParameter_NormalizationMode_VALID = 1,
LossParameter_NormalizationMode_BATCH_SIZE = 2,
LossParameter_NormalizationMode_NONE = 3
};
bool LossParameter_NormalizationMode_IsValid(int value);
constexpr LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MIN = LossParameter_NormalizationMode_FULL;
constexpr LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MAX = LossParameter_NormalizationMode_NONE;
constexpr int LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE = LossParameter_NormalizationMode_NormalizationMode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LossParameter_NormalizationMode_descriptor();
template<typename T>
inline const std::string& LossParameter_NormalizationMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, LossParameter_NormalizationMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function LossParameter_NormalizationMode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
LossParameter_NormalizationMode_descriptor(), enum_t_value);
}
inline bool LossParameter_NormalizationMode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LossParameter_NormalizationMode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LossParameter_NormalizationMode>(
LossParameter_NormalizationMode_descriptor(), name, value);
}
enum ConvolutionParameter_Engine : int {
ConvolutionParameter_Engine_DEFAULT = 0,
ConvolutionParameter_Engine_CAFFE = 1,
ConvolutionParameter_Engine_CUDNN = 2,
ConvolutionParameter_Engine_CUDNN_FORWARD = 3
};
bool ConvolutionParameter_Engine_IsValid(int value);
constexpr ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MIN = ConvolutionParameter_Engine_DEFAULT;
constexpr ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MAX = ConvolutionParameter_Engine_CUDNN_FORWARD;
constexpr int ConvolutionParameter_Engine_Engine_ARRAYSIZE = ConvolutionParameter_Engine_Engine_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConvolutionParameter_Engine_descriptor();
template<typename T>
inline const std::string& ConvolutionParameter_Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConvolutionParameter_Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConvolutionParameter_Engine_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ConvolutionParameter_Engine_descriptor(), enum_t_value);
}
inline bool ConvolutionParameter_Engine_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConvolutionParameter_Engine* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConvolutionParameter_Engine>(
ConvolutionParameter_Engine_descriptor(), name, value);
}
enum DataParameter_DB : int {
DataParameter_DB_LEVELDB = 0,
DataParameter_DB_LMDB = 1
};
bool DataParameter_DB_IsValid(int value);
constexpr DataParameter_DB DataParameter_DB_DB_MIN = DataParameter_DB_LEVELDB;
constexpr DataParameter_DB DataParameter_DB_DB_MAX = DataParameter_DB_LMDB;
constexpr int DataParameter_DB_DB_ARRAYSIZE = DataParameter_DB_DB_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataParameter_DB_descriptor();
template<typename T>
inline const std::string& DataParameter_DB_Name(T enum_t_value) {
static_assert(::std::is_same<T, DataParameter_DB>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DataParameter_DB_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
DataParameter_DB_descriptor(), enum_t_value);
}
inline bool DataParameter_DB_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataParameter_DB* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DataParameter_DB>(
DataParameter_DB_descriptor(), name, value);
}
enum EltwiseParameter_EltwiseOp : int {
EltwiseParameter_EltwiseOp_PROD = 0,
EltwiseParameter_EltwiseOp_SUM = 1,
EltwiseParameter_EltwiseOp_MAX = 2
};
bool EltwiseParameter_EltwiseOp_IsValid(int value);
constexpr EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MIN = EltwiseParameter_EltwiseOp_PROD;
constexpr EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MAX = EltwiseParameter_EltwiseOp_MAX;
constexpr int EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE = EltwiseParameter_EltwiseOp_EltwiseOp_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor();
template<typename T>
inline const std::string& EltwiseParameter_EltwiseOp_Name(T enum_t_value) {
static_assert(::std::is_same<T, EltwiseParameter_EltwiseOp>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function EltwiseParameter_EltwiseOp_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
EltwiseParameter_EltwiseOp_descriptor(), enum_t_value);
}
inline bool EltwiseParameter_EltwiseOp_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EltwiseParameter_EltwiseOp* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EltwiseParameter_EltwiseOp>(
EltwiseParameter_EltwiseOp_descriptor(), name, value);
}
enum HingeLossParameter_Norm : int {
HingeLossParameter_Norm_L1 = 1,
HingeLossParameter_Norm_L2 = 2
};
bool HingeLossParameter_Norm_IsValid(int value);
constexpr HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MIN = HingeLossParameter_Norm_L1;
constexpr HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MAX = HingeLossParameter_Norm_L2;
constexpr int HingeLossParameter_Norm_Norm_ARRAYSIZE = HingeLossParameter_Norm_Norm_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HingeLossParameter_Norm_descriptor();
template<typename T>
inline const std::string& HingeLossParameter_Norm_Name(T enum_t_value) {
static_assert(::std::is_same<T, HingeLossParameter_Norm>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function HingeLossParameter_Norm_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
HingeLossParameter_Norm_descriptor(), enum_t_value);
}
inline bool HingeLossParameter_Norm_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HingeLossParameter_Norm* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HingeLossParameter_Norm>(
HingeLossParameter_Norm_descriptor(), name, value);
}
enum LRNParameter_NormRegion : int {
LRNParameter_NormRegion_ACROSS_CHANNELS = 0,
LRNParameter_NormRegion_WITHIN_CHANNEL = 1
};
bool LRNParameter_NormRegion_IsValid(int value);
constexpr LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MIN = LRNParameter_NormRegion_ACROSS_CHANNELS;
constexpr LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MAX = LRNParameter_NormRegion_WITHIN_CHANNEL;
constexpr int LRNParameter_NormRegion_NormRegion_ARRAYSIZE = LRNParameter_NormRegion_NormRegion_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_NormRegion_descriptor();
template<typename T>
inline const std::string& LRNParameter_NormRegion_Name(T enum_t_value) {
static_assert(::std::is_same<T, LRNParameter_NormRegion>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function LRNParameter_NormRegion_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
LRNParameter_NormRegion_descriptor(), enum_t_value);
}
inline bool LRNParameter_NormRegion_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LRNParameter_NormRegion* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LRNParameter_NormRegion>(
LRNParameter_NormRegion_descriptor(), name, value);
}
enum LRNParameter_Engine : int {
LRNParameter_Engine_DEFAULT = 0,
LRNParameter_Engine_CAFFE = 1,
LRNParameter_Engine_CUDNN = 2
};
bool LRNParameter_Engine_IsValid(int value);
constexpr LRNParameter_Engine LRNParameter_Engine_Engine_MIN = LRNParameter_Engine_DEFAULT;
constexpr LRNParameter_Engine LRNParameter_Engine_Engine_MAX = LRNParameter_Engine_CUDNN;
constexpr int LRNParameter_Engine_Engine_ARRAYSIZE = LRNParameter_Engine_Engine_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_Engine_descriptor();
template<typename T>
inline const std::string& LRNParameter_Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, LRNParameter_Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function LRNParameter_Engine_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
LRNParameter_Engine_descriptor(), enum_t_value);
}
inline bool LRNParameter_Engine_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LRNParameter_Engine* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LRNParameter_Engine>(
LRNParameter_Engine_descriptor(), name, value);
}
enum MultiBoxLossParameter_LocLossType : int {
MultiBoxLossParameter_LocLossType_L2 = 0,
MultiBoxLossParameter_LocLossType_SMOOTH_L1 = 1
};
bool MultiBoxLossParameter_LocLossType_IsValid(int value);
constexpr MultiBoxLossParameter_LocLossType MultiBoxLossParameter_LocLossType_LocLossType_MIN = MultiBoxLossParameter_LocLossType_L2;
constexpr MultiBoxLossParameter_LocLossType MultiBoxLossParameter_LocLossType_LocLossType_MAX = MultiBoxLossParameter_LocLossType_SMOOTH_L1;
constexpr int MultiBoxLossParameter_LocLossType_LocLossType_ARRAYSIZE = MultiBoxLossParameter_LocLossType_LocLossType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MultiBoxLossParameter_LocLossType_descriptor();
template<typename T>
inline const std::string& MultiBoxLossParameter_LocLossType_Name(T enum_t_value) {
static_assert(::std::is_same<T, MultiBoxLossParameter_LocLossType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MultiBoxLossParameter_LocLossType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
MultiBoxLossParameter_LocLossType_descriptor(), enum_t_value);
}
inline bool MultiBoxLossParameter_LocLossType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiBoxLossParameter_LocLossType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MultiBoxLossParameter_LocLossType>(
MultiBoxLossParameter_LocLossType_descriptor(), name, value);
}
enum MultiBoxLossParameter_ConfLossType : int {
MultiBoxLossParameter_ConfLossType_SOFTMAX = 0,
MultiBoxLossParameter_ConfLossType_LOGISTIC = 1
};
bool MultiBoxLossParameter_ConfLossType_IsValid(int value);
constexpr MultiBoxLossParameter_ConfLossType MultiBoxLossParameter_ConfLossType_ConfLossType_MIN = MultiBoxLossParameter_ConfLossType_SOFTMAX;
constexpr MultiBoxLossParameter_ConfLossType MultiBoxLossParameter_ConfLossType_ConfLossType_MAX = MultiBoxLossParameter_ConfLossType_LOGISTIC;
constexpr int MultiBoxLossParameter_ConfLossType_ConfLossType_ARRAYSIZE = MultiBoxLossParameter_ConfLossType_ConfLossType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MultiBoxLossParameter_ConfLossType_descriptor();
template<typename T>
inline const std::string& MultiBoxLossParameter_ConfLossType_Name(T enum_t_value) {
static_assert(::std::is_same<T, MultiBoxLossParameter_ConfLossType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MultiBoxLossParameter_ConfLossType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
MultiBoxLossParameter_ConfLossType_descriptor(), enum_t_value);
}
inline bool MultiBoxLossParameter_ConfLossType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiBoxLossParameter_ConfLossType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MultiBoxLossParameter_ConfLossType>(
MultiBoxLossParameter_ConfLossType_descriptor(), name, value);
}
enum MultiBoxLossParameter_MatchType : int {
MultiBoxLossParameter_MatchType_BIPARTITE = 0,
MultiBoxLossParameter_MatchType_PER_PREDICTION = 1
};
bool MultiBoxLossParameter_MatchType_IsValid(int value);
constexpr MultiBoxLossParameter_MatchType MultiBoxLossParameter_MatchType_MatchType_MIN = MultiBoxLossParameter_MatchType_BIPARTITE;
constexpr MultiBoxLossParameter_MatchType MultiBoxLossParameter_MatchType_MatchType_MAX = MultiBoxLossParameter_MatchType_PER_PREDICTION;
constexpr int MultiBoxLossParameter_MatchType_MatchType_ARRAYSIZE = MultiBoxLossParameter_MatchType_MatchType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MultiBoxLossParameter_MatchType_descriptor();
template<typename T>
inline const std::string& MultiBoxLossParameter_MatchType_Name(T enum_t_value) {
static_assert(::std::is_same<T, MultiBoxLossParameter_MatchType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MultiBoxLossParameter_MatchType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
MultiBoxLossParameter_MatchType_descriptor(), enum_t_value);
}
inline bool MultiBoxLossParameter_MatchType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiBoxLossParameter_MatchType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MultiBoxLossParameter_MatchType>(
MultiBoxLossParameter_MatchType_descriptor(), name, value);
}
enum MultiBoxLossParameter_MiningType : int {
MultiBoxLossParameter_MiningType_NONE = 0,
MultiBoxLossParameter_MiningType_MAX_NEGATIVE = 1,
MultiBoxLossParameter_MiningType_HARD_EXAMPLE = 2
};
bool MultiBoxLossParameter_MiningType_IsValid(int value);
constexpr MultiBoxLossParameter_MiningType MultiBoxLossParameter_MiningType_MiningType_MIN = MultiBoxLossParameter_MiningType_NONE;
constexpr MultiBoxLossParameter_MiningType MultiBoxLossParameter_MiningType_MiningType_MAX = MultiBoxLossParameter_MiningType_HARD_EXAMPLE;
constexpr int MultiBoxLossParameter_MiningType_MiningType_ARRAYSIZE = MultiBoxLossParameter_MiningType_MiningType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MultiBoxLossParameter_MiningType_descriptor();
template<typename T>
inline const std::string& MultiBoxLossParameter_MiningType_Name(T enum_t_value) {
static_assert(::std::is_same<T, MultiBoxLossParameter_MiningType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MultiBoxLossParameter_MiningType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
MultiBoxLossParameter_MiningType_descriptor(), enum_t_value);
}
inline bool MultiBoxLossParameter_MiningType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiBoxLossParameter_MiningType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MultiBoxLossParameter_MiningType>(
MultiBoxLossParameter_MiningType_descriptor(), name, value);
}
enum PoolingParameter_PoolMethod : int {
PoolingParameter_PoolMethod_MAX = 0,
PoolingParameter_PoolMethod_AVE = 1,
PoolingParameter_PoolMethod_STOCHASTIC = 2
};
bool PoolingParameter_PoolMethod_IsValid(int value);
constexpr PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MIN = PoolingParameter_PoolMethod_MAX;
constexpr PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MAX = PoolingParameter_PoolMethod_STOCHASTIC;
constexpr int PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE = PoolingParameter_PoolMethod_PoolMethod_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_PoolMethod_descriptor();
template<typename T>
inline const std::string& PoolingParameter_PoolMethod_Name(T enum_t_value) {
static_assert(::std::is_same<T, PoolingParameter_PoolMethod>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PoolingParameter_PoolMethod_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
PoolingParameter_PoolMethod_descriptor(), enum_t_value);
}
inline bool PoolingParameter_PoolMethod_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PoolingParameter_PoolMethod* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PoolingParameter_PoolMethod>(
PoolingParameter_PoolMethod_descriptor(), name, value);
}
enum PoolingParameter_Engine : int {
PoolingParameter_Engine_DEFAULT = 0,
PoolingParameter_Engine_CAFFE = 1,
PoolingParameter_Engine_CUDNN = 2
};
bool PoolingParameter_Engine_IsValid(int value);
constexpr PoolingParameter_Engine PoolingParameter_Engine_Engine_MIN = PoolingParameter_Engine_DEFAULT;
constexpr PoolingParameter_Engine PoolingParameter_Engine_Engine_MAX = PoolingParameter_Engine_CUDNN;
constexpr int PoolingParameter_Engine_Engine_ARRAYSIZE = PoolingParameter_Engine_Engine_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_Engine_descriptor();
template<typename T>
inline const std::string& PoolingParameter_Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, PoolingParameter_Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PoolingParameter_Engine_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
PoolingParameter_Engine_descriptor(), enum_t_value);
}
inline bool PoolingParameter_Engine_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PoolingParameter_Engine* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PoolingParameter_Engine>(
PoolingParameter_Engine_descriptor(), name, value);
}
enum PoolingParameter_RoundMode : int {
PoolingParameter_RoundMode_CEIL = 0,
PoolingParameter_RoundMode_FLOOR = 1
};
bool PoolingParameter_RoundMode_IsValid(int value);
constexpr PoolingParameter_RoundMode PoolingParameter_RoundMode_RoundMode_MIN = PoolingParameter_RoundMode_CEIL;
constexpr PoolingParameter_RoundMode PoolingParameter_RoundMode_RoundMode_MAX = PoolingParameter_RoundMode_FLOOR;
constexpr int PoolingParameter_RoundMode_RoundMode_ARRAYSIZE = PoolingParameter_RoundMode_RoundMode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_RoundMode_descriptor();
template<typename T>
inline const std::string& PoolingParameter_RoundMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, PoolingParameter_RoundMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PoolingParameter_RoundMode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
PoolingParameter_RoundMode_descriptor(), enum_t_value);
}
inline bool PoolingParameter_RoundMode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PoolingParameter_RoundMode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PoolingParameter_RoundMode>(
PoolingParameter_RoundMode_descriptor(), name, value);
}
enum Pooling3DParameter_PoolMethod : int {
Pooling3DParameter_PoolMethod_MAX = 0,
Pooling3DParameter_PoolMethod_AVE = 1,
Pooling3DParameter_PoolMethod_STOCHASTIC = 2
};
bool Pooling3DParameter_PoolMethod_IsValid(int value);
constexpr Pooling3DParameter_PoolMethod Pooling3DParameter_PoolMethod_PoolMethod_MIN = Pooling3DParameter_PoolMethod_MAX;
constexpr Pooling3DParameter_PoolMethod Pooling3DParameter_PoolMethod_PoolMethod_MAX = Pooling3DParameter_PoolMethod_STOCHASTIC;
constexpr int Pooling3DParameter_PoolMethod_PoolMethod_ARRAYSIZE = Pooling3DParameter_PoolMethod_PoolMethod_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Pooling3DParameter_PoolMethod_descriptor();
template<typename T>
inline const std::string& Pooling3DParameter_PoolMethod_Name(T enum_t_value) {
static_assert(::std::is_same<T, Pooling3DParameter_PoolMethod>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Pooling3DParameter_PoolMethod_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
Pooling3DParameter_PoolMethod_descriptor(), enum_t_value);
}
inline bool Pooling3DParameter_PoolMethod_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Pooling3DParameter_PoolMethod* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Pooling3DParameter_PoolMethod>(
Pooling3DParameter_PoolMethod_descriptor(), name, value);
}
enum PriorBoxParameter_CodeType : int {
PriorBoxParameter_CodeType_CORNER = 1,
PriorBoxParameter_CodeType_CENTER_SIZE = 2,
PriorBoxParameter_CodeType_CORNER_SIZE = 3
};
bool PriorBoxParameter_CodeType_IsValid(int value);
constexpr PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MIN = PriorBoxParameter_CodeType_CORNER;
constexpr PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MAX = PriorBoxParameter_CodeType_CORNER_SIZE;
constexpr int PriorBoxParameter_CodeType_CodeType_ARRAYSIZE = PriorBoxParameter_CodeType_CodeType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PriorBoxParameter_CodeType_descriptor();
template<typename T>
inline const std::string& PriorBoxParameter_CodeType_Name(T enum_t_value) {
static_assert(::std::is_same<T, PriorBoxParameter_CodeType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PriorBoxParameter_CodeType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
PriorBoxParameter_CodeType_descriptor(), enum_t_value);
}
inline bool PriorBoxParameter_CodeType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PriorBoxParameter_CodeType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PriorBoxParameter_CodeType>(
PriorBoxParameter_CodeType_descriptor(), name, value);
}
enum ReductionParameter_ReductionOp : int {
ReductionParameter_ReductionOp_SUM = 1,
ReductionParameter_ReductionOp_ASUM = 2,
ReductionParameter_ReductionOp_SUMSQ = 3,
ReductionParameter_ReductionOp_MEAN = 4
};
bool ReductionParameter_ReductionOp_IsValid(int value);
constexpr ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MIN = ReductionParameter_ReductionOp_SUM;
constexpr ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MAX = ReductionParameter_ReductionOp_MEAN;
constexpr int ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE = ReductionParameter_ReductionOp_ReductionOp_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReductionParameter_ReductionOp_descriptor();
template<typename T>
inline const std::string& ReductionParameter_ReductionOp_Name(T enum_t_value) {
static_assert(::std::is_same<T, ReductionParameter_ReductionOp>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ReductionParameter_ReductionOp_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ReductionParameter_ReductionOp_descriptor(), enum_t_value);
}
inline bool ReductionParameter_ReductionOp_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReductionParameter_ReductionOp* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReductionParameter_ReductionOp>(
ReductionParameter_ReductionOp_descriptor(), name, value);
}
enum ReLUParameter_Engine : int {
ReLUParameter_Engine_DEFAULT = 0,
ReLUParameter_Engine_CAFFE = 1,
ReLUParameter_Engine_CUDNN = 2
};
bool ReLUParameter_Engine_IsValid(int value);
constexpr ReLUParameter_Engine ReLUParameter_Engine_Engine_MIN = ReLUParameter_Engine_DEFAULT;
constexpr ReLUParameter_Engine ReLUParameter_Engine_Engine_MAX = ReLUParameter_Engine_CUDNN;
constexpr int ReLUParameter_Engine_Engine_ARRAYSIZE = ReLUParameter_Engine_Engine_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReLUParameter_Engine_descriptor();
template<typename T>
inline const std::string& ReLUParameter_Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, ReLUParameter_Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ReLUParameter_Engine_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ReLUParameter_Engine_descriptor(), enum_t_value);
}
inline bool ReLUParameter_Engine_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReLUParameter_Engine* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReLUParameter_Engine>(
ReLUParameter_Engine_descriptor(), name, value);
}
enum SigmoidParameter_Engine : int {
SigmoidParameter_Engine_DEFAULT = 0,
SigmoidParameter_Engine_CAFFE = 1,
SigmoidParameter_Engine_CUDNN = 2
};
bool SigmoidParameter_Engine_IsValid(int value);
constexpr SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MIN = SigmoidParameter_Engine_DEFAULT;
constexpr SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MAX = SigmoidParameter_Engine_CUDNN;
constexpr int SigmoidParameter_Engine_Engine_ARRAYSIZE = SigmoidParameter_Engine_Engine_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SigmoidParameter_Engine_descriptor();
template<typename T>
inline const std::string& SigmoidParameter_Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, SigmoidParameter_Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SigmoidParameter_Engine_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
SigmoidParameter_Engine_descriptor(), enum_t_value);
}
inline bool SigmoidParameter_Engine_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SigmoidParameter_Engine* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SigmoidParameter_Engine>(
SigmoidParameter_Engine_descriptor(), name, value);
}
enum SoftmaxParameter_Engine : int {
SoftmaxParameter_Engine_DEFAULT = 0,
SoftmaxParameter_Engine_CAFFE = 1,
SoftmaxParameter_Engine_CUDNN = 2
};
bool SoftmaxParameter_Engine_IsValid(int value);
constexpr SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MIN = SoftmaxParameter_Engine_DEFAULT;
constexpr SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MAX = SoftmaxParameter_Engine_CUDNN;
constexpr int SoftmaxParameter_Engine_Engine_ARRAYSIZE = SoftmaxParameter_Engine_Engine_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SoftmaxParameter_Engine_descriptor();
template<typename T>
inline const std::string& SoftmaxParameter_Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, SoftmaxParameter_Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SoftmaxParameter_Engine_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
SoftmaxParameter_Engine_descriptor(), enum_t_value);
}
inline bool SoftmaxParameter_Engine_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SoftmaxParameter_Engine* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SoftmaxParameter_Engine>(
SoftmaxParameter_Engine_descriptor(), name, value);
}
enum TanHParameter_Engine : int {
TanHParameter_Engine_DEFAULT = 0,
TanHParameter_Engine_CAFFE = 1,
TanHParameter_Engine_CUDNN = 2
};
bool TanHParameter_Engine_IsValid(int value);
constexpr TanHParameter_Engine TanHParameter_Engine_Engine_MIN = TanHParameter_Engine_DEFAULT;
constexpr TanHParameter_Engine TanHParameter_Engine_Engine_MAX = TanHParameter_Engine_CUDNN;
constexpr int TanHParameter_Engine_Engine_ARRAYSIZE = TanHParameter_Engine_Engine_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TanHParameter_Engine_descriptor();
template<typename T>
inline const std::string& TanHParameter_Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, TanHParameter_Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function TanHParameter_Engine_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
TanHParameter_Engine_descriptor(), enum_t_value);
}
inline bool TanHParameter_Engine_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TanHParameter_Engine* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TanHParameter_Engine>(
TanHParameter_Engine_descriptor(), name, value);
}
enum SPPParameter_PoolMethod : int {
SPPParameter_PoolMethod_MAX = 0,
SPPParameter_PoolMethod_AVE = 1,
SPPParameter_PoolMethod_STOCHASTIC = 2
};
bool SPPParameter_PoolMethod_IsValid(int value);
constexpr SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MIN = SPPParameter_PoolMethod_MAX;
constexpr SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MAX = SPPParameter_PoolMethod_STOCHASTIC;
constexpr int SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE = SPPParameter_PoolMethod_PoolMethod_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_PoolMethod_descriptor();
template<typename T>
inline const std::string& SPPParameter_PoolMethod_Name(T enum_t_value) {
static_assert(::std::is_same<T, SPPParameter_PoolMethod>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SPPParameter_PoolMethod_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
SPPParameter_PoolMethod_descriptor(), enum_t_value);
}
inline bool SPPParameter_PoolMethod_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SPPParameter_PoolMethod* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SPPParameter_PoolMethod>(
SPPParameter_PoolMethod_descriptor(), name, value);
}
enum SPPParameter_Engine : int {
SPPParameter_Engine_DEFAULT = 0,
SPPParameter_Engine_CAFFE = 1,
SPPParameter_Engine_CUDNN = 2
};
bool SPPParameter_Engine_IsValid(int value);
constexpr SPPParameter_Engine SPPParameter_Engine_Engine_MIN = SPPParameter_Engine_DEFAULT;
constexpr SPPParameter_Engine SPPParameter_Engine_Engine_MAX = SPPParameter_Engine_CUDNN;
constexpr int SPPParameter_Engine_Engine_ARRAYSIZE = SPPParameter_Engine_Engine_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_Engine_descriptor();
template<typename T>
inline const std::string& SPPParameter_Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, SPPParameter_Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SPPParameter_Engine_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
SPPParameter_Engine_descriptor(), enum_t_value);
}
inline bool SPPParameter_Engine_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SPPParameter_Engine* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SPPParameter_Engine>(
SPPParameter_Engine_descriptor(), name, value);
}
enum V1LayerParameter_LayerType : int {
V1LayerParameter_LayerType_NONE = 0,
V1LayerParameter_LayerType_ABSVAL = 35,
V1LayerParameter_LayerType_ACCURACY = 1,
V1LayerParameter_LayerType_ARGMAX = 30,
V1LayerParameter_LayerType_BNLL = 2,
V1LayerParameter_LayerType_CONCAT = 3,
V1LayerParameter_LayerType_CONTRASTIVE_LOSS = 37,
V1LayerParameter_LayerType_CONVOLUTION = 4,
V1LayerParameter_LayerType_DATA = 5,
V1LayerParameter_LayerType_DECONVOLUTION = 39,
V1LayerParameter_LayerType_DROPOUT = 6,
V1LayerParameter_LayerType_DUMMY_DATA = 32,
V1LayerParameter_LayerType_EUCLIDEAN_LOSS = 7,
V1LayerParameter_LayerType_ELTWISE = 25,
V1LayerParameter_LayerType_EXP = 38,
V1LayerParameter_LayerType_FLATTEN = 8,
V1LayerParameter_LayerType_HDF5_DATA = 9,
V1LayerParameter_LayerType_HDF5_OUTPUT = 10,
V1LayerParameter_LayerType_HINGE_LOSS = 28,
V1LayerParameter_LayerType_IM2COL = 11,
V1LayerParameter_LayerType_IMAGE_DATA = 12,
V1LayerParameter_LayerType_INFOGAIN_LOSS = 13,
V1LayerParameter_LayerType_INNER_PRODUCT = 14,
V1LayerParameter_LayerType_LRN = 15,
V1LayerParameter_LayerType_MEMORY_DATA = 29,
V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS = 16,
V1LayerParameter_LayerType_MVN = 34,
V1LayerParameter_LayerType_POOLING = 17,
V1LayerParameter_LayerType_POWER = 26,
V1LayerParameter_LayerType_RELU = 18,
V1LayerParameter_LayerType_SIGMOID = 19,
V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS = 27,
V1LayerParameter_LayerType_SILENCE = 36,
V1LayerParameter_LayerType_SOFTMAX = 20,
V1LayerParameter_LayerType_SOFTMAX_LOSS = 21,
V1LayerParameter_LayerType_SPLIT = 22,
V1LayerParameter_LayerType_SLICE = 33,
V1LayerParameter_LayerType_TANH = 23,
V1LayerParameter_LayerType_WINDOW_DATA = 24,
V1LayerParameter_LayerType_THRESHOLD = 31
};
bool V1LayerParameter_LayerType_IsValid(int value);
constexpr V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MIN = V1LayerParameter_LayerType_NONE;
constexpr V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MAX = V1LayerParameter_LayerType_DECONVOLUTION;
constexpr int V1LayerParameter_LayerType_LayerType_ARRAYSIZE = V1LayerParameter_LayerType_LayerType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_LayerType_descriptor();
template<typename T>
inline const std::string& V1LayerParameter_LayerType_Name(T enum_t_value) {
static_assert(::std::is_same<T, V1LayerParameter_LayerType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function V1LayerParameter_LayerType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
V1LayerParameter_LayerType_descriptor(), enum_t_value);
}
inline bool V1LayerParameter_LayerType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1LayerParameter_LayerType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<V1LayerParameter_LayerType>(
V1LayerParameter_LayerType_descriptor(), name, value);
}
enum V1LayerParameter_DimCheckMode : int {
V1LayerParameter_DimCheckMode_STRICT = 0,
V1LayerParameter_DimCheckMode_PERMISSIVE = 1
};
bool V1LayerParameter_DimCheckMode_IsValid(int value);
constexpr V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MIN = V1LayerParameter_DimCheckMode_STRICT;
constexpr V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MAX = V1LayerParameter_DimCheckMode_PERMISSIVE;
constexpr int V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE = V1LayerParameter_DimCheckMode_DimCheckMode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor();
template<typename T>
inline const std::string& V1LayerParameter_DimCheckMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, V1LayerParameter_DimCheckMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function V1LayerParameter_DimCheckMode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
V1LayerParameter_DimCheckMode_descriptor(), enum_t_value);
}
inline bool V1LayerParameter_DimCheckMode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1LayerParameter_DimCheckMode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<V1LayerParameter_DimCheckMode>(
V1LayerParameter_DimCheckMode_descriptor(), name, value);
}
enum V0LayerParameter_PoolMethod : int {
V0LayerParameter_PoolMethod_MAX = 0,
V0LayerParameter_PoolMethod_AVE = 1,
V0LayerParameter_PoolMethod_STOCHASTIC = 2
};
bool V0LayerParameter_PoolMethod_IsValid(int value);
constexpr V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MIN = V0LayerParameter_PoolMethod_MAX;
constexpr V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MAX = V0LayerParameter_PoolMethod_STOCHASTIC;
constexpr int V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE = V0LayerParameter_PoolMethod_PoolMethod_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor();
template<typename T>
inline const std::string& V0LayerParameter_PoolMethod_Name(T enum_t_value) {
static_assert(::std::is_same<T, V0LayerParameter_PoolMethod>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function V0LayerParameter_PoolMethod_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
V0LayerParameter_PoolMethod_descriptor(), enum_t_value);
}
inline bool V0LayerParameter_PoolMethod_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V0LayerParameter_PoolMethod* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<V0LayerParameter_PoolMethod>(
V0LayerParameter_PoolMethod_descriptor(), name, value);
}
enum Phase : int {
TRAIN = 0,
TEST = 1,
QUAN = 2,
INT8 = 3
};
bool Phase_IsValid(int value);
constexpr Phase Phase_MIN = TRAIN;
constexpr Phase Phase_MAX = INT8;
constexpr int Phase_ARRAYSIZE = Phase_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Phase_descriptor();
template<typename T>
inline const std::string& Phase_Name(T enum_t_value) {
static_assert(::std::is_same<T, Phase>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Phase_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
Phase_descriptor(), enum_t_value);
}
inline bool Phase_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Phase* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Phase>(
Phase_descriptor(), name, value);
}
// ===================================================================
class BlobShape final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.BlobShape) */ {
public:
inline BlobShape() : BlobShape(nullptr) {}
~BlobShape() override;
explicit constexpr BlobShape(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
BlobShape(const BlobShape& from);
BlobShape(BlobShape&& from) noexcept
: BlobShape() {
*this = ::std::move(from);
}
inline BlobShape& operator=(const BlobShape& from) {
CopyFrom(from);
return *this;
}
inline BlobShape& operator=(BlobShape&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const BlobShape& default_instance() {
return *internal_default_instance();
}
static inline const BlobShape* internal_default_instance() {
return reinterpret_cast<const BlobShape*>(
&_BlobShape_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(BlobShape& a, BlobShape& b) {
a.Swap(&b);
}
inline void Swap(BlobShape* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(BlobShape* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
BlobShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<BlobShape>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const BlobShape& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const BlobShape& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(BlobShape* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.BlobShape";
}
protected:
explicit BlobShape(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDimFieldNumber = 1,
};
// repeated int64 dim = 1 [packed = true];
int dim_size() const;
private:
int _internal_dim_size() const;
public:
void clear_dim();
private:
int64_t _internal_dim(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
_internal_dim() const;
void _internal_add_dim(int64_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
_internal_mutable_dim();
public:
int64_t dim(int index) const;
void set_dim(int index, int64_t value);
void add_dim(int64_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
dim() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
mutable_dim();
// @@protoc_insertion_point(class_scope:caffe.BlobShape)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dim_;
mutable std::atomic<int> _dim_cached_byte_size_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class BlobProto final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.BlobProto) */ {
public:
inline BlobProto() : BlobProto(nullptr) {}
~BlobProto() override;
explicit constexpr BlobProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
BlobProto(const BlobProto& from);
BlobProto(BlobProto&& from) noexcept
: BlobProto() {
*this = ::std::move(from);
}
inline BlobProto& operator=(const BlobProto& from) {
CopyFrom(from);
return *this;
}
inline BlobProto& operator=(BlobProto&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const BlobProto& default_instance() {
return *internal_default_instance();
}
static inline const BlobProto* internal_default_instance() {
return reinterpret_cast<const BlobProto*>(
&_BlobProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(BlobProto& a, BlobProto& b) {
a.Swap(&b);
}
inline void Swap(BlobProto* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(BlobProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
BlobProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<BlobProto>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const BlobProto& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const BlobProto& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(BlobProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.BlobProto";
}
protected:
explicit BlobProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDataFieldNumber = 5,
kDiffFieldNumber = 6,
kDoubleDataFieldNumber = 8,
kDoubleDiffFieldNumber = 9,
kShapeFieldNumber = 7,
kNumFieldNumber = 1,
kChannelsFieldNumber = 2,
kHeightFieldNumber = 3,
kWidthFieldNumber = 4,
};
// repeated float data = 5 [packed = true];
int data_size() const;
private:
int _internal_data_size() const;
public:
void clear_data();
private:
float _internal_data(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_data() const;
void _internal_add_data(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_data();
public:
float data(int index) const;
void set_data(int index, float value);
void add_data(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
data() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_data();
// repeated float diff = 6 [packed = true];
int diff_size() const;
private:
int _internal_diff_size() const;
public:
void clear_diff();
private:
float _internal_diff(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_diff() const;
void _internal_add_diff(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_diff();
public:
float diff(int index) const;
void set_diff(int index, float value);
void add_diff(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
diff() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_diff();
// repeated double double_data = 8 [packed = true];
int double_data_size() const;
private:
int _internal_double_data_size() const;
public:
void clear_double_data();
private:
double _internal_double_data(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
_internal_double_data() const;
void _internal_add_double_data(double value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
_internal_mutable_double_data();
public:
double double_data(int index) const;
void set_double_data(int index, double value);
void add_double_data(double value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
double_data() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
mutable_double_data();
// repeated double double_diff = 9 [packed = true];
int double_diff_size() const;
private:
int _internal_double_diff_size() const;
public:
void clear_double_diff();
private:
double _internal_double_diff(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
_internal_double_diff() const;
void _internal_add_double_diff(double value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
_internal_mutable_double_diff();
public:
double double_diff(int index) const;
void set_double_diff(int index, double value);
void add_double_diff(double value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
double_diff() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
mutable_double_diff();
// optional .caffe.BlobShape shape = 7;
bool has_shape() const;
private:
bool _internal_has_shape() const;
public:
void clear_shape();
const ::caffe::BlobShape& shape() const;
PROTOBUF_NODISCARD ::caffe::BlobShape* release_shape();
::caffe::BlobShape* mutable_shape();
void set_allocated_shape(::caffe::BlobShape* shape);
private:
const ::caffe::BlobShape& _internal_shape() const;
::caffe::BlobShape* _internal_mutable_shape();
public:
void unsafe_arena_set_allocated_shape(
::caffe::BlobShape* shape);
::caffe::BlobShape* unsafe_arena_release_shape();
// optional int32 num = 1 [default = 0];
bool has_num() const;
private:
bool _internal_has_num() const;
public:
void clear_num();
int32_t num() const;
void set_num(int32_t value);
private:
int32_t _internal_num() const;
void _internal_set_num(int32_t value);
public:
// optional int32 channels = 2 [default = 0];
bool has_channels() const;
private:
bool _internal_has_channels() const;
public:
void clear_channels();
int32_t channels() const;
void set_channels(int32_t value);
private:
int32_t _internal_channels() const;
void _internal_set_channels(int32_t value);
public:
// optional int32 height = 3 [default = 0];
bool has_height() const;
private:
bool _internal_has_height() const;
public:
void clear_height();
int32_t height() const;
void set_height(int32_t value);
private:
int32_t _internal_height() const;
void _internal_set_height(int32_t value);
public:
// optional int32 width = 4 [default = 0];
bool has_width() const;
private:
bool _internal_has_width() const;
public:
void clear_width();
int32_t width() const;
void set_width(int32_t value);
private:
int32_t _internal_width() const;
void _internal_set_width(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.BlobProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > data_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > diff_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_diff_;
::caffe::BlobShape* shape_;
int32_t num_;
int32_t channels_;
int32_t height_;
int32_t width_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class BlobProtoVector final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.BlobProtoVector) */ {
public:
inline BlobProtoVector() : BlobProtoVector(nullptr) {}
~BlobProtoVector() override;
explicit constexpr BlobProtoVector(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
BlobProtoVector(const BlobProtoVector& from);
BlobProtoVector(BlobProtoVector&& from) noexcept
: BlobProtoVector() {
*this = ::std::move(from);
}
inline BlobProtoVector& operator=(const BlobProtoVector& from) {
CopyFrom(from);
return *this;
}
inline BlobProtoVector& operator=(BlobProtoVector&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const BlobProtoVector& default_instance() {
return *internal_default_instance();
}
static inline const BlobProtoVector* internal_default_instance() {
return reinterpret_cast<const BlobProtoVector*>(
&_BlobProtoVector_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(BlobProtoVector& a, BlobProtoVector& b) {
a.Swap(&b);
}
inline void Swap(BlobProtoVector* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(BlobProtoVector* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
BlobProtoVector* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<BlobProtoVector>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const BlobProtoVector& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const BlobProtoVector& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(BlobProtoVector* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.BlobProtoVector";
}
protected:
explicit BlobProtoVector(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBlobsFieldNumber = 1,
};
// repeated .caffe.BlobProto blobs = 1;
int blobs_size() const;
private:
int _internal_blobs_size() const;
public:
void clear_blobs();
::caffe::BlobProto* mutable_blobs(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
mutable_blobs();
private:
const ::caffe::BlobProto& _internal_blobs(int index) const;
::caffe::BlobProto* _internal_add_blobs();
public:
const ::caffe::BlobProto& blobs(int index) const;
::caffe::BlobProto* add_blobs();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
blobs() const;
// @@protoc_insertion_point(class_scope:caffe.BlobProtoVector)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto > blobs_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class Datum final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.Datum) */ {
public:
inline Datum() : Datum(nullptr) {}
~Datum() override;
explicit constexpr Datum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Datum(const Datum& from);
Datum(Datum&& from) noexcept
: Datum() {
*this = ::std::move(from);
}
inline Datum& operator=(const Datum& from) {
CopyFrom(from);
return *this;
}
inline Datum& operator=(Datum&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Datum& default_instance() {
return *internal_default_instance();
}
static inline const Datum* internal_default_instance() {
return reinterpret_cast<const Datum*>(
&_Datum_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(Datum& a, Datum& b) {
a.Swap(&b);
}
inline void Swap(Datum* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Datum* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Datum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Datum>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Datum& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Datum& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Datum* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.Datum";
}
protected:
explicit Datum(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kFloatDataFieldNumber = 6,
kLabelsFieldNumber = 8,
kFloatLabelsFieldNumber = 10,
kDataFieldNumber = 4,
kByteLabelsFieldNumber = 11,
kChannelsFieldNumber = 1,
kHeightFieldNumber = 2,
kWidthFieldNumber = 3,
kLabelFieldNumber = 5,
kEncodedFieldNumber = 7,
kFloatLabelFieldNumber = 9,
};
// repeated float float_data = 6;
int float_data_size() const;
private:
int _internal_float_data_size() const;
public:
void clear_float_data();
private:
float _internal_float_data(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_float_data() const;
void _internal_add_float_data(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_float_data();
public:
float float_data(int index) const;
void set_float_data(int index, float value);
void add_float_data(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
float_data() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_float_data();
// repeated int32 labels = 8;
int labels_size() const;
private:
int _internal_labels_size() const;
public:
void clear_labels();
private:
int32_t _internal_labels(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
_internal_labels() const;
void _internal_add_labels(int32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
_internal_mutable_labels();
public:
int32_t labels(int index) const;
void set_labels(int index, int32_t value);
void add_labels(int32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
labels() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
mutable_labels();
// repeated float float_labels = 10;
int float_labels_size() const;
private:
int _internal_float_labels_size() const;
public:
void clear_float_labels();
private:
float _internal_float_labels(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_float_labels() const;
void _internal_add_float_labels(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_float_labels();
public:
float float_labels(int index) const;
void set_float_labels(int index, float value);
void add_float_labels(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
float_labels() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_float_labels();
// optional bytes data = 4;
bool has_data() const;
private:
bool _internal_has_data() const;
public:
void clear_data();
const std::string& data() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_data(ArgT0&& arg0, ArgT... args);
std::string* mutable_data();
PROTOBUF_NODISCARD std::string* release_data();
void set_allocated_data(std::string* data);
private:
const std::string& _internal_data() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
std::string* _internal_mutable_data();
public:
// optional bytes byte_labels = 11;
bool has_byte_labels() const;
private:
bool _internal_has_byte_labels() const;
public:
void clear_byte_labels();
const std::string& byte_labels() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_byte_labels(ArgT0&& arg0, ArgT... args);
std::string* mutable_byte_labels();
PROTOBUF_NODISCARD std::string* release_byte_labels();
void set_allocated_byte_labels(std::string* byte_labels);
private:
const std::string& _internal_byte_labels() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_byte_labels(const std::string& value);
std::string* _internal_mutable_byte_labels();
public:
// optional int32 channels = 1;
bool has_channels() const;
private:
bool _internal_has_channels() const;
public:
void clear_channels();
int32_t channels() const;
void set_channels(int32_t value);
private:
int32_t _internal_channels() const;
void _internal_set_channels(int32_t value);
public:
// optional int32 height = 2;
bool has_height() const;
private:
bool _internal_has_height() const;
public:
void clear_height();
int32_t height() const;
void set_height(int32_t value);
private:
int32_t _internal_height() const;
void _internal_set_height(int32_t value);
public:
// optional int32 width = 3;
bool has_width() const;
private:
bool _internal_has_width() const;
public:
void clear_width();
int32_t width() const;
void set_width(int32_t value);
private:
int32_t _internal_width() const;
void _internal_set_width(int32_t value);
public:
// optional int32 label = 5;
bool has_label() const;
private:
bool _internal_has_label() const;
public:
void clear_label();
int32_t label() const;
void set_label(int32_t value);
private:
int32_t _internal_label() const;
void _internal_set_label(int32_t value);
public:
// optional bool encoded = 7 [default = false];
bool has_encoded() const;
private:
bool _internal_has_encoded() const;
public:
void clear_encoded();
bool encoded() const;
void set_encoded(bool value);
private:
bool _internal_encoded() const;
void _internal_set_encoded(bool value);
public:
// optional float float_label = 9;
bool has_float_label() const;
private:
bool _internal_has_float_label() const;
public:
void clear_float_label();
float float_label() const;
void set_float_label(float value);
private:
float _internal_float_label() const;
void _internal_set_float_label(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.Datum)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > labels_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_labels_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr byte_labels_;
int32_t channels_;
int32_t height_;
int32_t width_;
int32_t label_;
bool encoded_;
float float_label_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class MTCNNBBox final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.MTCNNBBox) */ {
public:
inline MTCNNBBox() : MTCNNBBox(nullptr) {}
~MTCNNBBox() override;
explicit constexpr MTCNNBBox(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
MTCNNBBox(const MTCNNBBox& from);
MTCNNBBox(MTCNNBBox&& from) noexcept
: MTCNNBBox() {
*this = ::std::move(from);
}
inline MTCNNBBox& operator=(const MTCNNBBox& from) {
CopyFrom(from);
return *this;
}
inline MTCNNBBox& operator=(MTCNNBBox&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const MTCNNBBox& default_instance() {
return *internal_default_instance();
}
static inline const MTCNNBBox* internal_default_instance() {
return reinterpret_cast<const MTCNNBBox*>(
&_MTCNNBBox_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
friend void swap(MTCNNBBox& a, MTCNNBBox& b) {
a.Swap(&b);
}
inline void Swap(MTCNNBBox* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MTCNNBBox* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
MTCNNBBox* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<MTCNNBBox>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const MTCNNBBox& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const MTCNNBBox& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MTCNNBBox* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.MTCNNBBox";
}
protected:
explicit MTCNNBBox(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kXminFieldNumber = 1,
kYminFieldNumber = 2,
kXmaxFieldNumber = 3,
kYmaxFieldNumber = 4,
};
// optional float xmin = 1;
bool has_xmin() const;
private:
bool _internal_has_xmin() const;
public:
void clear_xmin();
float xmin() const;
void set_xmin(float value);
private:
float _internal_xmin() const;
void _internal_set_xmin(float value);
public:
// optional float ymin = 2;
bool has_ymin() const;
private:
bool _internal_has_ymin() const;
public:
void clear_ymin();
float ymin() const;
void set_ymin(float value);
private:
float _internal_ymin() const;
void _internal_set_ymin(float value);
public:
// optional float xmax = 3;
bool has_xmax() const;
private:
bool _internal_has_xmax() const;
public:
void clear_xmax();
float xmax() const;
void set_xmax(float value);
private:
float _internal_xmax() const;
void _internal_set_xmax(float value);
public:
// optional float ymax = 4;
bool has_ymax() const;
private:
bool _internal_has_ymax() const;
public:
void clear_ymax();
float ymax() const;
void set_ymax(float value);
private:
float _internal_ymax() const;
void _internal_set_ymax(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.MTCNNBBox)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float xmin_;
float ymin_;
float xmax_;
float ymax_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class MTCNNDatum final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.MTCNNDatum) */ {
public:
inline MTCNNDatum() : MTCNNDatum(nullptr) {}
~MTCNNDatum() override;
explicit constexpr MTCNNDatum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
MTCNNDatum(const MTCNNDatum& from);
MTCNNDatum(MTCNNDatum&& from) noexcept
: MTCNNDatum() {
*this = ::std::move(from);
}
inline MTCNNDatum& operator=(const MTCNNDatum& from) {
CopyFrom(from);
return *this;
}
inline MTCNNDatum& operator=(MTCNNDatum&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const MTCNNDatum& default_instance() {
return *internal_default_instance();
}
static inline const MTCNNDatum* internal_default_instance() {
return reinterpret_cast<const MTCNNDatum*>(
&_MTCNNDatum_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
friend void swap(MTCNNDatum& a, MTCNNDatum& b) {
a.Swap(&b);
}
inline void Swap(MTCNNDatum* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MTCNNDatum* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
MTCNNDatum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<MTCNNDatum>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const MTCNNDatum& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const MTCNNDatum& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MTCNNDatum* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.MTCNNDatum";
}
protected:
explicit MTCNNDatum(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kPtsFieldNumber = 3,
kDatumFieldNumber = 1,
kRoiFieldNumber = 2,
};
// repeated float pts = 3;
int pts_size() const;
private:
int _internal_pts_size() const;
public:
void clear_pts();
private:
float _internal_pts(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_pts() const;
void _internal_add_pts(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_pts();
public:
float pts(int index) const;
void set_pts(int index, float value);
void add_pts(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
pts() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_pts();
// optional .caffe.Datum datum = 1;
bool has_datum() const;
private:
bool _internal_has_datum() const;
public:
void clear_datum();
const ::caffe::Datum& datum() const;
PROTOBUF_NODISCARD ::caffe::Datum* release_datum();
::caffe::Datum* mutable_datum();
void set_allocated_datum(::caffe::Datum* datum);
private:
const ::caffe::Datum& _internal_datum() const;
::caffe::Datum* _internal_mutable_datum();
public:
void unsafe_arena_set_allocated_datum(
::caffe::Datum* datum);
::caffe::Datum* unsafe_arena_release_datum();
// optional .caffe.MTCNNBBox roi = 2;
bool has_roi() const;
private:
bool _internal_has_roi() const;
public:
void clear_roi();
const ::caffe::MTCNNBBox& roi() const;
PROTOBUF_NODISCARD ::caffe::MTCNNBBox* release_roi();
::caffe::MTCNNBBox* mutable_roi();
void set_allocated_roi(::caffe::MTCNNBBox* roi);
private:
const ::caffe::MTCNNBBox& _internal_roi() const;
::caffe::MTCNNBBox* _internal_mutable_roi();
public:
void unsafe_arena_set_allocated_roi(
::caffe::MTCNNBBox* roi);
::caffe::MTCNNBBox* unsafe_arena_release_roi();
// @@protoc_insertion_point(class_scope:caffe.MTCNNDatum)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > pts_;
::caffe::Datum* datum_;
::caffe::MTCNNBBox* roi_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class LabelMapItem final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.LabelMapItem) */ {
public:
inline LabelMapItem() : LabelMapItem(nullptr) {}
~LabelMapItem() override;
explicit constexpr LabelMapItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
LabelMapItem(const LabelMapItem& from);
LabelMapItem(LabelMapItem&& from) noexcept
: LabelMapItem() {
*this = ::std::move(from);
}
inline LabelMapItem& operator=(const LabelMapItem& from) {
CopyFrom(from);
return *this;
}
inline LabelMapItem& operator=(LabelMapItem&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const LabelMapItem& default_instance() {
return *internal_default_instance();
}
static inline const LabelMapItem* internal_default_instance() {
return reinterpret_cast<const LabelMapItem*>(
&_LabelMapItem_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
friend void swap(LabelMapItem& a, LabelMapItem& b) {
a.Swap(&b);
}
inline void Swap(LabelMapItem* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(LabelMapItem* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
LabelMapItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<LabelMapItem>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const LabelMapItem& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const LabelMapItem& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(LabelMapItem* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.LabelMapItem";
}
protected:
explicit LabelMapItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNameFieldNumber = 1,
kDisplayNameFieldNumber = 3,
kLabelFieldNumber = 2,
};
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string display_name = 3;
bool has_display_name() const;
private:
bool _internal_has_display_name() const;
public:
void clear_display_name();
const std::string& display_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_display_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_display_name();
PROTOBUF_NODISCARD std::string* release_display_name();
void set_allocated_display_name(std::string* display_name);
private:
const std::string& _internal_display_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_display_name(const std::string& value);
std::string* _internal_mutable_display_name();
public:
// optional int32 label = 2;
bool has_label() const;
private:
bool _internal_has_label() const;
public:
void clear_label();
int32_t label() const;
void set_label(int32_t value);
private:
int32_t _internal_label() const;
void _internal_set_label(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.LabelMapItem)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr display_name_;
int32_t label_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class LabelMap final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.LabelMap) */ {
public:
inline LabelMap() : LabelMap(nullptr) {}
~LabelMap() override;
explicit constexpr LabelMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
LabelMap(const LabelMap& from);
LabelMap(LabelMap&& from) noexcept
: LabelMap() {
*this = ::std::move(from);
}
inline LabelMap& operator=(const LabelMap& from) {
CopyFrom(from);
return *this;
}
inline LabelMap& operator=(LabelMap&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const LabelMap& default_instance() {
return *internal_default_instance();
}
static inline const LabelMap* internal_default_instance() {
return reinterpret_cast<const LabelMap*>(
&_LabelMap_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
friend void swap(LabelMap& a, LabelMap& b) {
a.Swap(&b);
}
inline void Swap(LabelMap* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(LabelMap* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
LabelMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<LabelMap>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const LabelMap& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const LabelMap& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(LabelMap* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.LabelMap";
}
protected:
explicit LabelMap(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kItemFieldNumber = 1,
};
// repeated .caffe.LabelMapItem item = 1;
int item_size() const;
private:
int _internal_item_size() const;
public:
void clear_item();
::caffe::LabelMapItem* mutable_item(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LabelMapItem >*
mutable_item();
private:
const ::caffe::LabelMapItem& _internal_item(int index) const;
::caffe::LabelMapItem* _internal_add_item();
public:
const ::caffe::LabelMapItem& item(int index) const;
::caffe::LabelMapItem* add_item();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LabelMapItem >&
item() const;
// @@protoc_insertion_point(class_scope:caffe.LabelMap)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LabelMapItem > item_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class Sampler final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.Sampler) */ {
public:
inline Sampler() : Sampler(nullptr) {}
~Sampler() override;
explicit constexpr Sampler(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Sampler(const Sampler& from);
Sampler(Sampler&& from) noexcept
: Sampler() {
*this = ::std::move(from);
}
inline Sampler& operator=(const Sampler& from) {
CopyFrom(from);
return *this;
}
inline Sampler& operator=(Sampler&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Sampler& default_instance() {
return *internal_default_instance();
}
static inline const Sampler* internal_default_instance() {
return reinterpret_cast<const Sampler*>(
&_Sampler_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
friend void swap(Sampler& a, Sampler& b) {
a.Swap(&b);
}
inline void Swap(Sampler* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Sampler* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Sampler* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Sampler>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Sampler& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Sampler& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Sampler* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.Sampler";
}
protected:
explicit Sampler(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMinScaleFieldNumber = 1,
kMaxScaleFieldNumber = 2,
kMinAspectRatioFieldNumber = 3,
kMaxAspectRatioFieldNumber = 4,
};
// optional float min_scale = 1 [default = 1];
bool has_min_scale() const;
private:
bool _internal_has_min_scale() const;
public:
void clear_min_scale();
float min_scale() const;
void set_min_scale(float value);
private:
float _internal_min_scale() const;
void _internal_set_min_scale(float value);
public:
// optional float max_scale = 2 [default = 1];
bool has_max_scale() const;
private:
bool _internal_has_max_scale() const;
public:
void clear_max_scale();
float max_scale() const;
void set_max_scale(float value);
private:
float _internal_max_scale() const;
void _internal_set_max_scale(float value);
public:
// optional float min_aspect_ratio = 3 [default = 1];
bool has_min_aspect_ratio() const;
private:
bool _internal_has_min_aspect_ratio() const;
public:
void clear_min_aspect_ratio();
float min_aspect_ratio() const;
void set_min_aspect_ratio(float value);
private:
float _internal_min_aspect_ratio() const;
void _internal_set_min_aspect_ratio(float value);
public:
// optional float max_aspect_ratio = 4 [default = 1];
bool has_max_aspect_ratio() const;
private:
bool _internal_has_max_aspect_ratio() const;
public:
void clear_max_aspect_ratio();
float max_aspect_ratio() const;
void set_max_aspect_ratio(float value);
private:
float _internal_max_aspect_ratio() const;
void _internal_set_max_aspect_ratio(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.Sampler)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float min_scale_;
float max_scale_;
float min_aspect_ratio_;
float max_aspect_ratio_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class SampleConstraint final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.SampleConstraint) */ {
public:
inline SampleConstraint() : SampleConstraint(nullptr) {}
~SampleConstraint() override;
explicit constexpr SampleConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SampleConstraint(const SampleConstraint& from);
SampleConstraint(SampleConstraint&& from) noexcept
: SampleConstraint() {
*this = ::std::move(from);
}
inline SampleConstraint& operator=(const SampleConstraint& from) {
CopyFrom(from);
return *this;
}
inline SampleConstraint& operator=(SampleConstraint&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SampleConstraint& default_instance() {
return *internal_default_instance();
}
static inline const SampleConstraint* internal_default_instance() {
return reinterpret_cast<const SampleConstraint*>(
&_SampleConstraint_default_instance_);
}
static constexpr int kIndexInFileMessages =
9;
friend void swap(SampleConstraint& a, SampleConstraint& b) {
a.Swap(&b);
}
inline void Swap(SampleConstraint* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SampleConstraint* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SampleConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SampleConstraint>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SampleConstraint& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const SampleConstraint& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SampleConstraint* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.SampleConstraint";
}
protected:
explicit SampleConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMinJaccardOverlapFieldNumber = 1,
kMaxJaccardOverlapFieldNumber = 2,
kMinSampleCoverageFieldNumber = 3,
kMaxSampleCoverageFieldNumber = 4,
kMinObjectCoverageFieldNumber = 5,
kMaxObjectCoverageFieldNumber = 6,
};
// optional float min_jaccard_overlap = 1;
bool has_min_jaccard_overlap() const;
private:
bool _internal_has_min_jaccard_overlap() const;
public:
void clear_min_jaccard_overlap();
float min_jaccard_overlap() const;
void set_min_jaccard_overlap(float value);
private:
float _internal_min_jaccard_overlap() const;
void _internal_set_min_jaccard_overlap(float value);
public:
// optional float max_jaccard_overlap = 2;
bool has_max_jaccard_overlap() const;
private:
bool _internal_has_max_jaccard_overlap() const;
public:
void clear_max_jaccard_overlap();
float max_jaccard_overlap() const;
void set_max_jaccard_overlap(float value);
private:
float _internal_max_jaccard_overlap() const;
void _internal_set_max_jaccard_overlap(float value);
public:
// optional float min_sample_coverage = 3;
bool has_min_sample_coverage() const;
private:
bool _internal_has_min_sample_coverage() const;
public:
void clear_min_sample_coverage();
float min_sample_coverage() const;
void set_min_sample_coverage(float value);
private:
float _internal_min_sample_coverage() const;
void _internal_set_min_sample_coverage(float value);
public:
// optional float max_sample_coverage = 4;
bool has_max_sample_coverage() const;
private:
bool _internal_has_max_sample_coverage() const;
public:
void clear_max_sample_coverage();
float max_sample_coverage() const;
void set_max_sample_coverage(float value);
private:
float _internal_max_sample_coverage() const;
void _internal_set_max_sample_coverage(float value);
public:
// optional float min_object_coverage = 5;
bool has_min_object_coverage() const;
private:
bool _internal_has_min_object_coverage() const;
public:
void clear_min_object_coverage();
float min_object_coverage() const;
void set_min_object_coverage(float value);
private:
float _internal_min_object_coverage() const;
void _internal_set_min_object_coverage(float value);
public:
// optional float max_object_coverage = 6;
bool has_max_object_coverage() const;
private:
bool _internal_has_max_object_coverage() const;
public:
void clear_max_object_coverage();
float max_object_coverage() const;
void set_max_object_coverage(float value);
private:
float _internal_max_object_coverage() const;
void _internal_set_max_object_coverage(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.SampleConstraint)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float min_jaccard_overlap_;
float max_jaccard_overlap_;
float min_sample_coverage_;
float max_sample_coverage_;
float min_object_coverage_;
float max_object_coverage_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class BatchSampler final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.BatchSampler) */ {
public:
inline BatchSampler() : BatchSampler(nullptr) {}
~BatchSampler() override;
explicit constexpr BatchSampler(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
BatchSampler(const BatchSampler& from);
BatchSampler(BatchSampler&& from) noexcept
: BatchSampler() {
*this = ::std::move(from);
}
inline BatchSampler& operator=(const BatchSampler& from) {
CopyFrom(from);
return *this;
}
inline BatchSampler& operator=(BatchSampler&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const BatchSampler& default_instance() {
return *internal_default_instance();
}
static inline const BatchSampler* internal_default_instance() {
return reinterpret_cast<const BatchSampler*>(
&_BatchSampler_default_instance_);
}
static constexpr int kIndexInFileMessages =
10;
friend void swap(BatchSampler& a, BatchSampler& b) {
a.Swap(&b);
}
inline void Swap(BatchSampler* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(BatchSampler* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
BatchSampler* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<BatchSampler>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const BatchSampler& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const BatchSampler& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(BatchSampler* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.BatchSampler";
}
protected:
explicit BatchSampler(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSamplerFieldNumber = 2,
kSampleConstraintFieldNumber = 3,
kMaxSampleFieldNumber = 4,
kUseOriginalImageFieldNumber = 1,
kMaxTrialsFieldNumber = 5,
};
// optional .caffe.Sampler sampler = 2;
bool has_sampler() const;
private:
bool _internal_has_sampler() const;
public:
void clear_sampler();
const ::caffe::Sampler& sampler() const;
PROTOBUF_NODISCARD ::caffe::Sampler* release_sampler();
::caffe::Sampler* mutable_sampler();
void set_allocated_sampler(::caffe::Sampler* sampler);
private:
const ::caffe::Sampler& _internal_sampler() const;
::caffe::Sampler* _internal_mutable_sampler();
public:
void unsafe_arena_set_allocated_sampler(
::caffe::Sampler* sampler);
::caffe::Sampler* unsafe_arena_release_sampler();
// optional .caffe.SampleConstraint sample_constraint = 3;
bool has_sample_constraint() const;
private:
bool _internal_has_sample_constraint() const;
public:
void clear_sample_constraint();
const ::caffe::SampleConstraint& sample_constraint() const;
PROTOBUF_NODISCARD ::caffe::SampleConstraint* release_sample_constraint();
::caffe::SampleConstraint* mutable_sample_constraint();
void set_allocated_sample_constraint(::caffe::SampleConstraint* sample_constraint);
private:
const ::caffe::SampleConstraint& _internal_sample_constraint() const;
::caffe::SampleConstraint* _internal_mutable_sample_constraint();
public:
void unsafe_arena_set_allocated_sample_constraint(
::caffe::SampleConstraint* sample_constraint);
::caffe::SampleConstraint* unsafe_arena_release_sample_constraint();
// optional uint32 max_sample = 4;
bool has_max_sample() const;
private:
bool _internal_has_max_sample() const;
public:
void clear_max_sample();
uint32_t max_sample() const;
void set_max_sample(uint32_t value);
private:
uint32_t _internal_max_sample() const;
void _internal_set_max_sample(uint32_t value);
public:
// optional bool use_original_image = 1 [default = true];
bool has_use_original_image() const;
private:
bool _internal_has_use_original_image() const;
public:
void clear_use_original_image();
bool use_original_image() const;
void set_use_original_image(bool value);
private:
bool _internal_use_original_image() const;
void _internal_set_use_original_image(bool value);
public:
// optional uint32 max_trials = 5 [default = 100];
bool has_max_trials() const;
private:
bool _internal_has_max_trials() const;
public:
void clear_max_trials();
uint32_t max_trials() const;
void set_max_trials(uint32_t value);
private:
uint32_t _internal_max_trials() const;
void _internal_set_max_trials(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.BatchSampler)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::Sampler* sampler_;
::caffe::SampleConstraint* sample_constraint_;
uint32_t max_sample_;
bool use_original_image_;
uint32_t max_trials_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class EmitConstraint final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.EmitConstraint) */ {
public:
inline EmitConstraint() : EmitConstraint(nullptr) {}
~EmitConstraint() override;
explicit constexpr EmitConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
EmitConstraint(const EmitConstraint& from);
EmitConstraint(EmitConstraint&& from) noexcept
: EmitConstraint() {
*this = ::std::move(from);
}
inline EmitConstraint& operator=(const EmitConstraint& from) {
CopyFrom(from);
return *this;
}
inline EmitConstraint& operator=(EmitConstraint&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const EmitConstraint& default_instance() {
return *internal_default_instance();
}
static inline const EmitConstraint* internal_default_instance() {
return reinterpret_cast<const EmitConstraint*>(
&_EmitConstraint_default_instance_);
}
static constexpr int kIndexInFileMessages =
11;
friend void swap(EmitConstraint& a, EmitConstraint& b) {
a.Swap(&b);
}
inline void Swap(EmitConstraint* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(EmitConstraint* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
EmitConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<EmitConstraint>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const EmitConstraint& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const EmitConstraint& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(EmitConstraint* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.EmitConstraint";
}
protected:
explicit EmitConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef EmitConstraint_EmitType EmitType;
static constexpr EmitType CENTER =
EmitConstraint_EmitType_CENTER;
static constexpr EmitType MIN_OVERLAP =
EmitConstraint_EmitType_MIN_OVERLAP;
static inline bool EmitType_IsValid(int value) {
return EmitConstraint_EmitType_IsValid(value);
}
static constexpr EmitType EmitType_MIN =
EmitConstraint_EmitType_EmitType_MIN;
static constexpr EmitType EmitType_MAX =
EmitConstraint_EmitType_EmitType_MAX;
static constexpr int EmitType_ARRAYSIZE =
EmitConstraint_EmitType_EmitType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
EmitType_descriptor() {
return EmitConstraint_EmitType_descriptor();
}
template<typename T>
static inline const std::string& EmitType_Name(T enum_t_value) {
static_assert(::std::is_same<T, EmitType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function EmitType_Name.");
return EmitConstraint_EmitType_Name(enum_t_value);
}
static inline bool EmitType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
EmitType* value) {
return EmitConstraint_EmitType_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kEmitTypeFieldNumber = 1,
kEmitOverlapFieldNumber = 2,
};
// optional .caffe.EmitConstraint.EmitType emit_type = 1 [default = CENTER];
bool has_emit_type() const;
private:
bool _internal_has_emit_type() const;
public:
void clear_emit_type();
::caffe::EmitConstraint_EmitType emit_type() const;
void set_emit_type(::caffe::EmitConstraint_EmitType value);
private:
::caffe::EmitConstraint_EmitType _internal_emit_type() const;
void _internal_set_emit_type(::caffe::EmitConstraint_EmitType value);
public:
// optional float emit_overlap = 2;
bool has_emit_overlap() const;
private:
bool _internal_has_emit_overlap() const;
public:
void clear_emit_overlap();
float emit_overlap() const;
void set_emit_overlap(float value);
private:
float _internal_emit_overlap() const;
void _internal_set_emit_overlap(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.EmitConstraint)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int emit_type_;
float emit_overlap_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class NormalizedBBox final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.NormalizedBBox) */ {
public:
inline NormalizedBBox() : NormalizedBBox(nullptr) {}
~NormalizedBBox() override;
explicit constexpr NormalizedBBox(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NormalizedBBox(const NormalizedBBox& from);
NormalizedBBox(NormalizedBBox&& from) noexcept
: NormalizedBBox() {
*this = ::std::move(from);
}
inline NormalizedBBox& operator=(const NormalizedBBox& from) {
CopyFrom(from);
return *this;
}
inline NormalizedBBox& operator=(NormalizedBBox&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const NormalizedBBox& default_instance() {
return *internal_default_instance();
}
static inline const NormalizedBBox* internal_default_instance() {
return reinterpret_cast<const NormalizedBBox*>(
&_NormalizedBBox_default_instance_);
}
static constexpr int kIndexInFileMessages =
12;
friend void swap(NormalizedBBox& a, NormalizedBBox& b) {
a.Swap(&b);
}
inline void Swap(NormalizedBBox* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(NormalizedBBox* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NormalizedBBox* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NormalizedBBox>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const NormalizedBBox& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const NormalizedBBox& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(NormalizedBBox* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.NormalizedBBox";
}
protected:
explicit NormalizedBBox(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kXminFieldNumber = 1,
kYminFieldNumber = 2,
kXmaxFieldNumber = 3,
kYmaxFieldNumber = 4,
kLabelFieldNumber = 5,
kDifficultFieldNumber = 6,
kScoreFieldNumber = 7,
kSizeFieldNumber = 8,
};
// optional float xmin = 1;
bool has_xmin() const;
private:
bool _internal_has_xmin() const;
public:
void clear_xmin();
float xmin() const;
void set_xmin(float value);
private:
float _internal_xmin() const;
void _internal_set_xmin(float value);
public:
// optional float ymin = 2;
bool has_ymin() const;
private:
bool _internal_has_ymin() const;
public:
void clear_ymin();
float ymin() const;
void set_ymin(float value);
private:
float _internal_ymin() const;
void _internal_set_ymin(float value);
public:
// optional float xmax = 3;
bool has_xmax() const;
private:
bool _internal_has_xmax() const;
public:
void clear_xmax();
float xmax() const;
void set_xmax(float value);
private:
float _internal_xmax() const;
void _internal_set_xmax(float value);
public:
// optional float ymax = 4;
bool has_ymax() const;
private:
bool _internal_has_ymax() const;
public:
void clear_ymax();
float ymax() const;
void set_ymax(float value);
private:
float _internal_ymax() const;
void _internal_set_ymax(float value);
public:
// optional int32 label = 5;
bool has_label() const;
private:
bool _internal_has_label() const;
public:
void clear_label();
int32_t label() const;
void set_label(int32_t value);
private:
int32_t _internal_label() const;
void _internal_set_label(int32_t value);
public:
// optional bool difficult = 6;
bool has_difficult() const;
private:
bool _internal_has_difficult() const;
public:
void clear_difficult();
bool difficult() const;
void set_difficult(bool value);
private:
bool _internal_difficult() const;
void _internal_set_difficult(bool value);
public:
// optional float score = 7;
bool has_score() const;
private:
bool _internal_has_score() const;
public:
void clear_score();
float score() const;
void set_score(float value);
private:
float _internal_score() const;
void _internal_set_score(float value);
public:
// optional float size = 8;
bool has_size() const;
private:
bool _internal_has_size() const;
public:
void clear_size();
float size() const;
void set_size(float value);
private:
float _internal_size() const;
void _internal_set_size(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.NormalizedBBox)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float xmin_;
float ymin_;
float xmax_;
float ymax_;
int32_t label_;
bool difficult_;
float score_;
float size_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class Annotation final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.Annotation) */ {
public:
inline Annotation() : Annotation(nullptr) {}
~Annotation() override;
explicit constexpr Annotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Annotation(const Annotation& from);
Annotation(Annotation&& from) noexcept
: Annotation() {
*this = ::std::move(from);
}
inline Annotation& operator=(const Annotation& from) {
CopyFrom(from);
return *this;
}
inline Annotation& operator=(Annotation&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Annotation& default_instance() {
return *internal_default_instance();
}
static inline const Annotation* internal_default_instance() {
return reinterpret_cast<const Annotation*>(
&_Annotation_default_instance_);
}
static constexpr int kIndexInFileMessages =
13;
friend void swap(Annotation& a, Annotation& b) {
a.Swap(&b);
}
inline void Swap(Annotation* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Annotation* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Annotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Annotation>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Annotation& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Annotation& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Annotation* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.Annotation";
}
protected:
explicit Annotation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBboxFieldNumber = 2,
kInstanceIdFieldNumber = 1,
};
// optional .caffe.NormalizedBBox bbox = 2;
bool has_bbox() const;
private:
bool _internal_has_bbox() const;
public:
void clear_bbox();
const ::caffe::NormalizedBBox& bbox() const;
PROTOBUF_NODISCARD ::caffe::NormalizedBBox* release_bbox();
::caffe::NormalizedBBox* mutable_bbox();
void set_allocated_bbox(::caffe::NormalizedBBox* bbox);
private:
const ::caffe::NormalizedBBox& _internal_bbox() const;
::caffe::NormalizedBBox* _internal_mutable_bbox();
public:
void unsafe_arena_set_allocated_bbox(
::caffe::NormalizedBBox* bbox);
::caffe::NormalizedBBox* unsafe_arena_release_bbox();
// optional int32 instance_id = 1 [default = 0];
bool has_instance_id() const;
private:
bool _internal_has_instance_id() const;
public:
void clear_instance_id();
int32_t instance_id() const;
void set_instance_id(int32_t value);
private:
int32_t _internal_instance_id() const;
void _internal_set_instance_id(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.Annotation)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::NormalizedBBox* bbox_;
int32_t instance_id_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class AnnotationGroup final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.AnnotationGroup) */ {
public:
inline AnnotationGroup() : AnnotationGroup(nullptr) {}
~AnnotationGroup() override;
explicit constexpr AnnotationGroup(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AnnotationGroup(const AnnotationGroup& from);
AnnotationGroup(AnnotationGroup&& from) noexcept
: AnnotationGroup() {
*this = ::std::move(from);
}
inline AnnotationGroup& operator=(const AnnotationGroup& from) {
CopyFrom(from);
return *this;
}
inline AnnotationGroup& operator=(AnnotationGroup&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AnnotationGroup& default_instance() {
return *internal_default_instance();
}
static inline const AnnotationGroup* internal_default_instance() {
return reinterpret_cast<const AnnotationGroup*>(
&_AnnotationGroup_default_instance_);
}
static constexpr int kIndexInFileMessages =
14;
friend void swap(AnnotationGroup& a, AnnotationGroup& b) {
a.Swap(&b);
}
inline void Swap(AnnotationGroup* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AnnotationGroup* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AnnotationGroup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AnnotationGroup>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AnnotationGroup& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const AnnotationGroup& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AnnotationGroup* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.AnnotationGroup";
}
protected:
explicit AnnotationGroup(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kAnnotationFieldNumber = 2,
kGroupLabelFieldNumber = 1,
};
// repeated .caffe.Annotation annotation = 2;
int annotation_size() const;
private:
int _internal_annotation_size() const;
public:
void clear_annotation();
::caffe::Annotation* mutable_annotation(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::Annotation >*
mutable_annotation();
private:
const ::caffe::Annotation& _internal_annotation(int index) const;
::caffe::Annotation* _internal_add_annotation();
public:
const ::caffe::Annotation& annotation(int index) const;
::caffe::Annotation* add_annotation();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::Annotation >&
annotation() const;
// optional int32 group_label = 1;
bool has_group_label() const;
private:
bool _internal_has_group_label() const;
public:
void clear_group_label();
int32_t group_label() const;
void set_group_label(int32_t value);
private:
int32_t _internal_group_label() const;
void _internal_set_group_label(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.AnnotationGroup)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::Annotation > annotation_;
int32_t group_label_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class AnnotatedDatum final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.AnnotatedDatum) */ {
public:
inline AnnotatedDatum() : AnnotatedDatum(nullptr) {}
~AnnotatedDatum() override;
explicit constexpr AnnotatedDatum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AnnotatedDatum(const AnnotatedDatum& from);
AnnotatedDatum(AnnotatedDatum&& from) noexcept
: AnnotatedDatum() {
*this = ::std::move(from);
}
inline AnnotatedDatum& operator=(const AnnotatedDatum& from) {
CopyFrom(from);
return *this;
}
inline AnnotatedDatum& operator=(AnnotatedDatum&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AnnotatedDatum& default_instance() {
return *internal_default_instance();
}
static inline const AnnotatedDatum* internal_default_instance() {
return reinterpret_cast<const AnnotatedDatum*>(
&_AnnotatedDatum_default_instance_);
}
static constexpr int kIndexInFileMessages =
15;
friend void swap(AnnotatedDatum& a, AnnotatedDatum& b) {
a.Swap(&b);
}
inline void Swap(AnnotatedDatum* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AnnotatedDatum* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AnnotatedDatum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AnnotatedDatum>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AnnotatedDatum& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const AnnotatedDatum& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AnnotatedDatum* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.AnnotatedDatum";
}
protected:
explicit AnnotatedDatum(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef AnnotatedDatum_AnnotationType AnnotationType;
static constexpr AnnotationType BBOX =
AnnotatedDatum_AnnotationType_BBOX;
static inline bool AnnotationType_IsValid(int value) {
return AnnotatedDatum_AnnotationType_IsValid(value);
}
static constexpr AnnotationType AnnotationType_MIN =
AnnotatedDatum_AnnotationType_AnnotationType_MIN;
static constexpr AnnotationType AnnotationType_MAX =
AnnotatedDatum_AnnotationType_AnnotationType_MAX;
static constexpr int AnnotationType_ARRAYSIZE =
AnnotatedDatum_AnnotationType_AnnotationType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
AnnotationType_descriptor() {
return AnnotatedDatum_AnnotationType_descriptor();
}
template<typename T>
static inline const std::string& AnnotationType_Name(T enum_t_value) {
static_assert(::std::is_same<T, AnnotationType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function AnnotationType_Name.");
return AnnotatedDatum_AnnotationType_Name(enum_t_value);
}
static inline bool AnnotationType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
AnnotationType* value) {
return AnnotatedDatum_AnnotationType_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kAnnotationGroupFieldNumber = 3,
kDatumFieldNumber = 1,
kTypeFieldNumber = 2,
};
// repeated .caffe.AnnotationGroup annotation_group = 3;
int annotation_group_size() const;
private:
int _internal_annotation_group_size() const;
public:
void clear_annotation_group();
::caffe::AnnotationGroup* mutable_annotation_group(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::AnnotationGroup >*
mutable_annotation_group();
private:
const ::caffe::AnnotationGroup& _internal_annotation_group(int index) const;
::caffe::AnnotationGroup* _internal_add_annotation_group();
public:
const ::caffe::AnnotationGroup& annotation_group(int index) const;
::caffe::AnnotationGroup* add_annotation_group();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::AnnotationGroup >&
annotation_group() const;
// optional .caffe.Datum datum = 1;
bool has_datum() const;
private:
bool _internal_has_datum() const;
public:
void clear_datum();
const ::caffe::Datum& datum() const;
PROTOBUF_NODISCARD ::caffe::Datum* release_datum();
::caffe::Datum* mutable_datum();
void set_allocated_datum(::caffe::Datum* datum);
private:
const ::caffe::Datum& _internal_datum() const;
::caffe::Datum* _internal_mutable_datum();
public:
void unsafe_arena_set_allocated_datum(
::caffe::Datum* datum);
::caffe::Datum* unsafe_arena_release_datum();
// optional .caffe.AnnotatedDatum.AnnotationType type = 2;
bool has_type() const;
private:
bool _internal_has_type() const;
public:
void clear_type();
::caffe::AnnotatedDatum_AnnotationType type() const;
void set_type(::caffe::AnnotatedDatum_AnnotationType value);
private:
::caffe::AnnotatedDatum_AnnotationType _internal_type() const;
void _internal_set_type(::caffe::AnnotatedDatum_AnnotationType value);
public:
// @@protoc_insertion_point(class_scope:caffe.AnnotatedDatum)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::AnnotationGroup > annotation_group_;
::caffe::Datum* datum_;
int type_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class FillerParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.FillerParameter) */ {
public:
inline FillerParameter() : FillerParameter(nullptr) {}
~FillerParameter() override;
explicit constexpr FillerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FillerParameter(const FillerParameter& from);
FillerParameter(FillerParameter&& from) noexcept
: FillerParameter() {
*this = ::std::move(from);
}
inline FillerParameter& operator=(const FillerParameter& from) {
CopyFrom(from);
return *this;
}
inline FillerParameter& operator=(FillerParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const FillerParameter& default_instance() {
return *internal_default_instance();
}
static inline const FillerParameter* internal_default_instance() {
return reinterpret_cast<const FillerParameter*>(
&_FillerParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
16;
friend void swap(FillerParameter& a, FillerParameter& b) {
a.Swap(&b);
}
inline void Swap(FillerParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FillerParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FillerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FillerParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const FillerParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const FillerParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FillerParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.FillerParameter";
}
protected:
explicit FillerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef FillerParameter_VarianceNorm VarianceNorm;
static constexpr VarianceNorm FAN_IN =
FillerParameter_VarianceNorm_FAN_IN;
static constexpr VarianceNorm FAN_OUT =
FillerParameter_VarianceNorm_FAN_OUT;
static constexpr VarianceNorm AVERAGE =
FillerParameter_VarianceNorm_AVERAGE;
static inline bool VarianceNorm_IsValid(int value) {
return FillerParameter_VarianceNorm_IsValid(value);
}
static constexpr VarianceNorm VarianceNorm_MIN =
FillerParameter_VarianceNorm_VarianceNorm_MIN;
static constexpr VarianceNorm VarianceNorm_MAX =
FillerParameter_VarianceNorm_VarianceNorm_MAX;
static constexpr int VarianceNorm_ARRAYSIZE =
FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
VarianceNorm_descriptor() {
return FillerParameter_VarianceNorm_descriptor();
}
template<typename T>
static inline const std::string& VarianceNorm_Name(T enum_t_value) {
static_assert(::std::is_same<T, VarianceNorm>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function VarianceNorm_Name.");
return FillerParameter_VarianceNorm_Name(enum_t_value);
}
static inline bool VarianceNorm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
VarianceNorm* value) {
return FillerParameter_VarianceNorm_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kTypeFieldNumber = 1,
kValueFieldNumber = 2,
kMinFieldNumber = 3,
kMeanFieldNumber = 5,
kVarianceNormFieldNumber = 8,
kSparseFieldNumber = 7,
kMaxFieldNumber = 4,
kStdFieldNumber = 6,
};
// optional string type = 1 [default = "constant"];
bool has_type() const;
private:
bool _internal_has_type() const;
public:
void clear_type();
const std::string& type() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_type(ArgT0&& arg0, ArgT... args);
std::string* mutable_type();
PROTOBUF_NODISCARD std::string* release_type();
void set_allocated_type(std::string* type);
private:
const std::string& _internal_type() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
std::string* _internal_mutable_type();
public:
// optional float value = 2 [default = 0];
bool has_value() const;
private:
bool _internal_has_value() const;
public:
void clear_value();
float value() const;
void set_value(float value);
private:
float _internal_value() const;
void _internal_set_value(float value);
public:
// optional float min = 3 [default = 0];
bool has_min() const;
private:
bool _internal_has_min() const;
public:
void clear_min();
float min() const;
void set_min(float value);
private:
float _internal_min() const;
void _internal_set_min(float value);
public:
// optional float mean = 5 [default = 0];
bool has_mean() const;
private:
bool _internal_has_mean() const;
public:
void clear_mean();
float mean() const;
void set_mean(float value);
private:
float _internal_mean() const;
void _internal_set_mean(float value);
public:
// optional .caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
bool has_variance_norm() const;
private:
bool _internal_has_variance_norm() const;
public:
void clear_variance_norm();
::caffe::FillerParameter_VarianceNorm variance_norm() const;
void set_variance_norm(::caffe::FillerParameter_VarianceNorm value);
private:
::caffe::FillerParameter_VarianceNorm _internal_variance_norm() const;
void _internal_set_variance_norm(::caffe::FillerParameter_VarianceNorm value);
public:
// optional int32 sparse = 7 [default = -1];
bool has_sparse() const;
private:
bool _internal_has_sparse() const;
public:
void clear_sparse();
int32_t sparse() const;
void set_sparse(int32_t value);
private:
int32_t _internal_sparse() const;
void _internal_set_sparse(int32_t value);
public:
// optional float max = 4 [default = 1];
bool has_max() const;
private:
bool _internal_has_max() const;
public:
void clear_max();
float max() const;
void set_max(float value);
private:
float _internal_max() const;
void _internal_set_max(float value);
public:
// optional float std = 6 [default = 1];
bool has_std() const;
private:
bool _internal_has_std() const;
public:
void clear_std();
float std() const;
void set_std(float value);
private:
float _internal_std() const;
void _internal_set_std(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.FillerParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_type_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
float value_;
float min_;
float mean_;
int variance_norm_;
int32_t sparse_;
float max_;
float std_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class NetParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.NetParameter) */ {
public:
inline NetParameter() : NetParameter(nullptr) {}
~NetParameter() override;
explicit constexpr NetParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NetParameter(const NetParameter& from);
NetParameter(NetParameter&& from) noexcept
: NetParameter() {
*this = ::std::move(from);
}
inline NetParameter& operator=(const NetParameter& from) {
CopyFrom(from);
return *this;
}
inline NetParameter& operator=(NetParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const NetParameter& default_instance() {
return *internal_default_instance();
}
static inline const NetParameter* internal_default_instance() {
return reinterpret_cast<const NetParameter*>(
&_NetParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
17;
friend void swap(NetParameter& a, NetParameter& b) {
a.Swap(&b);
}
inline void Swap(NetParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(NetParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NetParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NetParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const NetParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const NetParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(NetParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.NetParameter";
}
protected:
explicit NetParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kLayersFieldNumber = 2,
kInputFieldNumber = 3,
kInputDimFieldNumber = 4,
kInputShapeFieldNumber = 8,
kLayerFieldNumber = 100,
kNameFieldNumber = 1,
kStateFieldNumber = 6,
kForceBackwardFieldNumber = 5,
kDebugInfoFieldNumber = 7,
};
// repeated .caffe.V1LayerParameter layers = 2;
int layers_size() const;
private:
int _internal_layers_size() const;
public:
void clear_layers();
::caffe::V1LayerParameter* mutable_layers(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::V1LayerParameter >*
mutable_layers();
private:
const ::caffe::V1LayerParameter& _internal_layers(int index) const;
::caffe::V1LayerParameter* _internal_add_layers();
public:
const ::caffe::V1LayerParameter& layers(int index) const;
::caffe::V1LayerParameter* add_layers();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::V1LayerParameter >&
layers() const;
// repeated string input = 3;
int input_size() const;
private:
int _internal_input_size() const;
public:
void clear_input();
const std::string& input(int index) const;
std::string* mutable_input(int index);
void set_input(int index, const std::string& value);
void set_input(int index, std::string&& value);
void set_input(int index, const char* value);
void set_input(int index, const char* value, size_t size);
std::string* add_input();
void add_input(const std::string& value);
void add_input(std::string&& value);
void add_input(const char* value);
void add_input(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
private:
const std::string& _internal_input(int index) const;
std::string* _internal_add_input();
public:
// repeated int32 input_dim = 4;
int input_dim_size() const;
private:
int _internal_input_dim_size() const;
public:
void clear_input_dim();
private:
int32_t _internal_input_dim(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
_internal_input_dim() const;
void _internal_add_input_dim(int32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
_internal_mutable_input_dim();
public:
int32_t input_dim(int index) const;
void set_input_dim(int index, int32_t value);
void add_input_dim(int32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
input_dim() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
mutable_input_dim();
// repeated .caffe.BlobShape input_shape = 8;
int input_shape_size() const;
private:
int _internal_input_shape_size() const;
public:
void clear_input_shape();
::caffe::BlobShape* mutable_input_shape(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >*
mutable_input_shape();
private:
const ::caffe::BlobShape& _internal_input_shape(int index) const;
::caffe::BlobShape* _internal_add_input_shape();
public:
const ::caffe::BlobShape& input_shape(int index) const;
::caffe::BlobShape* add_input_shape();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >&
input_shape() const;
// repeated .caffe.LayerParameter layer = 100;
int layer_size() const;
private:
int _internal_layer_size() const;
public:
void clear_layer();
::caffe::LayerParameter* mutable_layer(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LayerParameter >*
mutable_layer();
private:
const ::caffe::LayerParameter& _internal_layer(int index) const;
::caffe::LayerParameter* _internal_add_layer();
public:
const ::caffe::LayerParameter& layer(int index) const;
::caffe::LayerParameter* add_layer();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LayerParameter >&
layer() const;
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional .caffe.NetState state = 6;
bool has_state() const;
private:
bool _internal_has_state() const;
public:
void clear_state();
const ::caffe::NetState& state() const;
PROTOBUF_NODISCARD ::caffe::NetState* release_state();
::caffe::NetState* mutable_state();
void set_allocated_state(::caffe::NetState* state);
private:
const ::caffe::NetState& _internal_state() const;
::caffe::NetState* _internal_mutable_state();
public:
void unsafe_arena_set_allocated_state(
::caffe::NetState* state);
::caffe::NetState* unsafe_arena_release_state();
// optional bool force_backward = 5 [default = false];
bool has_force_backward() const;
private:
bool _internal_has_force_backward() const;
public:
void clear_force_backward();
bool force_backward() const;
void set_force_backward(bool value);
private:
bool _internal_force_backward() const;
void _internal_set_force_backward(bool value);
public:
// optional bool debug_info = 7 [default = false];
bool has_debug_info() const;
private:
bool _internal_has_debug_info() const;
public:
void clear_debug_info();
bool debug_info() const;
void set_debug_info(bool value);
private:
bool _internal_debug_info() const;
void _internal_set_debug_info(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.NetParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::V1LayerParameter > layers_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > input_dim_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape > input_shape_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LayerParameter > layer_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::caffe::NetState* state_;
bool force_backward_;
bool debug_info_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class SolverParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.SolverParameter) */ {
public:
inline SolverParameter() : SolverParameter(nullptr) {}
~SolverParameter() override;
explicit constexpr SolverParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SolverParameter(const SolverParameter& from);
SolverParameter(SolverParameter&& from) noexcept
: SolverParameter() {
*this = ::std::move(from);
}
inline SolverParameter& operator=(const SolverParameter& from) {
CopyFrom(from);
return *this;
}
inline SolverParameter& operator=(SolverParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SolverParameter& default_instance() {
return *internal_default_instance();
}
static inline const SolverParameter* internal_default_instance() {
return reinterpret_cast<const SolverParameter*>(
&_SolverParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
18;
friend void swap(SolverParameter& a, SolverParameter& b) {
a.Swap(&b);
}
inline void Swap(SolverParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SolverParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SolverParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SolverParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SolverParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const SolverParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SolverParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.SolverParameter";
}
protected:
explicit SolverParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef SolverParameter_SnapshotFormat SnapshotFormat;
static constexpr SnapshotFormat HDF5 =
SolverParameter_SnapshotFormat_HDF5;
static constexpr SnapshotFormat BINARYPROTO =
SolverParameter_SnapshotFormat_BINARYPROTO;
static inline bool SnapshotFormat_IsValid(int value) {
return SolverParameter_SnapshotFormat_IsValid(value);
}
static constexpr SnapshotFormat SnapshotFormat_MIN =
SolverParameter_SnapshotFormat_SnapshotFormat_MIN;
static constexpr SnapshotFormat SnapshotFormat_MAX =
SolverParameter_SnapshotFormat_SnapshotFormat_MAX;
static constexpr int SnapshotFormat_ARRAYSIZE =
SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
SnapshotFormat_descriptor() {
return SolverParameter_SnapshotFormat_descriptor();
}
template<typename T>
static inline const std::string& SnapshotFormat_Name(T enum_t_value) {
static_assert(::std::is_same<T, SnapshotFormat>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SnapshotFormat_Name.");
return SolverParameter_SnapshotFormat_Name(enum_t_value);
}
static inline bool SnapshotFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
SnapshotFormat* value) {
return SolverParameter_SnapshotFormat_Parse(name, value);
}
typedef SolverParameter_SolverMode SolverMode;
static constexpr SolverMode CPU =
SolverParameter_SolverMode_CPU;
static constexpr SolverMode GPU =
SolverParameter_SolverMode_GPU;
static inline bool SolverMode_IsValid(int value) {
return SolverParameter_SolverMode_IsValid(value);
}
static constexpr SolverMode SolverMode_MIN =
SolverParameter_SolverMode_SolverMode_MIN;
static constexpr SolverMode SolverMode_MAX =
SolverParameter_SolverMode_SolverMode_MAX;
static constexpr int SolverMode_ARRAYSIZE =
SolverParameter_SolverMode_SolverMode_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
SolverMode_descriptor() {
return SolverParameter_SolverMode_descriptor();
}
template<typename T>
static inline const std::string& SolverMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, SolverMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SolverMode_Name.");
return SolverParameter_SolverMode_Name(enum_t_value);
}
static inline bool SolverMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
SolverMode* value) {
return SolverParameter_SolverMode_Parse(name, value);
}
typedef SolverParameter_SolverType SolverType;
static constexpr SolverType SGD =
SolverParameter_SolverType_SGD;
static constexpr SolverType NESTEROV =
SolverParameter_SolverType_NESTEROV;
static constexpr SolverType ADAGRAD =
SolverParameter_SolverType_ADAGRAD;
static constexpr SolverType RMSPROP =
SolverParameter_SolverType_RMSPROP;
static constexpr SolverType ADADELTA =
SolverParameter_SolverType_ADADELTA;
static constexpr SolverType ADAM =
SolverParameter_SolverType_ADAM;
static inline bool SolverType_IsValid(int value) {
return SolverParameter_SolverType_IsValid(value);
}
static constexpr SolverType SolverType_MIN =
SolverParameter_SolverType_SolverType_MIN;
static constexpr SolverType SolverType_MAX =
SolverParameter_SolverType_SolverType_MAX;
static constexpr int SolverType_ARRAYSIZE =
SolverParameter_SolverType_SolverType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
SolverType_descriptor() {
return SolverParameter_SolverType_descriptor();
}
template<typename T>
static inline const std::string& SolverType_Name(T enum_t_value) {
static_assert(::std::is_same<T, SolverType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SolverType_Name.");
return SolverParameter_SolverType_Name(enum_t_value);
}
static inline bool SolverType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
SolverType* value) {
return SolverParameter_SolverType_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kTestNetFieldNumber = 2,
kTestIterFieldNumber = 3,
kTestNetParamFieldNumber = 22,
kTestStateFieldNumber = 27,
kStepvalueFieldNumber = 34,
kTrainNetFieldNumber = 1,
kLrPolicyFieldNumber = 8,
kSnapshotPrefixFieldNumber = 15,
kNetFieldNumber = 24,
kRegularizationTypeFieldNumber = 29,
kTypeFieldNumber = 40,
kEvalTypeFieldNumber = 41,
kApVersionFieldNumber = 42,
kTrainNetParamFieldNumber = 21,
kNetParamFieldNumber = 25,
kTrainStateFieldNumber = 26,
kTestIntervalFieldNumber = 4,
kBaseLrFieldNumber = 5,
kDisplayFieldNumber = 6,
kMaxIterFieldNumber = 7,
kGammaFieldNumber = 9,
kPowerFieldNumber = 10,
kMomentumFieldNumber = 11,
kWeightDecayFieldNumber = 12,
kStepsizeFieldNumber = 13,
kSnapshotFieldNumber = 14,
kDeviceIdFieldNumber = 18,
kShowPerClassResultFieldNumber = 44,
kTestComputeLossFieldNumber = 19,
kSnapshotDiffFieldNumber = 16,
kDebugInfoFieldNumber = 23,
kSolverTypeFieldNumber = 30,
kMomentum2FieldNumber = 39,
kRandomSeedFieldNumber = 20,
kSolverModeFieldNumber = 17,
kDeltaFieldNumber = 31,
kAverageLossFieldNumber = 33,
kClipGradientsFieldNumber = 35,
kTestInitializationFieldNumber = 32,
kSnapshotAfterTrainFieldNumber = 28,
kLayerWiseReduceFieldNumber = 45,
kIterSizeFieldNumber = 36,
kSnapshotFormatFieldNumber = 37,
kRmsDecayFieldNumber = 38,
};
// repeated string test_net = 2;
int test_net_size() const;
private:
int _internal_test_net_size() const;
public:
void clear_test_net();
const std::string& test_net(int index) const;
std::string* mutable_test_net(int index);
void set_test_net(int index, const std::string& value);
void set_test_net(int index, std::string&& value);
void set_test_net(int index, const char* value);
void set_test_net(int index, const char* value, size_t size);
std::string* add_test_net();
void add_test_net(const std::string& value);
void add_test_net(std::string&& value);
void add_test_net(const char* value);
void add_test_net(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& test_net() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_test_net();
private:
const std::string& _internal_test_net(int index) const;
std::string* _internal_add_test_net();
public:
// repeated int32 test_iter = 3;
int test_iter_size() const;
private:
int _internal_test_iter_size() const;
public:
void clear_test_iter();
private:
int32_t _internal_test_iter(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
_internal_test_iter() const;
void _internal_add_test_iter(int32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
_internal_mutable_test_iter();
public:
int32_t test_iter(int index) const;
void set_test_iter(int index, int32_t value);
void add_test_iter(int32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
test_iter() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
mutable_test_iter();
// repeated .caffe.NetParameter test_net_param = 22;
int test_net_param_size() const;
private:
int _internal_test_net_param_size() const;
public:
void clear_test_net_param();
::caffe::NetParameter* mutable_test_net_param(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetParameter >*
mutable_test_net_param();
private:
const ::caffe::NetParameter& _internal_test_net_param(int index) const;
::caffe::NetParameter* _internal_add_test_net_param();
public:
const ::caffe::NetParameter& test_net_param(int index) const;
::caffe::NetParameter* add_test_net_param();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetParameter >&
test_net_param() const;
// repeated .caffe.NetState test_state = 27;
int test_state_size() const;
private:
int _internal_test_state_size() const;
public:
void clear_test_state();
::caffe::NetState* mutable_test_state(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetState >*
mutable_test_state();
private:
const ::caffe::NetState& _internal_test_state(int index) const;
::caffe::NetState* _internal_add_test_state();
public:
const ::caffe::NetState& test_state(int index) const;
::caffe::NetState* add_test_state();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetState >&
test_state() const;
// repeated int32 stepvalue = 34;
int stepvalue_size() const;
private:
int _internal_stepvalue_size() const;
public:
void clear_stepvalue();
private:
int32_t _internal_stepvalue(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
_internal_stepvalue() const;
void _internal_add_stepvalue(int32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
_internal_mutable_stepvalue();
public:
int32_t stepvalue(int index) const;
void set_stepvalue(int index, int32_t value);
void add_stepvalue(int32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
stepvalue() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
mutable_stepvalue();
// optional string train_net = 1;
bool has_train_net() const;
private:
bool _internal_has_train_net() const;
public:
void clear_train_net();
const std::string& train_net() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_train_net(ArgT0&& arg0, ArgT... args);
std::string* mutable_train_net();
PROTOBUF_NODISCARD std::string* release_train_net();
void set_allocated_train_net(std::string* train_net);
private:
const std::string& _internal_train_net() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_train_net(const std::string& value);
std::string* _internal_mutable_train_net();
public:
// optional string lr_policy = 8;
bool has_lr_policy() const;
private:
bool _internal_has_lr_policy() const;
public:
void clear_lr_policy();
const std::string& lr_policy() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_lr_policy(ArgT0&& arg0, ArgT... args);
std::string* mutable_lr_policy();
PROTOBUF_NODISCARD std::string* release_lr_policy();
void set_allocated_lr_policy(std::string* lr_policy);
private:
const std::string& _internal_lr_policy() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_lr_policy(const std::string& value);
std::string* _internal_mutable_lr_policy();
public:
// optional string snapshot_prefix = 15;
bool has_snapshot_prefix() const;
private:
bool _internal_has_snapshot_prefix() const;
public:
void clear_snapshot_prefix();
const std::string& snapshot_prefix() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_snapshot_prefix(ArgT0&& arg0, ArgT... args);
std::string* mutable_snapshot_prefix();
PROTOBUF_NODISCARD std::string* release_snapshot_prefix();
void set_allocated_snapshot_prefix(std::string* snapshot_prefix);
private:
const std::string& _internal_snapshot_prefix() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshot_prefix(const std::string& value);
std::string* _internal_mutable_snapshot_prefix();
public:
// optional string net = 24;
bool has_net() const;
private:
bool _internal_has_net() const;
public:
void clear_net();
const std::string& net() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_net(ArgT0&& arg0, ArgT... args);
std::string* mutable_net();
PROTOBUF_NODISCARD std::string* release_net();
void set_allocated_net(std::string* net);
private:
const std::string& _internal_net() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_net(const std::string& value);
std::string* _internal_mutable_net();
public:
// optional string regularization_type = 29 [default = "L2"];
bool has_regularization_type() const;
private:
bool _internal_has_regularization_type() const;
public:
void clear_regularization_type();
const std::string& regularization_type() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_regularization_type(ArgT0&& arg0, ArgT... args);
std::string* mutable_regularization_type();
PROTOBUF_NODISCARD std::string* release_regularization_type();
void set_allocated_regularization_type(std::string* regularization_type);
private:
const std::string& _internal_regularization_type() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_regularization_type(const std::string& value);
std::string* _internal_mutable_regularization_type();
public:
// optional string type = 40 [default = "SGD"];
bool has_type() const;
private:
bool _internal_has_type() const;
public:
void clear_type();
const std::string& type() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_type(ArgT0&& arg0, ArgT... args);
std::string* mutable_type();
PROTOBUF_NODISCARD std::string* release_type();
void set_allocated_type(std::string* type);
private:
const std::string& _internal_type() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
std::string* _internal_mutable_type();
public:
// optional string eval_type = 41 [default = "classification"];
bool has_eval_type() const;
private:
bool _internal_has_eval_type() const;
public:
void clear_eval_type();
const std::string& eval_type() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_eval_type(ArgT0&& arg0, ArgT... args);
std::string* mutable_eval_type();
PROTOBUF_NODISCARD std::string* release_eval_type();
void set_allocated_eval_type(std::string* eval_type);
private:
const std::string& _internal_eval_type() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_eval_type(const std::string& value);
std::string* _internal_mutable_eval_type();
public:
// optional string ap_version = 42 [default = "Integral"];
bool has_ap_version() const;
private:
bool _internal_has_ap_version() const;
public:
void clear_ap_version();
const std::string& ap_version() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_ap_version(ArgT0&& arg0, ArgT... args);
std::string* mutable_ap_version();
PROTOBUF_NODISCARD std::string* release_ap_version();
void set_allocated_ap_version(std::string* ap_version);
private:
const std::string& _internal_ap_version() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_ap_version(const std::string& value);
std::string* _internal_mutable_ap_version();
public:
// optional .caffe.NetParameter train_net_param = 21;
bool has_train_net_param() const;
private:
bool _internal_has_train_net_param() const;
public:
void clear_train_net_param();
const ::caffe::NetParameter& train_net_param() const;
PROTOBUF_NODISCARD ::caffe::NetParameter* release_train_net_param();
::caffe::NetParameter* mutable_train_net_param();
void set_allocated_train_net_param(::caffe::NetParameter* train_net_param);
private:
const ::caffe::NetParameter& _internal_train_net_param() const;
::caffe::NetParameter* _internal_mutable_train_net_param();
public:
void unsafe_arena_set_allocated_train_net_param(
::caffe::NetParameter* train_net_param);
::caffe::NetParameter* unsafe_arena_release_train_net_param();
// optional .caffe.NetParameter net_param = 25;
bool has_net_param() const;
private:
bool _internal_has_net_param() const;
public:
void clear_net_param();
const ::caffe::NetParameter& net_param() const;
PROTOBUF_NODISCARD ::caffe::NetParameter* release_net_param();
::caffe::NetParameter* mutable_net_param();
void set_allocated_net_param(::caffe::NetParameter* net_param);
private:
const ::caffe::NetParameter& _internal_net_param() const;
::caffe::NetParameter* _internal_mutable_net_param();
public:
void unsafe_arena_set_allocated_net_param(
::caffe::NetParameter* net_param);
::caffe::NetParameter* unsafe_arena_release_net_param();
// optional .caffe.NetState train_state = 26;
bool has_train_state() const;
private:
bool _internal_has_train_state() const;
public:
void clear_train_state();
const ::caffe::NetState& train_state() const;
PROTOBUF_NODISCARD ::caffe::NetState* release_train_state();
::caffe::NetState* mutable_train_state();
void set_allocated_train_state(::caffe::NetState* train_state);
private:
const ::caffe::NetState& _internal_train_state() const;
::caffe::NetState* _internal_mutable_train_state();
public:
void unsafe_arena_set_allocated_train_state(
::caffe::NetState* train_state);
::caffe::NetState* unsafe_arena_release_train_state();
// optional int32 test_interval = 4 [default = 0];
bool has_test_interval() const;
private:
bool _internal_has_test_interval() const;
public:
void clear_test_interval();
int32_t test_interval() const;
void set_test_interval(int32_t value);
private:
int32_t _internal_test_interval() const;
void _internal_set_test_interval(int32_t value);
public:
// optional float base_lr = 5;
bool has_base_lr() const;
private:
bool _internal_has_base_lr() const;
public:
void clear_base_lr();
float base_lr() const;
void set_base_lr(float value);
private:
float _internal_base_lr() const;
void _internal_set_base_lr(float value);
public:
// optional int32 display = 6;
bool has_display() const;
private:
bool _internal_has_display() const;
public:
void clear_display();
int32_t display() const;
void set_display(int32_t value);
private:
int32_t _internal_display() const;
void _internal_set_display(int32_t value);
public:
// optional int32 max_iter = 7;
bool has_max_iter() const;
private:
bool _internal_has_max_iter() const;
public:
void clear_max_iter();
int32_t max_iter() const;
void set_max_iter(int32_t value);
private:
int32_t _internal_max_iter() const;
void _internal_set_max_iter(int32_t value);
public:
// optional float gamma = 9;
bool has_gamma() const;
private:
bool _internal_has_gamma() const;
public:
void clear_gamma();
float gamma() const;
void set_gamma(float value);
private:
float _internal_gamma() const;
void _internal_set_gamma(float value);
public:
// optional float power = 10;
bool has_power() const;
private:
bool _internal_has_power() const;
public:
void clear_power();
float power() const;
void set_power(float value);
private:
float _internal_power() const;
void _internal_set_power(float value);
public:
// optional float momentum = 11;
bool has_momentum() const;
private:
bool _internal_has_momentum() const;
public:
void clear_momentum();
float momentum() const;
void set_momentum(float value);
private:
float _internal_momentum() const;
void _internal_set_momentum(float value);
public:
// optional float weight_decay = 12;
bool has_weight_decay() const;
private:
bool _internal_has_weight_decay() const;
public:
void clear_weight_decay();
float weight_decay() const;
void set_weight_decay(float value);
private:
float _internal_weight_decay() const;
void _internal_set_weight_decay(float value);
public:
// optional int32 stepsize = 13;
bool has_stepsize() const;
private:
bool _internal_has_stepsize() const;
public:
void clear_stepsize();
int32_t stepsize() const;
void set_stepsize(int32_t value);
private:
int32_t _internal_stepsize() const;
void _internal_set_stepsize(int32_t value);
public:
// optional int32 snapshot = 14 [default = 0];
bool has_snapshot() const;
private:
bool _internal_has_snapshot() const;
public:
void clear_snapshot();
int32_t snapshot() const;
void set_snapshot(int32_t value);
private:
int32_t _internal_snapshot() const;
void _internal_set_snapshot(int32_t value);
public:
// optional int32 device_id = 18 [default = 0];
bool has_device_id() const;
private:
bool _internal_has_device_id() const;
public:
void clear_device_id();
int32_t device_id() const;
void set_device_id(int32_t value);
private:
int32_t _internal_device_id() const;
void _internal_set_device_id(int32_t value);
public:
// optional bool show_per_class_result = 44 [default = false];
bool has_show_per_class_result() const;
private:
bool _internal_has_show_per_class_result() const;
public:
void clear_show_per_class_result();
bool show_per_class_result() const;
void set_show_per_class_result(bool value);
private:
bool _internal_show_per_class_result() const;
void _internal_set_show_per_class_result(bool value);
public:
// optional bool test_compute_loss = 19 [default = false];
bool has_test_compute_loss() const;
private:
bool _internal_has_test_compute_loss() const;
public:
void clear_test_compute_loss();
bool test_compute_loss() const;
void set_test_compute_loss(bool value);
private:
bool _internal_test_compute_loss() const;
void _internal_set_test_compute_loss(bool value);
public:
// optional bool snapshot_diff = 16 [default = false];
bool has_snapshot_diff() const;
private:
bool _internal_has_snapshot_diff() const;
public:
void clear_snapshot_diff();
bool snapshot_diff() const;
void set_snapshot_diff(bool value);
private:
bool _internal_snapshot_diff() const;
void _internal_set_snapshot_diff(bool value);
public:
// optional bool debug_info = 23 [default = false];
bool has_debug_info() const;
private:
bool _internal_has_debug_info() const;
public:
void clear_debug_info();
bool debug_info() const;
void set_debug_info(bool value);
private:
bool _internal_debug_info() const;
void _internal_set_debug_info(bool value);
public:
// optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
bool has_solver_type() const;
private:
bool _internal_has_solver_type() const;
public:
void clear_solver_type();
::caffe::SolverParameter_SolverType solver_type() const;
void set_solver_type(::caffe::SolverParameter_SolverType value);
private:
::caffe::SolverParameter_SolverType _internal_solver_type() const;
void _internal_set_solver_type(::caffe::SolverParameter_SolverType value);
public:
// optional float momentum2 = 39 [default = 0.999];
bool has_momentum2() const;
private:
bool _internal_has_momentum2() const;
public:
void clear_momentum2();
float momentum2() const;
void set_momentum2(float value);
private:
float _internal_momentum2() const;
void _internal_set_momentum2(float value);
public:
// optional int64 random_seed = 20 [default = -1];
bool has_random_seed() const;
private:
bool _internal_has_random_seed() const;
public:
void clear_random_seed();
int64_t random_seed() const;
void set_random_seed(int64_t value);
private:
int64_t _internal_random_seed() const;
void _internal_set_random_seed(int64_t value);
public:
// optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
bool has_solver_mode() const;
private:
bool _internal_has_solver_mode() const;
public:
void clear_solver_mode();
::caffe::SolverParameter_SolverMode solver_mode() const;
void set_solver_mode(::caffe::SolverParameter_SolverMode value);
private:
::caffe::SolverParameter_SolverMode _internal_solver_mode() const;
void _internal_set_solver_mode(::caffe::SolverParameter_SolverMode value);
public:
// optional float delta = 31 [default = 1e-08];
bool has_delta() const;
private:
bool _internal_has_delta() const;
public:
void clear_delta();
float delta() const;
void set_delta(float value);
private:
float _internal_delta() const;
void _internal_set_delta(float value);
public:
// optional int32 average_loss = 33 [default = 1];
bool has_average_loss() const;
private:
bool _internal_has_average_loss() const;
public:
void clear_average_loss();
int32_t average_loss() const;
void set_average_loss(int32_t value);
private:
int32_t _internal_average_loss() const;
void _internal_set_average_loss(int32_t value);
public:
// optional float clip_gradients = 35 [default = -1];
bool has_clip_gradients() const;
private:
bool _internal_has_clip_gradients() const;
public:
void clear_clip_gradients();
float clip_gradients() const;
void set_clip_gradients(float value);
private:
float _internal_clip_gradients() const;
void _internal_set_clip_gradients(float value);
public:
// optional bool test_initialization = 32 [default = true];
bool has_test_initialization() const;
private:
bool _internal_has_test_initialization() const;
public:
void clear_test_initialization();
bool test_initialization() const;
void set_test_initialization(bool value);
private:
bool _internal_test_initialization() const;
void _internal_set_test_initialization(bool value);
public:
// optional bool snapshot_after_train = 28 [default = true];
bool has_snapshot_after_train() const;
private:
bool _internal_has_snapshot_after_train() const;
public:
void clear_snapshot_after_train();
bool snapshot_after_train() const;
void set_snapshot_after_train(bool value);
private:
bool _internal_snapshot_after_train() const;
void _internal_set_snapshot_after_train(bool value);
public:
// optional bool layer_wise_reduce = 45 [default = true];
bool has_layer_wise_reduce() const;
private:
bool _internal_has_layer_wise_reduce() const;
public:
void clear_layer_wise_reduce();
bool layer_wise_reduce() const;
void set_layer_wise_reduce(bool value);
private:
bool _internal_layer_wise_reduce() const;
void _internal_set_layer_wise_reduce(bool value);
public:
// optional int32 iter_size = 36 [default = 1];
bool has_iter_size() const;
private:
bool _internal_has_iter_size() const;
public:
void clear_iter_size();
int32_t iter_size() const;
void set_iter_size(int32_t value);
private:
int32_t _internal_iter_size() const;
void _internal_set_iter_size(int32_t value);
public:
// optional .caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
bool has_snapshot_format() const;
private:
bool _internal_has_snapshot_format() const;
public:
void clear_snapshot_format();
::caffe::SolverParameter_SnapshotFormat snapshot_format() const;
void set_snapshot_format(::caffe::SolverParameter_SnapshotFormat value);
private:
::caffe::SolverParameter_SnapshotFormat _internal_snapshot_format() const;
void _internal_set_snapshot_format(::caffe::SolverParameter_SnapshotFormat value);
public:
// optional float rms_decay = 38 [default = 0.99];
bool has_rms_decay() const;
private:
bool _internal_has_rms_decay() const;
public:
void clear_rms_decay();
float rms_decay() const;
void set_rms_decay(float value);
private:
float _internal_rms_decay() const;
void _internal_set_rms_decay(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.SolverParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> test_net_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > test_iter_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetParameter > test_net_param_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetState > test_state_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > stepvalue_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr train_net_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lr_policy_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshot_prefix_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr net_;
static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_regularization_type_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr regularization_type_;
static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_type_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_eval_type_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eval_type_;
static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_ap_version_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ap_version_;
::caffe::NetParameter* train_net_param_;
::caffe::NetParameter* net_param_;
::caffe::NetState* train_state_;
int32_t test_interval_;
float base_lr_;
int32_t display_;
int32_t max_iter_;
float gamma_;
float power_;
float momentum_;
float weight_decay_;
int32_t stepsize_;
int32_t snapshot_;
int32_t device_id_;
bool show_per_class_result_;
bool test_compute_loss_;
bool snapshot_diff_;
bool debug_info_;
int solver_type_;
float momentum2_;
int64_t random_seed_;
int solver_mode_;
float delta_;
int32_t average_loss_;
float clip_gradients_;
bool test_initialization_;
bool snapshot_after_train_;
bool layer_wise_reduce_;
int32_t iter_size_;
int snapshot_format_;
float rms_decay_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class SolverState final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.SolverState) */ {
public:
inline SolverState() : SolverState(nullptr) {}
~SolverState() override;
explicit constexpr SolverState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SolverState(const SolverState& from);
SolverState(SolverState&& from) noexcept
: SolverState() {
*this = ::std::move(from);
}
inline SolverState& operator=(const SolverState& from) {
CopyFrom(from);
return *this;
}
inline SolverState& operator=(SolverState&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SolverState& default_instance() {
return *internal_default_instance();
}
static inline const SolverState* internal_default_instance() {
return reinterpret_cast<const SolverState*>(
&_SolverState_default_instance_);
}
static constexpr int kIndexInFileMessages =
19;
friend void swap(SolverState& a, SolverState& b) {
a.Swap(&b);
}
inline void Swap(SolverState* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SolverState* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SolverState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SolverState>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SolverState& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const SolverState& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SolverState* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.SolverState";
}
protected:
explicit SolverState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kHistoryFieldNumber = 3,
kLearnedNetFieldNumber = 2,
kIterFieldNumber = 1,
kCurrentStepFieldNumber = 4,
};
// repeated .caffe.BlobProto history = 3;
int history_size() const;
private:
int _internal_history_size() const;
public:
void clear_history();
::caffe::BlobProto* mutable_history(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
mutable_history();
private:
const ::caffe::BlobProto& _internal_history(int index) const;
::caffe::BlobProto* _internal_add_history();
public:
const ::caffe::BlobProto& history(int index) const;
::caffe::BlobProto* add_history();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
history() const;
// optional string learned_net = 2;
bool has_learned_net() const;
private:
bool _internal_has_learned_net() const;
public:
void clear_learned_net();
const std::string& learned_net() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_learned_net(ArgT0&& arg0, ArgT... args);
std::string* mutable_learned_net();
PROTOBUF_NODISCARD std::string* release_learned_net();
void set_allocated_learned_net(std::string* learned_net);
private:
const std::string& _internal_learned_net() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_learned_net(const std::string& value);
std::string* _internal_mutable_learned_net();
public:
// optional int32 iter = 1;
bool has_iter() const;
private:
bool _internal_has_iter() const;
public:
void clear_iter();
int32_t iter() const;
void set_iter(int32_t value);
private:
int32_t _internal_iter() const;
void _internal_set_iter(int32_t value);
public:
// optional int32 current_step = 4 [default = 0];
bool has_current_step() const;
private:
bool _internal_has_current_step() const;
public:
void clear_current_step();
int32_t current_step() const;
void set_current_step(int32_t value);
private:
int32_t _internal_current_step() const;
void _internal_set_current_step(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.SolverState)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto > history_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr learned_net_;
int32_t iter_;
int32_t current_step_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class NetState final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.NetState) */ {
public:
inline NetState() : NetState(nullptr) {}
~NetState() override;
explicit constexpr NetState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NetState(const NetState& from);
NetState(NetState&& from) noexcept
: NetState() {
*this = ::std::move(from);
}
inline NetState& operator=(const NetState& from) {
CopyFrom(from);
return *this;
}
inline NetState& operator=(NetState&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const NetState& default_instance() {
return *internal_default_instance();
}
static inline const NetState* internal_default_instance() {
return reinterpret_cast<const NetState*>(
&_NetState_default_instance_);
}
static constexpr int kIndexInFileMessages =
20;
friend void swap(NetState& a, NetState& b) {
a.Swap(&b);
}
inline void Swap(NetState* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(NetState* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NetState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NetState>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const NetState& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const NetState& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(NetState* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.NetState";
}
protected:
explicit NetState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kStageFieldNumber = 3,
kLevelFieldNumber = 2,
kPhaseFieldNumber = 1,
};
// repeated string stage = 3;
int stage_size() const;
private:
int _internal_stage_size() const;
public:
void clear_stage();
const std::string& stage(int index) const;
std::string* mutable_stage(int index);
void set_stage(int index, const std::string& value);
void set_stage(int index, std::string&& value);
void set_stage(int index, const char* value);
void set_stage(int index, const char* value, size_t size);
std::string* add_stage();
void add_stage(const std::string& value);
void add_stage(std::string&& value);
void add_stage(const char* value);
void add_stage(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& stage() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_stage();
private:
const std::string& _internal_stage(int index) const;
std::string* _internal_add_stage();
public:
// optional int32 level = 2 [default = 0];
bool has_level() const;
private:
bool _internal_has_level() const;
public:
void clear_level();
int32_t level() const;
void set_level(int32_t value);
private:
int32_t _internal_level() const;
void _internal_set_level(int32_t value);
public:
// optional .caffe.Phase phase = 1 [default = TEST];
bool has_phase() const;
private:
bool _internal_has_phase() const;
public:
void clear_phase();
::caffe::Phase phase() const;
void set_phase(::caffe::Phase value);
private:
::caffe::Phase _internal_phase() const;
void _internal_set_phase(::caffe::Phase value);
public:
// @@protoc_insertion_point(class_scope:caffe.NetState)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> stage_;
int32_t level_;
int phase_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class NetStateRule final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.NetStateRule) */ {
public:
inline NetStateRule() : NetStateRule(nullptr) {}
~NetStateRule() override;
explicit constexpr NetStateRule(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NetStateRule(const NetStateRule& from);
NetStateRule(NetStateRule&& from) noexcept
: NetStateRule() {
*this = ::std::move(from);
}
inline NetStateRule& operator=(const NetStateRule& from) {
CopyFrom(from);
return *this;
}
inline NetStateRule& operator=(NetStateRule&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const NetStateRule& default_instance() {
return *internal_default_instance();
}
static inline const NetStateRule* internal_default_instance() {
return reinterpret_cast<const NetStateRule*>(
&_NetStateRule_default_instance_);
}
static constexpr int kIndexInFileMessages =
21;
friend void swap(NetStateRule& a, NetStateRule& b) {
a.Swap(&b);
}
inline void Swap(NetStateRule* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(NetStateRule* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NetStateRule* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NetStateRule>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const NetStateRule& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const NetStateRule& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(NetStateRule* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.NetStateRule";
}
protected:
explicit NetStateRule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kStageFieldNumber = 4,
kNotStageFieldNumber = 5,
kPhaseFieldNumber = 1,
kMinLevelFieldNumber = 2,
kMaxLevelFieldNumber = 3,
};
// repeated string stage = 4;
int stage_size() const;
private:
int _internal_stage_size() const;
public:
void clear_stage();
const std::string& stage(int index) const;
std::string* mutable_stage(int index);
void set_stage(int index, const std::string& value);
void set_stage(int index, std::string&& value);
void set_stage(int index, const char* value);
void set_stage(int index, const char* value, size_t size);
std::string* add_stage();
void add_stage(const std::string& value);
void add_stage(std::string&& value);
void add_stage(const char* value);
void add_stage(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& stage() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_stage();
private:
const std::string& _internal_stage(int index) const;
std::string* _internal_add_stage();
public:
// repeated string not_stage = 5;
int not_stage_size() const;
private:
int _internal_not_stage_size() const;
public:
void clear_not_stage();
const std::string& not_stage(int index) const;
std::string* mutable_not_stage(int index);
void set_not_stage(int index, const std::string& value);
void set_not_stage(int index, std::string&& value);
void set_not_stage(int index, const char* value);
void set_not_stage(int index, const char* value, size_t size);
std::string* add_not_stage();
void add_not_stage(const std::string& value);
void add_not_stage(std::string&& value);
void add_not_stage(const char* value);
void add_not_stage(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& not_stage() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_not_stage();
private:
const std::string& _internal_not_stage(int index) const;
std::string* _internal_add_not_stage();
public:
// optional .caffe.Phase phase = 1;
bool has_phase() const;
private:
bool _internal_has_phase() const;
public:
void clear_phase();
::caffe::Phase phase() const;
void set_phase(::caffe::Phase value);
private:
::caffe::Phase _internal_phase() const;
void _internal_set_phase(::caffe::Phase value);
public:
// optional int32 min_level = 2;
bool has_min_level() const;
private:
bool _internal_has_min_level() const;
public:
void clear_min_level();
int32_t min_level() const;
void set_min_level(int32_t value);
private:
int32_t _internal_min_level() const;
void _internal_set_min_level(int32_t value);
public:
// optional int32 max_level = 3;
bool has_max_level() const;
private:
bool _internal_has_max_level() const;
public:
void clear_max_level();
int32_t max_level() const;
void set_max_level(int32_t value);
private:
int32_t _internal_max_level() const;
void _internal_set_max_level(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.NetStateRule)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> stage_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> not_stage_;
int phase_;
int32_t min_level_;
int32_t max_level_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ParamSpec final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ParamSpec) */ {
public:
inline ParamSpec() : ParamSpec(nullptr) {}
~ParamSpec() override;
explicit constexpr ParamSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ParamSpec(const ParamSpec& from);
ParamSpec(ParamSpec&& from) noexcept
: ParamSpec() {
*this = ::std::move(from);
}
inline ParamSpec& operator=(const ParamSpec& from) {
CopyFrom(from);
return *this;
}
inline ParamSpec& operator=(ParamSpec&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ParamSpec& default_instance() {
return *internal_default_instance();
}
static inline const ParamSpec* internal_default_instance() {
return reinterpret_cast<const ParamSpec*>(
&_ParamSpec_default_instance_);
}
static constexpr int kIndexInFileMessages =
22;
friend void swap(ParamSpec& a, ParamSpec& b) {
a.Swap(&b);
}
inline void Swap(ParamSpec* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ParamSpec* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ParamSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ParamSpec>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ParamSpec& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ParamSpec& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ParamSpec* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ParamSpec";
}
protected:
explicit ParamSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef ParamSpec_DimCheckMode DimCheckMode;
static constexpr DimCheckMode STRICT =
ParamSpec_DimCheckMode_STRICT;
static constexpr DimCheckMode PERMISSIVE =
ParamSpec_DimCheckMode_PERMISSIVE;
static inline bool DimCheckMode_IsValid(int value) {
return ParamSpec_DimCheckMode_IsValid(value);
}
static constexpr DimCheckMode DimCheckMode_MIN =
ParamSpec_DimCheckMode_DimCheckMode_MIN;
static constexpr DimCheckMode DimCheckMode_MAX =
ParamSpec_DimCheckMode_DimCheckMode_MAX;
static constexpr int DimCheckMode_ARRAYSIZE =
ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
DimCheckMode_descriptor() {
return ParamSpec_DimCheckMode_descriptor();
}
template<typename T>
static inline const std::string& DimCheckMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, DimCheckMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DimCheckMode_Name.");
return ParamSpec_DimCheckMode_Name(enum_t_value);
}
static inline bool DimCheckMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
DimCheckMode* value) {
return ParamSpec_DimCheckMode_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kNameFieldNumber = 1,
kShareModeFieldNumber = 2,
kLrMultFieldNumber = 3,
kDecayMultFieldNumber = 4,
};
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional .caffe.ParamSpec.DimCheckMode share_mode = 2;
bool has_share_mode() const;
private:
bool _internal_has_share_mode() const;
public:
void clear_share_mode();
::caffe::ParamSpec_DimCheckMode share_mode() const;
void set_share_mode(::caffe::ParamSpec_DimCheckMode value);
private:
::caffe::ParamSpec_DimCheckMode _internal_share_mode() const;
void _internal_set_share_mode(::caffe::ParamSpec_DimCheckMode value);
public:
// optional float lr_mult = 3 [default = 1];
bool has_lr_mult() const;
private:
bool _internal_has_lr_mult() const;
public:
void clear_lr_mult();
float lr_mult() const;
void set_lr_mult(float value);
private:
float _internal_lr_mult() const;
void _internal_set_lr_mult(float value);
public:
// optional float decay_mult = 4 [default = 1];
bool has_decay_mult() const;
private:
bool _internal_has_decay_mult() const;
public:
void clear_decay_mult();
float decay_mult() const;
void set_decay_mult(float value);
private:
float _internal_decay_mult() const;
void _internal_set_decay_mult(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ParamSpec)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
int share_mode_;
float lr_mult_;
float decay_mult_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class LayerParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.LayerParameter) */ {
public:
inline LayerParameter() : LayerParameter(nullptr) {}
~LayerParameter() override;
explicit constexpr LayerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
LayerParameter(const LayerParameter& from);
LayerParameter(LayerParameter&& from) noexcept
: LayerParameter() {
*this = ::std::move(from);
}
inline LayerParameter& operator=(const LayerParameter& from) {
CopyFrom(from);
return *this;
}
inline LayerParameter& operator=(LayerParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const LayerParameter& default_instance() {
return *internal_default_instance();
}
static inline const LayerParameter* internal_default_instance() {
return reinterpret_cast<const LayerParameter*>(
&_LayerParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
23;
friend void swap(LayerParameter& a, LayerParameter& b) {
a.Swap(&b);
}
inline void Swap(LayerParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(LayerParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
LayerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<LayerParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const LayerParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const LayerParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(LayerParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.LayerParameter";
}
protected:
explicit LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBottomFieldNumber = 3,
kTopFieldNumber = 4,
kLossWeightFieldNumber = 5,
kParamFieldNumber = 6,
kBlobsFieldNumber = 7,
kIncludeFieldNumber = 8,
kExcludeFieldNumber = 9,
kPropagateDownFieldNumber = 11,
kNameFieldNumber = 1,
kTypeFieldNumber = 2,
kTransformParamFieldNumber = 100,
kLossParamFieldNumber = 101,
kAccuracyParamFieldNumber = 102,
kArgmaxParamFieldNumber = 103,
kConcatParamFieldNumber = 104,
kContrastiveLossParamFieldNumber = 105,
kConvolutionParamFieldNumber = 106,
kDataParamFieldNumber = 107,
kDropoutParamFieldNumber = 108,
kDummyDataParamFieldNumber = 109,
kEltwiseParamFieldNumber = 110,
kExpParamFieldNumber = 111,
kHdf5DataParamFieldNumber = 112,
kHdf5OutputParamFieldNumber = 113,
kHingeLossParamFieldNumber = 114,
kImageDataParamFieldNumber = 115,
kInfogainLossParamFieldNumber = 116,
kInnerProductParamFieldNumber = 117,
kLrnParamFieldNumber = 118,
kMemoryDataParamFieldNumber = 119,
kMvnParamFieldNumber = 120,
kPoolingParamFieldNumber = 121,
kPowerParamFieldNumber = 122,
kReluParamFieldNumber = 123,
kSigmoidParamFieldNumber = 124,
kSoftmaxParamFieldNumber = 125,
kSliceParamFieldNumber = 126,
kTanhParamFieldNumber = 127,
kThresholdParamFieldNumber = 128,
kWindowDataParamFieldNumber = 129,
kPythonParamFieldNumber = 130,
kPreluParamFieldNumber = 131,
kSppParamFieldNumber = 132,
kReshapeParamFieldNumber = 133,
kLogParamFieldNumber = 134,
kFlattenParamFieldNumber = 135,
kReductionParamFieldNumber = 136,
kEmbedParamFieldNumber = 137,
kTileParamFieldNumber = 138,
kBatchNormParamFieldNumber = 139,
kEluParamFieldNumber = 140,
kBiasParamFieldNumber = 141,
kScaleParamFieldNumber = 142,
kInputParamFieldNumber = 143,
kCropParamFieldNumber = 144,
kParameterParamFieldNumber = 145,
kRecurrentParamFieldNumber = 146,
kConvolution3DParamFieldNumber = 147,
kPooling3DParamFieldNumber = 148,
kAnnotatedDataParamFieldNumber = 200,
kMultiboxLossParamFieldNumber = 201,
kPermuteParamFieldNumber = 202,
kPriorBoxParamFieldNumber = 203,
kDetectionOutputParamFieldNumber = 204,
kDetectionEvaluateParamFieldNumber = 205,
kNormParamFieldNumber = 206,
kIm2SeqParamFieldNumber = 207,
kSeq2OutParamFieldNumber = 208,
kImgSizeParamFieldNumber = 209,
kLstmParamFieldNumber = 210,
kCenterLossParamFieldNumber = 211,
kShuffleChannelParamFieldNumber = 212,
kRoiPoolingParamFieldNumber = 2201,
kClipParamFieldNumber = 2202,
kUpsampleParamFieldNumber = 2203,
kInterpParamFieldNumber = 2210,
kPhaseFieldNumber = 10,
};
// repeated string bottom = 3;
int bottom_size() const;
private:
int _internal_bottom_size() const;
public:
void clear_bottom();
const std::string& bottom(int index) const;
std::string* mutable_bottom(int index);
void set_bottom(int index, const std::string& value);
void set_bottom(int index, std::string&& value);
void set_bottom(int index, const char* value);
void set_bottom(int index, const char* value, size_t size);
std::string* add_bottom();
void add_bottom(const std::string& value);
void add_bottom(std::string&& value);
void add_bottom(const char* value);
void add_bottom(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& bottom() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_bottom();
private:
const std::string& _internal_bottom(int index) const;
std::string* _internal_add_bottom();
public:
// repeated string top = 4;
int top_size() const;
private:
int _internal_top_size() const;
public:
void clear_top();
const std::string& top(int index) const;
std::string* mutable_top(int index);
void set_top(int index, const std::string& value);
void set_top(int index, std::string&& value);
void set_top(int index, const char* value);
void set_top(int index, const char* value, size_t size);
std::string* add_top();
void add_top(const std::string& value);
void add_top(std::string&& value);
void add_top(const char* value);
void add_top(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& top() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_top();
private:
const std::string& _internal_top(int index) const;
std::string* _internal_add_top();
public:
// repeated float loss_weight = 5;
int loss_weight_size() const;
private:
int _internal_loss_weight_size() const;
public:
void clear_loss_weight();
private:
float _internal_loss_weight(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_loss_weight() const;
void _internal_add_loss_weight(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_loss_weight();
public:
float loss_weight(int index) const;
void set_loss_weight(int index, float value);
void add_loss_weight(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
loss_weight() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_loss_weight();
// repeated .caffe.ParamSpec param = 6;
int param_size() const;
private:
int _internal_param_size() const;
public:
void clear_param();
::caffe::ParamSpec* mutable_param(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::ParamSpec >*
mutable_param();
private:
const ::caffe::ParamSpec& _internal_param(int index) const;
::caffe::ParamSpec* _internal_add_param();
public:
const ::caffe::ParamSpec& param(int index) const;
::caffe::ParamSpec* add_param();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::ParamSpec >&
param() const;
// repeated .caffe.BlobProto blobs = 7;
int blobs_size() const;
private:
int _internal_blobs_size() const;
public:
void clear_blobs();
::caffe::BlobProto* mutable_blobs(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
mutable_blobs();
private:
const ::caffe::BlobProto& _internal_blobs(int index) const;
::caffe::BlobProto* _internal_add_blobs();
public:
const ::caffe::BlobProto& blobs(int index) const;
::caffe::BlobProto* add_blobs();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
blobs() const;
// repeated .caffe.NetStateRule include = 8;
int include_size() const;
private:
int _internal_include_size() const;
public:
void clear_include();
::caffe::NetStateRule* mutable_include(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >*
mutable_include();
private:
const ::caffe::NetStateRule& _internal_include(int index) const;
::caffe::NetStateRule* _internal_add_include();
public:
const ::caffe::NetStateRule& include(int index) const;
::caffe::NetStateRule* add_include();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >&
include() const;
// repeated .caffe.NetStateRule exclude = 9;
int exclude_size() const;
private:
int _internal_exclude_size() const;
public:
void clear_exclude();
::caffe::NetStateRule* mutable_exclude(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >*
mutable_exclude();
private:
const ::caffe::NetStateRule& _internal_exclude(int index) const;
::caffe::NetStateRule* _internal_add_exclude();
public:
const ::caffe::NetStateRule& exclude(int index) const;
::caffe::NetStateRule* add_exclude();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >&
exclude() const;
// repeated bool propagate_down = 11;
int propagate_down_size() const;
private:
int _internal_propagate_down_size() const;
public:
void clear_propagate_down();
private:
bool _internal_propagate_down(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
_internal_propagate_down() const;
void _internal_add_propagate_down(bool value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
_internal_mutable_propagate_down();
public:
bool propagate_down(int index) const;
void set_propagate_down(int index, bool value);
void add_propagate_down(bool value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
propagate_down() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
mutable_propagate_down();
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string type = 2;
bool has_type() const;
private:
bool _internal_has_type() const;
public:
void clear_type();
const std::string& type() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_type(ArgT0&& arg0, ArgT... args);
std::string* mutable_type();
PROTOBUF_NODISCARD std::string* release_type();
void set_allocated_type(std::string* type);
private:
const std::string& _internal_type() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
std::string* _internal_mutable_type();
public:
// optional .caffe.TransformationParameter transform_param = 100;
bool has_transform_param() const;
private:
bool _internal_has_transform_param() const;
public:
void clear_transform_param();
const ::caffe::TransformationParameter& transform_param() const;
PROTOBUF_NODISCARD ::caffe::TransformationParameter* release_transform_param();
::caffe::TransformationParameter* mutable_transform_param();
void set_allocated_transform_param(::caffe::TransformationParameter* transform_param);
private:
const ::caffe::TransformationParameter& _internal_transform_param() const;
::caffe::TransformationParameter* _internal_mutable_transform_param();
public:
void unsafe_arena_set_allocated_transform_param(
::caffe::TransformationParameter* transform_param);
::caffe::TransformationParameter* unsafe_arena_release_transform_param();
// optional .caffe.LossParameter loss_param = 101;
bool has_loss_param() const;
private:
bool _internal_has_loss_param() const;
public:
void clear_loss_param();
const ::caffe::LossParameter& loss_param() const;
PROTOBUF_NODISCARD ::caffe::LossParameter* release_loss_param();
::caffe::LossParameter* mutable_loss_param();
void set_allocated_loss_param(::caffe::LossParameter* loss_param);
private:
const ::caffe::LossParameter& _internal_loss_param() const;
::caffe::LossParameter* _internal_mutable_loss_param();
public:
void unsafe_arena_set_allocated_loss_param(
::caffe::LossParameter* loss_param);
::caffe::LossParameter* unsafe_arena_release_loss_param();
// optional .caffe.AccuracyParameter accuracy_param = 102;
bool has_accuracy_param() const;
private:
bool _internal_has_accuracy_param() const;
public:
void clear_accuracy_param();
const ::caffe::AccuracyParameter& accuracy_param() const;
PROTOBUF_NODISCARD ::caffe::AccuracyParameter* release_accuracy_param();
::caffe::AccuracyParameter* mutable_accuracy_param();
void set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param);
private:
const ::caffe::AccuracyParameter& _internal_accuracy_param() const;
::caffe::AccuracyParameter* _internal_mutable_accuracy_param();
public:
void unsafe_arena_set_allocated_accuracy_param(
::caffe::AccuracyParameter* accuracy_param);
::caffe::AccuracyParameter* unsafe_arena_release_accuracy_param();
// optional .caffe.ArgMaxParameter argmax_param = 103;
bool has_argmax_param() const;
private:
bool _internal_has_argmax_param() const;
public:
void clear_argmax_param();
const ::caffe::ArgMaxParameter& argmax_param() const;
PROTOBUF_NODISCARD ::caffe::ArgMaxParameter* release_argmax_param();
::caffe::ArgMaxParameter* mutable_argmax_param();
void set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param);
private:
const ::caffe::ArgMaxParameter& _internal_argmax_param() const;
::caffe::ArgMaxParameter* _internal_mutable_argmax_param();
public:
void unsafe_arena_set_allocated_argmax_param(
::caffe::ArgMaxParameter* argmax_param);
::caffe::ArgMaxParameter* unsafe_arena_release_argmax_param();
// optional .caffe.ConcatParameter concat_param = 104;
bool has_concat_param() const;
private:
bool _internal_has_concat_param() const;
public:
void clear_concat_param();
const ::caffe::ConcatParameter& concat_param() const;
PROTOBUF_NODISCARD ::caffe::ConcatParameter* release_concat_param();
::caffe::ConcatParameter* mutable_concat_param();
void set_allocated_concat_param(::caffe::ConcatParameter* concat_param);
private:
const ::caffe::ConcatParameter& _internal_concat_param() const;
::caffe::ConcatParameter* _internal_mutable_concat_param();
public:
void unsafe_arena_set_allocated_concat_param(
::caffe::ConcatParameter* concat_param);
::caffe::ConcatParameter* unsafe_arena_release_concat_param();
// optional .caffe.ContrastiveLossParameter contrastive_loss_param = 105;
bool has_contrastive_loss_param() const;
private:
bool _internal_has_contrastive_loss_param() const;
public:
void clear_contrastive_loss_param();
const ::caffe::ContrastiveLossParameter& contrastive_loss_param() const;
PROTOBUF_NODISCARD ::caffe::ContrastiveLossParameter* release_contrastive_loss_param();
::caffe::ContrastiveLossParameter* mutable_contrastive_loss_param();
void set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param);
private:
const ::caffe::ContrastiveLossParameter& _internal_contrastive_loss_param() const;
::caffe::ContrastiveLossParameter* _internal_mutable_contrastive_loss_param();
public:
void unsafe_arena_set_allocated_contrastive_loss_param(
::caffe::ContrastiveLossParameter* contrastive_loss_param);
::caffe::ContrastiveLossParameter* unsafe_arena_release_contrastive_loss_param();
// optional .caffe.ConvolutionParameter convolution_param = 106;
bool has_convolution_param() const;
private:
bool _internal_has_convolution_param() const;
public:
void clear_convolution_param();
const ::caffe::ConvolutionParameter& convolution_param() const;
PROTOBUF_NODISCARD ::caffe::ConvolutionParameter* release_convolution_param();
::caffe::ConvolutionParameter* mutable_convolution_param();
void set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param);
private:
const ::caffe::ConvolutionParameter& _internal_convolution_param() const;
::caffe::ConvolutionParameter* _internal_mutable_convolution_param();
public:
void unsafe_arena_set_allocated_convolution_param(
::caffe::ConvolutionParameter* convolution_param);
::caffe::ConvolutionParameter* unsafe_arena_release_convolution_param();
// optional .caffe.DataParameter data_param = 107;
bool has_data_param() const;
private:
bool _internal_has_data_param() const;
public:
void clear_data_param();
const ::caffe::DataParameter& data_param() const;
PROTOBUF_NODISCARD ::caffe::DataParameter* release_data_param();
::caffe::DataParameter* mutable_data_param();
void set_allocated_data_param(::caffe::DataParameter* data_param);
private:
const ::caffe::DataParameter& _internal_data_param() const;
::caffe::DataParameter* _internal_mutable_data_param();
public:
void unsafe_arena_set_allocated_data_param(
::caffe::DataParameter* data_param);
::caffe::DataParameter* unsafe_arena_release_data_param();
// optional .caffe.DropoutParameter dropout_param = 108;
bool has_dropout_param() const;
private:
bool _internal_has_dropout_param() const;
public:
void clear_dropout_param();
const ::caffe::DropoutParameter& dropout_param() const;
PROTOBUF_NODISCARD ::caffe::DropoutParameter* release_dropout_param();
::caffe::DropoutParameter* mutable_dropout_param();
void set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param);
private:
const ::caffe::DropoutParameter& _internal_dropout_param() const;
::caffe::DropoutParameter* _internal_mutable_dropout_param();
public:
void unsafe_arena_set_allocated_dropout_param(
::caffe::DropoutParameter* dropout_param);
::caffe::DropoutParameter* unsafe_arena_release_dropout_param();
// optional .caffe.DummyDataParameter dummy_data_param = 109;
bool has_dummy_data_param() const;
private:
bool _internal_has_dummy_data_param() const;
public:
void clear_dummy_data_param();
const ::caffe::DummyDataParameter& dummy_data_param() const;
PROTOBUF_NODISCARD ::caffe::DummyDataParameter* release_dummy_data_param();
::caffe::DummyDataParameter* mutable_dummy_data_param();
void set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param);
private:
const ::caffe::DummyDataParameter& _internal_dummy_data_param() const;
::caffe::DummyDataParameter* _internal_mutable_dummy_data_param();
public:
void unsafe_arena_set_allocated_dummy_data_param(
::caffe::DummyDataParameter* dummy_data_param);
::caffe::DummyDataParameter* unsafe_arena_release_dummy_data_param();
// optional .caffe.EltwiseParameter eltwise_param = 110;
bool has_eltwise_param() const;
private:
bool _internal_has_eltwise_param() const;
public:
void clear_eltwise_param();
const ::caffe::EltwiseParameter& eltwise_param() const;
PROTOBUF_NODISCARD ::caffe::EltwiseParameter* release_eltwise_param();
::caffe::EltwiseParameter* mutable_eltwise_param();
void set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param);
private:
const ::caffe::EltwiseParameter& _internal_eltwise_param() const;
::caffe::EltwiseParameter* _internal_mutable_eltwise_param();
public:
void unsafe_arena_set_allocated_eltwise_param(
::caffe::EltwiseParameter* eltwise_param);
::caffe::EltwiseParameter* unsafe_arena_release_eltwise_param();
// optional .caffe.ExpParameter exp_param = 111;
bool has_exp_param() const;
private:
bool _internal_has_exp_param() const;
public:
void clear_exp_param();
const ::caffe::ExpParameter& exp_param() const;
PROTOBUF_NODISCARD ::caffe::ExpParameter* release_exp_param();
::caffe::ExpParameter* mutable_exp_param();
void set_allocated_exp_param(::caffe::ExpParameter* exp_param);
private:
const ::caffe::ExpParameter& _internal_exp_param() const;
::caffe::ExpParameter* _internal_mutable_exp_param();
public:
void unsafe_arena_set_allocated_exp_param(
::caffe::ExpParameter* exp_param);
::caffe::ExpParameter* unsafe_arena_release_exp_param();
// optional .caffe.HDF5DataParameter hdf5_data_param = 112;
bool has_hdf5_data_param() const;
private:
bool _internal_has_hdf5_data_param() const;
public:
void clear_hdf5_data_param();
const ::caffe::HDF5DataParameter& hdf5_data_param() const;
PROTOBUF_NODISCARD ::caffe::HDF5DataParameter* release_hdf5_data_param();
::caffe::HDF5DataParameter* mutable_hdf5_data_param();
void set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param);
private:
const ::caffe::HDF5DataParameter& _internal_hdf5_data_param() const;
::caffe::HDF5DataParameter* _internal_mutable_hdf5_data_param();
public:
void unsafe_arena_set_allocated_hdf5_data_param(
::caffe::HDF5DataParameter* hdf5_data_param);
::caffe::HDF5DataParameter* unsafe_arena_release_hdf5_data_param();
// optional .caffe.HDF5OutputParameter hdf5_output_param = 113;
bool has_hdf5_output_param() const;
private:
bool _internal_has_hdf5_output_param() const;
public:
void clear_hdf5_output_param();
const ::caffe::HDF5OutputParameter& hdf5_output_param() const;
PROTOBUF_NODISCARD ::caffe::HDF5OutputParameter* release_hdf5_output_param();
::caffe::HDF5OutputParameter* mutable_hdf5_output_param();
void set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param);
private:
const ::caffe::HDF5OutputParameter& _internal_hdf5_output_param() const;
::caffe::HDF5OutputParameter* _internal_mutable_hdf5_output_param();
public:
void unsafe_arena_set_allocated_hdf5_output_param(
::caffe::HDF5OutputParameter* hdf5_output_param);
::caffe::HDF5OutputParameter* unsafe_arena_release_hdf5_output_param();
// optional .caffe.HingeLossParameter hinge_loss_param = 114;
bool has_hinge_loss_param() const;
private:
bool _internal_has_hinge_loss_param() const;
public:
void clear_hinge_loss_param();
const ::caffe::HingeLossParameter& hinge_loss_param() const;
PROTOBUF_NODISCARD ::caffe::HingeLossParameter* release_hinge_loss_param();
::caffe::HingeLossParameter* mutable_hinge_loss_param();
void set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param);
private:
const ::caffe::HingeLossParameter& _internal_hinge_loss_param() const;
::caffe::HingeLossParameter* _internal_mutable_hinge_loss_param();
public:
void unsafe_arena_set_allocated_hinge_loss_param(
::caffe::HingeLossParameter* hinge_loss_param);
::caffe::HingeLossParameter* unsafe_arena_release_hinge_loss_param();
// optional .caffe.ImageDataParameter image_data_param = 115;
bool has_image_data_param() const;
private:
bool _internal_has_image_data_param() const;
public:
void clear_image_data_param();
const ::caffe::ImageDataParameter& image_data_param() const;
PROTOBUF_NODISCARD ::caffe::ImageDataParameter* release_image_data_param();
::caffe::ImageDataParameter* mutable_image_data_param();
void set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param);
private:
const ::caffe::ImageDataParameter& _internal_image_data_param() const;
::caffe::ImageDataParameter* _internal_mutable_image_data_param();
public:
void unsafe_arena_set_allocated_image_data_param(
::caffe::ImageDataParameter* image_data_param);
::caffe::ImageDataParameter* unsafe_arena_release_image_data_param();
// optional .caffe.InfogainLossParameter infogain_loss_param = 116;
bool has_infogain_loss_param() const;
private:
bool _internal_has_infogain_loss_param() const;
public:
void clear_infogain_loss_param();
const ::caffe::InfogainLossParameter& infogain_loss_param() const;
PROTOBUF_NODISCARD ::caffe::InfogainLossParameter* release_infogain_loss_param();
::caffe::InfogainLossParameter* mutable_infogain_loss_param();
void set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param);
private:
const ::caffe::InfogainLossParameter& _internal_infogain_loss_param() const;
::caffe::InfogainLossParameter* _internal_mutable_infogain_loss_param();
public:
void unsafe_arena_set_allocated_infogain_loss_param(
::caffe::InfogainLossParameter* infogain_loss_param);
::caffe::InfogainLossParameter* unsafe_arena_release_infogain_loss_param();
// optional .caffe.InnerProductParameter inner_product_param = 117;
bool has_inner_product_param() const;
private:
bool _internal_has_inner_product_param() const;
public:
void clear_inner_product_param();
const ::caffe::InnerProductParameter& inner_product_param() const;
PROTOBUF_NODISCARD ::caffe::InnerProductParameter* release_inner_product_param();
::caffe::InnerProductParameter* mutable_inner_product_param();
void set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param);
private:
const ::caffe::InnerProductParameter& _internal_inner_product_param() const;
::caffe::InnerProductParameter* _internal_mutable_inner_product_param();
public:
void unsafe_arena_set_allocated_inner_product_param(
::caffe::InnerProductParameter* inner_product_param);
::caffe::InnerProductParameter* unsafe_arena_release_inner_product_param();
// optional .caffe.LRNParameter lrn_param = 118;
bool has_lrn_param() const;
private:
bool _internal_has_lrn_param() const;
public:
void clear_lrn_param();
const ::caffe::LRNParameter& lrn_param() const;
PROTOBUF_NODISCARD ::caffe::LRNParameter* release_lrn_param();
::caffe::LRNParameter* mutable_lrn_param();
void set_allocated_lrn_param(::caffe::LRNParameter* lrn_param);
private:
const ::caffe::LRNParameter& _internal_lrn_param() const;
::caffe::LRNParameter* _internal_mutable_lrn_param();
public:
void unsafe_arena_set_allocated_lrn_param(
::caffe::LRNParameter* lrn_param);
::caffe::LRNParameter* unsafe_arena_release_lrn_param();
// optional .caffe.MemoryDataParameter memory_data_param = 119;
bool has_memory_data_param() const;
private:
bool _internal_has_memory_data_param() const;
public:
void clear_memory_data_param();
const ::caffe::MemoryDataParameter& memory_data_param() const;
PROTOBUF_NODISCARD ::caffe::MemoryDataParameter* release_memory_data_param();
::caffe::MemoryDataParameter* mutable_memory_data_param();
void set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param);
private:
const ::caffe::MemoryDataParameter& _internal_memory_data_param() const;
::caffe::MemoryDataParameter* _internal_mutable_memory_data_param();
public:
void unsafe_arena_set_allocated_memory_data_param(
::caffe::MemoryDataParameter* memory_data_param);
::caffe::MemoryDataParameter* unsafe_arena_release_memory_data_param();
// optional .caffe.MVNParameter mvn_param = 120;
bool has_mvn_param() const;
private:
bool _internal_has_mvn_param() const;
public:
void clear_mvn_param();
const ::caffe::MVNParameter& mvn_param() const;
PROTOBUF_NODISCARD ::caffe::MVNParameter* release_mvn_param();
::caffe::MVNParameter* mutable_mvn_param();
void set_allocated_mvn_param(::caffe::MVNParameter* mvn_param);
private:
const ::caffe::MVNParameter& _internal_mvn_param() const;
::caffe::MVNParameter* _internal_mutable_mvn_param();
public:
void unsafe_arena_set_allocated_mvn_param(
::caffe::MVNParameter* mvn_param);
::caffe::MVNParameter* unsafe_arena_release_mvn_param();
// optional .caffe.PoolingParameter pooling_param = 121;
bool has_pooling_param() const;
private:
bool _internal_has_pooling_param() const;
public:
void clear_pooling_param();
const ::caffe::PoolingParameter& pooling_param() const;
PROTOBUF_NODISCARD ::caffe::PoolingParameter* release_pooling_param();
::caffe::PoolingParameter* mutable_pooling_param();
void set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param);
private:
const ::caffe::PoolingParameter& _internal_pooling_param() const;
::caffe::PoolingParameter* _internal_mutable_pooling_param();
public:
void unsafe_arena_set_allocated_pooling_param(
::caffe::PoolingParameter* pooling_param);
::caffe::PoolingParameter* unsafe_arena_release_pooling_param();
// optional .caffe.PowerParameter power_param = 122;
bool has_power_param() const;
private:
bool _internal_has_power_param() const;
public:
void clear_power_param();
const ::caffe::PowerParameter& power_param() const;
PROTOBUF_NODISCARD ::caffe::PowerParameter* release_power_param();
::caffe::PowerParameter* mutable_power_param();
void set_allocated_power_param(::caffe::PowerParameter* power_param);
private:
const ::caffe::PowerParameter& _internal_power_param() const;
::caffe::PowerParameter* _internal_mutable_power_param();
public:
void unsafe_arena_set_allocated_power_param(
::caffe::PowerParameter* power_param);
::caffe::PowerParameter* unsafe_arena_release_power_param();
// optional .caffe.ReLUParameter relu_param = 123;
bool has_relu_param() const;
private:
bool _internal_has_relu_param() const;
public:
void clear_relu_param();
const ::caffe::ReLUParameter& relu_param() const;
PROTOBUF_NODISCARD ::caffe::ReLUParameter* release_relu_param();
::caffe::ReLUParameter* mutable_relu_param();
void set_allocated_relu_param(::caffe::ReLUParameter* relu_param);
private:
const ::caffe::ReLUParameter& _internal_relu_param() const;
::caffe::ReLUParameter* _internal_mutable_relu_param();
public:
void unsafe_arena_set_allocated_relu_param(
::caffe::ReLUParameter* relu_param);
::caffe::ReLUParameter* unsafe_arena_release_relu_param();
// optional .caffe.SigmoidParameter sigmoid_param = 124;
bool has_sigmoid_param() const;
private:
bool _internal_has_sigmoid_param() const;
public:
void clear_sigmoid_param();
const ::caffe::SigmoidParameter& sigmoid_param() const;
PROTOBUF_NODISCARD ::caffe::SigmoidParameter* release_sigmoid_param();
::caffe::SigmoidParameter* mutable_sigmoid_param();
void set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param);
private:
const ::caffe::SigmoidParameter& _internal_sigmoid_param() const;
::caffe::SigmoidParameter* _internal_mutable_sigmoid_param();
public:
void unsafe_arena_set_allocated_sigmoid_param(
::caffe::SigmoidParameter* sigmoid_param);
::caffe::SigmoidParameter* unsafe_arena_release_sigmoid_param();
// optional .caffe.SoftmaxParameter softmax_param = 125;
bool has_softmax_param() const;
private:
bool _internal_has_softmax_param() const;
public:
void clear_softmax_param();
const ::caffe::SoftmaxParameter& softmax_param() const;
PROTOBUF_NODISCARD ::caffe::SoftmaxParameter* release_softmax_param();
::caffe::SoftmaxParameter* mutable_softmax_param();
void set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param);
private:
const ::caffe::SoftmaxParameter& _internal_softmax_param() const;
::caffe::SoftmaxParameter* _internal_mutable_softmax_param();
public:
void unsafe_arena_set_allocated_softmax_param(
::caffe::SoftmaxParameter* softmax_param);
::caffe::SoftmaxParameter* unsafe_arena_release_softmax_param();
// optional .caffe.SliceParameter slice_param = 126;
bool has_slice_param() const;
private:
bool _internal_has_slice_param() const;
public:
void clear_slice_param();
const ::caffe::SliceParameter& slice_param() const;
PROTOBUF_NODISCARD ::caffe::SliceParameter* release_slice_param();
::caffe::SliceParameter* mutable_slice_param();
void set_allocated_slice_param(::caffe::SliceParameter* slice_param);
private:
const ::caffe::SliceParameter& _internal_slice_param() const;
::caffe::SliceParameter* _internal_mutable_slice_param();
public:
void unsafe_arena_set_allocated_slice_param(
::caffe::SliceParameter* slice_param);
::caffe::SliceParameter* unsafe_arena_release_slice_param();
// optional .caffe.TanHParameter tanh_param = 127;
bool has_tanh_param() const;
private:
bool _internal_has_tanh_param() const;
public:
void clear_tanh_param();
const ::caffe::TanHParameter& tanh_param() const;
PROTOBUF_NODISCARD ::caffe::TanHParameter* release_tanh_param();
::caffe::TanHParameter* mutable_tanh_param();
void set_allocated_tanh_param(::caffe::TanHParameter* tanh_param);
private:
const ::caffe::TanHParameter& _internal_tanh_param() const;
::caffe::TanHParameter* _internal_mutable_tanh_param();
public:
void unsafe_arena_set_allocated_tanh_param(
::caffe::TanHParameter* tanh_param);
::caffe::TanHParameter* unsafe_arena_release_tanh_param();
// optional .caffe.ThresholdParameter threshold_param = 128;
bool has_threshold_param() const;
private:
bool _internal_has_threshold_param() const;
public:
void clear_threshold_param();
const ::caffe::ThresholdParameter& threshold_param() const;
PROTOBUF_NODISCARD ::caffe::ThresholdParameter* release_threshold_param();
::caffe::ThresholdParameter* mutable_threshold_param();
void set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param);
private:
const ::caffe::ThresholdParameter& _internal_threshold_param() const;
::caffe::ThresholdParameter* _internal_mutable_threshold_param();
public:
void unsafe_arena_set_allocated_threshold_param(
::caffe::ThresholdParameter* threshold_param);
::caffe::ThresholdParameter* unsafe_arena_release_threshold_param();
// optional .caffe.WindowDataParameter window_data_param = 129;
bool has_window_data_param() const;
private:
bool _internal_has_window_data_param() const;
public:
void clear_window_data_param();
const ::caffe::WindowDataParameter& window_data_param() const;
PROTOBUF_NODISCARD ::caffe::WindowDataParameter* release_window_data_param();
::caffe::WindowDataParameter* mutable_window_data_param();
void set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param);
private:
const ::caffe::WindowDataParameter& _internal_window_data_param() const;
::caffe::WindowDataParameter* _internal_mutable_window_data_param();
public:
void unsafe_arena_set_allocated_window_data_param(
::caffe::WindowDataParameter* window_data_param);
::caffe::WindowDataParameter* unsafe_arena_release_window_data_param();
// optional .caffe.PythonParameter python_param = 130;
bool has_python_param() const;
private:
bool _internal_has_python_param() const;
public:
void clear_python_param();
const ::caffe::PythonParameter& python_param() const;
PROTOBUF_NODISCARD ::caffe::PythonParameter* release_python_param();
::caffe::PythonParameter* mutable_python_param();
void set_allocated_python_param(::caffe::PythonParameter* python_param);
private:
const ::caffe::PythonParameter& _internal_python_param() const;
::caffe::PythonParameter* _internal_mutable_python_param();
public:
void unsafe_arena_set_allocated_python_param(
::caffe::PythonParameter* python_param);
::caffe::PythonParameter* unsafe_arena_release_python_param();
// optional .caffe.PReLUParameter prelu_param = 131;
bool has_prelu_param() const;
private:
bool _internal_has_prelu_param() const;
public:
void clear_prelu_param();
const ::caffe::PReLUParameter& prelu_param() const;
PROTOBUF_NODISCARD ::caffe::PReLUParameter* release_prelu_param();
::caffe::PReLUParameter* mutable_prelu_param();
void set_allocated_prelu_param(::caffe::PReLUParameter* prelu_param);
private:
const ::caffe::PReLUParameter& _internal_prelu_param() const;
::caffe::PReLUParameter* _internal_mutable_prelu_param();
public:
void unsafe_arena_set_allocated_prelu_param(
::caffe::PReLUParameter* prelu_param);
::caffe::PReLUParameter* unsafe_arena_release_prelu_param();
// optional .caffe.SPPParameter spp_param = 132;
bool has_spp_param() const;
private:
bool _internal_has_spp_param() const;
public:
void clear_spp_param();
const ::caffe::SPPParameter& spp_param() const;
PROTOBUF_NODISCARD ::caffe::SPPParameter* release_spp_param();
::caffe::SPPParameter* mutable_spp_param();
void set_allocated_spp_param(::caffe::SPPParameter* spp_param);
private:
const ::caffe::SPPParameter& _internal_spp_param() const;
::caffe::SPPParameter* _internal_mutable_spp_param();
public:
void unsafe_arena_set_allocated_spp_param(
::caffe::SPPParameter* spp_param);
::caffe::SPPParameter* unsafe_arena_release_spp_param();
// optional .caffe.ReshapeParameter reshape_param = 133;
bool has_reshape_param() const;
private:
bool _internal_has_reshape_param() const;
public:
void clear_reshape_param();
const ::caffe::ReshapeParameter& reshape_param() const;
PROTOBUF_NODISCARD ::caffe::ReshapeParameter* release_reshape_param();
::caffe::ReshapeParameter* mutable_reshape_param();
void set_allocated_reshape_param(::caffe::ReshapeParameter* reshape_param);
private:
const ::caffe::ReshapeParameter& _internal_reshape_param() const;
::caffe::ReshapeParameter* _internal_mutable_reshape_param();
public:
void unsafe_arena_set_allocated_reshape_param(
::caffe::ReshapeParameter* reshape_param);
::caffe::ReshapeParameter* unsafe_arena_release_reshape_param();
// optional .caffe.LogParameter log_param = 134;
bool has_log_param() const;
private:
bool _internal_has_log_param() const;
public:
void clear_log_param();
const ::caffe::LogParameter& log_param() const;
PROTOBUF_NODISCARD ::caffe::LogParameter* release_log_param();
::caffe::LogParameter* mutable_log_param();
void set_allocated_log_param(::caffe::LogParameter* log_param);
private:
const ::caffe::LogParameter& _internal_log_param() const;
::caffe::LogParameter* _internal_mutable_log_param();
public:
void unsafe_arena_set_allocated_log_param(
::caffe::LogParameter* log_param);
::caffe::LogParameter* unsafe_arena_release_log_param();
// optional .caffe.FlattenParameter flatten_param = 135;
bool has_flatten_param() const;
private:
bool _internal_has_flatten_param() const;
public:
void clear_flatten_param();
const ::caffe::FlattenParameter& flatten_param() const;
PROTOBUF_NODISCARD ::caffe::FlattenParameter* release_flatten_param();
::caffe::FlattenParameter* mutable_flatten_param();
void set_allocated_flatten_param(::caffe::FlattenParameter* flatten_param);
private:
const ::caffe::FlattenParameter& _internal_flatten_param() const;
::caffe::FlattenParameter* _internal_mutable_flatten_param();
public:
void unsafe_arena_set_allocated_flatten_param(
::caffe::FlattenParameter* flatten_param);
::caffe::FlattenParameter* unsafe_arena_release_flatten_param();
// optional .caffe.ReductionParameter reduction_param = 136;
bool has_reduction_param() const;
private:
bool _internal_has_reduction_param() const;
public:
void clear_reduction_param();
const ::caffe::ReductionParameter& reduction_param() const;
PROTOBUF_NODISCARD ::caffe::ReductionParameter* release_reduction_param();
::caffe::ReductionParameter* mutable_reduction_param();
void set_allocated_reduction_param(::caffe::ReductionParameter* reduction_param);
private:
const ::caffe::ReductionParameter& _internal_reduction_param() const;
::caffe::ReductionParameter* _internal_mutable_reduction_param();
public:
void unsafe_arena_set_allocated_reduction_param(
::caffe::ReductionParameter* reduction_param);
::caffe::ReductionParameter* unsafe_arena_release_reduction_param();
// optional .caffe.EmbedParameter embed_param = 137;
bool has_embed_param() const;
private:
bool _internal_has_embed_param() const;
public:
void clear_embed_param();
const ::caffe::EmbedParameter& embed_param() const;
PROTOBUF_NODISCARD ::caffe::EmbedParameter* release_embed_param();
::caffe::EmbedParameter* mutable_embed_param();
void set_allocated_embed_param(::caffe::EmbedParameter* embed_param);
private:
const ::caffe::EmbedParameter& _internal_embed_param() const;
::caffe::EmbedParameter* _internal_mutable_embed_param();
public:
void unsafe_arena_set_allocated_embed_param(
::caffe::EmbedParameter* embed_param);
::caffe::EmbedParameter* unsafe_arena_release_embed_param();
// optional .caffe.TileParameter tile_param = 138;
bool has_tile_param() const;
private:
bool _internal_has_tile_param() const;
public:
void clear_tile_param();
const ::caffe::TileParameter& tile_param() const;
PROTOBUF_NODISCARD ::caffe::TileParameter* release_tile_param();
::caffe::TileParameter* mutable_tile_param();
void set_allocated_tile_param(::caffe::TileParameter* tile_param);
private:
const ::caffe::TileParameter& _internal_tile_param() const;
::caffe::TileParameter* _internal_mutable_tile_param();
public:
void unsafe_arena_set_allocated_tile_param(
::caffe::TileParameter* tile_param);
::caffe::TileParameter* unsafe_arena_release_tile_param();
// optional .caffe.BatchNormParameter batch_norm_param = 139;
bool has_batch_norm_param() const;
private:
bool _internal_has_batch_norm_param() const;
public:
void clear_batch_norm_param();
const ::caffe::BatchNormParameter& batch_norm_param() const;
PROTOBUF_NODISCARD ::caffe::BatchNormParameter* release_batch_norm_param();
::caffe::BatchNormParameter* mutable_batch_norm_param();
void set_allocated_batch_norm_param(::caffe::BatchNormParameter* batch_norm_param);
private:
const ::caffe::BatchNormParameter& _internal_batch_norm_param() const;
::caffe::BatchNormParameter* _internal_mutable_batch_norm_param();
public:
void unsafe_arena_set_allocated_batch_norm_param(
::caffe::BatchNormParameter* batch_norm_param);
::caffe::BatchNormParameter* unsafe_arena_release_batch_norm_param();
// optional .caffe.ELUParameter elu_param = 140;
bool has_elu_param() const;
private:
bool _internal_has_elu_param() const;
public:
void clear_elu_param();
const ::caffe::ELUParameter& elu_param() const;
PROTOBUF_NODISCARD ::caffe::ELUParameter* release_elu_param();
::caffe::ELUParameter* mutable_elu_param();
void set_allocated_elu_param(::caffe::ELUParameter* elu_param);
private:
const ::caffe::ELUParameter& _internal_elu_param() const;
::caffe::ELUParameter* _internal_mutable_elu_param();
public:
void unsafe_arena_set_allocated_elu_param(
::caffe::ELUParameter* elu_param);
::caffe::ELUParameter* unsafe_arena_release_elu_param();
// optional .caffe.BiasParameter bias_param = 141;
bool has_bias_param() const;
private:
bool _internal_has_bias_param() const;
public:
void clear_bias_param();
const ::caffe::BiasParameter& bias_param() const;
PROTOBUF_NODISCARD ::caffe::BiasParameter* release_bias_param();
::caffe::BiasParameter* mutable_bias_param();
void set_allocated_bias_param(::caffe::BiasParameter* bias_param);
private:
const ::caffe::BiasParameter& _internal_bias_param() const;
::caffe::BiasParameter* _internal_mutable_bias_param();
public:
void unsafe_arena_set_allocated_bias_param(
::caffe::BiasParameter* bias_param);
::caffe::BiasParameter* unsafe_arena_release_bias_param();
// optional .caffe.ScaleParameter scale_param = 142;
bool has_scale_param() const;
private:
bool _internal_has_scale_param() const;
public:
void clear_scale_param();
const ::caffe::ScaleParameter& scale_param() const;
PROTOBUF_NODISCARD ::caffe::ScaleParameter* release_scale_param();
::caffe::ScaleParameter* mutable_scale_param();
void set_allocated_scale_param(::caffe::ScaleParameter* scale_param);
private:
const ::caffe::ScaleParameter& _internal_scale_param() const;
::caffe::ScaleParameter* _internal_mutable_scale_param();
public:
void unsafe_arena_set_allocated_scale_param(
::caffe::ScaleParameter* scale_param);
::caffe::ScaleParameter* unsafe_arena_release_scale_param();
// optional .caffe.InputParameter input_param = 143;
bool has_input_param() const;
private:
bool _internal_has_input_param() const;
public:
void clear_input_param();
const ::caffe::InputParameter& input_param() const;
PROTOBUF_NODISCARD ::caffe::InputParameter* release_input_param();
::caffe::InputParameter* mutable_input_param();
void set_allocated_input_param(::caffe::InputParameter* input_param);
private:
const ::caffe::InputParameter& _internal_input_param() const;
::caffe::InputParameter* _internal_mutable_input_param();
public:
void unsafe_arena_set_allocated_input_param(
::caffe::InputParameter* input_param);
::caffe::InputParameter* unsafe_arena_release_input_param();
// optional .caffe.CropParameter crop_param = 144;
bool has_crop_param() const;
private:
bool _internal_has_crop_param() const;
public:
void clear_crop_param();
const ::caffe::CropParameter& crop_param() const;
PROTOBUF_NODISCARD ::caffe::CropParameter* release_crop_param();
::caffe::CropParameter* mutable_crop_param();
void set_allocated_crop_param(::caffe::CropParameter* crop_param);
private:
const ::caffe::CropParameter& _internal_crop_param() const;
::caffe::CropParameter* _internal_mutable_crop_param();
public:
void unsafe_arena_set_allocated_crop_param(
::caffe::CropParameter* crop_param);
::caffe::CropParameter* unsafe_arena_release_crop_param();
// optional .caffe.ParameterParameter parameter_param = 145;
bool has_parameter_param() const;
private:
bool _internal_has_parameter_param() const;
public:
void clear_parameter_param();
const ::caffe::ParameterParameter& parameter_param() const;
PROTOBUF_NODISCARD ::caffe::ParameterParameter* release_parameter_param();
::caffe::ParameterParameter* mutable_parameter_param();
void set_allocated_parameter_param(::caffe::ParameterParameter* parameter_param);
private:
const ::caffe::ParameterParameter& _internal_parameter_param() const;
::caffe::ParameterParameter* _internal_mutable_parameter_param();
public:
void unsafe_arena_set_allocated_parameter_param(
::caffe::ParameterParameter* parameter_param);
::caffe::ParameterParameter* unsafe_arena_release_parameter_param();
// optional .caffe.RecurrentParameter recurrent_param = 146;
bool has_recurrent_param() const;
private:
bool _internal_has_recurrent_param() const;
public:
void clear_recurrent_param();
const ::caffe::RecurrentParameter& recurrent_param() const;
PROTOBUF_NODISCARD ::caffe::RecurrentParameter* release_recurrent_param();
::caffe::RecurrentParameter* mutable_recurrent_param();
void set_allocated_recurrent_param(::caffe::RecurrentParameter* recurrent_param);
private:
const ::caffe::RecurrentParameter& _internal_recurrent_param() const;
::caffe::RecurrentParameter* _internal_mutable_recurrent_param();
public:
void unsafe_arena_set_allocated_recurrent_param(
::caffe::RecurrentParameter* recurrent_param);
::caffe::RecurrentParameter* unsafe_arena_release_recurrent_param();
// optional .caffe.Convolution3DParameter convolution3d_param = 147;
bool has_convolution3d_param() const;
private:
bool _internal_has_convolution3d_param() const;
public:
void clear_convolution3d_param();
const ::caffe::Convolution3DParameter& convolution3d_param() const;
PROTOBUF_NODISCARD ::caffe::Convolution3DParameter* release_convolution3d_param();
::caffe::Convolution3DParameter* mutable_convolution3d_param();
void set_allocated_convolution3d_param(::caffe::Convolution3DParameter* convolution3d_param);
private:
const ::caffe::Convolution3DParameter& _internal_convolution3d_param() const;
::caffe::Convolution3DParameter* _internal_mutable_convolution3d_param();
public:
void unsafe_arena_set_allocated_convolution3d_param(
::caffe::Convolution3DParameter* convolution3d_param);
::caffe::Convolution3DParameter* unsafe_arena_release_convolution3d_param();
// optional .caffe.Pooling3DParameter pooling3d_param = 148;
bool has_pooling3d_param() const;
private:
bool _internal_has_pooling3d_param() const;
public:
void clear_pooling3d_param();
const ::caffe::Pooling3DParameter& pooling3d_param() const;
PROTOBUF_NODISCARD ::caffe::Pooling3DParameter* release_pooling3d_param();
::caffe::Pooling3DParameter* mutable_pooling3d_param();
void set_allocated_pooling3d_param(::caffe::Pooling3DParameter* pooling3d_param);
private:
const ::caffe::Pooling3DParameter& _internal_pooling3d_param() const;
::caffe::Pooling3DParameter* _internal_mutable_pooling3d_param();
public:
void unsafe_arena_set_allocated_pooling3d_param(
::caffe::Pooling3DParameter* pooling3d_param);
::caffe::Pooling3DParameter* unsafe_arena_release_pooling3d_param();
// optional .caffe.AnnotatedDataParameter annotated_data_param = 200;
bool has_annotated_data_param() const;
private:
bool _internal_has_annotated_data_param() const;
public:
void clear_annotated_data_param();
const ::caffe::AnnotatedDataParameter& annotated_data_param() const;
PROTOBUF_NODISCARD ::caffe::AnnotatedDataParameter* release_annotated_data_param();
::caffe::AnnotatedDataParameter* mutable_annotated_data_param();
void set_allocated_annotated_data_param(::caffe::AnnotatedDataParameter* annotated_data_param);
private:
const ::caffe::AnnotatedDataParameter& _internal_annotated_data_param() const;
::caffe::AnnotatedDataParameter* _internal_mutable_annotated_data_param();
public:
void unsafe_arena_set_allocated_annotated_data_param(
::caffe::AnnotatedDataParameter* annotated_data_param);
::caffe::AnnotatedDataParameter* unsafe_arena_release_annotated_data_param();
// optional .caffe.MultiBoxLossParameter multibox_loss_param = 201;
bool has_multibox_loss_param() const;
private:
bool _internal_has_multibox_loss_param() const;
public:
void clear_multibox_loss_param();
const ::caffe::MultiBoxLossParameter& multibox_loss_param() const;
PROTOBUF_NODISCARD ::caffe::MultiBoxLossParameter* release_multibox_loss_param();
::caffe::MultiBoxLossParameter* mutable_multibox_loss_param();
void set_allocated_multibox_loss_param(::caffe::MultiBoxLossParameter* multibox_loss_param);
private:
const ::caffe::MultiBoxLossParameter& _internal_multibox_loss_param() const;
::caffe::MultiBoxLossParameter* _internal_mutable_multibox_loss_param();
public:
void unsafe_arena_set_allocated_multibox_loss_param(
::caffe::MultiBoxLossParameter* multibox_loss_param);
::caffe::MultiBoxLossParameter* unsafe_arena_release_multibox_loss_param();
// optional .caffe.PermuteParameter permute_param = 202;
bool has_permute_param() const;
private:
bool _internal_has_permute_param() const;
public:
void clear_permute_param();
const ::caffe::PermuteParameter& permute_param() const;
PROTOBUF_NODISCARD ::caffe::PermuteParameter* release_permute_param();
::caffe::PermuteParameter* mutable_permute_param();
void set_allocated_permute_param(::caffe::PermuteParameter* permute_param);
private:
const ::caffe::PermuteParameter& _internal_permute_param() const;
::caffe::PermuteParameter* _internal_mutable_permute_param();
public:
void unsafe_arena_set_allocated_permute_param(
::caffe::PermuteParameter* permute_param);
::caffe::PermuteParameter* unsafe_arena_release_permute_param();
// optional .caffe.PriorBoxParameter prior_box_param = 203;
bool has_prior_box_param() const;
private:
bool _internal_has_prior_box_param() const;
public:
void clear_prior_box_param();
const ::caffe::PriorBoxParameter& prior_box_param() const;
PROTOBUF_NODISCARD ::caffe::PriorBoxParameter* release_prior_box_param();
::caffe::PriorBoxParameter* mutable_prior_box_param();
void set_allocated_prior_box_param(::caffe::PriorBoxParameter* prior_box_param);
private:
const ::caffe::PriorBoxParameter& _internal_prior_box_param() const;
::caffe::PriorBoxParameter* _internal_mutable_prior_box_param();
public:
void unsafe_arena_set_allocated_prior_box_param(
::caffe::PriorBoxParameter* prior_box_param);
::caffe::PriorBoxParameter* unsafe_arena_release_prior_box_param();
// optional .caffe.DetectionOutputParameter detection_output_param = 204;
bool has_detection_output_param() const;
private:
bool _internal_has_detection_output_param() const;
public:
void clear_detection_output_param();
const ::caffe::DetectionOutputParameter& detection_output_param() const;
PROTOBUF_NODISCARD ::caffe::DetectionOutputParameter* release_detection_output_param();
::caffe::DetectionOutputParameter* mutable_detection_output_param();
void set_allocated_detection_output_param(::caffe::DetectionOutputParameter* detection_output_param);
private:
const ::caffe::DetectionOutputParameter& _internal_detection_output_param() const;
::caffe::DetectionOutputParameter* _internal_mutable_detection_output_param();
public:
void unsafe_arena_set_allocated_detection_output_param(
::caffe::DetectionOutputParameter* detection_output_param);
::caffe::DetectionOutputParameter* unsafe_arena_release_detection_output_param();
// optional .caffe.DetectionEvaluateParameter detection_evaluate_param = 205;
bool has_detection_evaluate_param() const;
private:
bool _internal_has_detection_evaluate_param() const;
public:
void clear_detection_evaluate_param();
const ::caffe::DetectionEvaluateParameter& detection_evaluate_param() const;
PROTOBUF_NODISCARD ::caffe::DetectionEvaluateParameter* release_detection_evaluate_param();
::caffe::DetectionEvaluateParameter* mutable_detection_evaluate_param();
void set_allocated_detection_evaluate_param(::caffe::DetectionEvaluateParameter* detection_evaluate_param);
private:
const ::caffe::DetectionEvaluateParameter& _internal_detection_evaluate_param() const;
::caffe::DetectionEvaluateParameter* _internal_mutable_detection_evaluate_param();
public:
void unsafe_arena_set_allocated_detection_evaluate_param(
::caffe::DetectionEvaluateParameter* detection_evaluate_param);
::caffe::DetectionEvaluateParameter* unsafe_arena_release_detection_evaluate_param();
// optional .caffe.NormalizeParameter norm_param = 206;
bool has_norm_param() const;
private:
bool _internal_has_norm_param() const;
public:
void clear_norm_param();
const ::caffe::NormalizeParameter& norm_param() const;
PROTOBUF_NODISCARD ::caffe::NormalizeParameter* release_norm_param();
::caffe::NormalizeParameter* mutable_norm_param();
void set_allocated_norm_param(::caffe::NormalizeParameter* norm_param);
private:
const ::caffe::NormalizeParameter& _internal_norm_param() const;
::caffe::NormalizeParameter* _internal_mutable_norm_param();
public:
void unsafe_arena_set_allocated_norm_param(
::caffe::NormalizeParameter* norm_param);
::caffe::NormalizeParameter* unsafe_arena_release_norm_param();
// optional .caffe.Im2seqParameter im2seq_param = 207;
bool has_im2seq_param() const;
private:
bool _internal_has_im2seq_param() const;
public:
void clear_im2seq_param();
const ::caffe::Im2seqParameter& im2seq_param() const;
PROTOBUF_NODISCARD ::caffe::Im2seqParameter* release_im2seq_param();
::caffe::Im2seqParameter* mutable_im2seq_param();
void set_allocated_im2seq_param(::caffe::Im2seqParameter* im2seq_param);
private:
const ::caffe::Im2seqParameter& _internal_im2seq_param() const;
::caffe::Im2seqParameter* _internal_mutable_im2seq_param();
public:
void unsafe_arena_set_allocated_im2seq_param(
::caffe::Im2seqParameter* im2seq_param);
::caffe::Im2seqParameter* unsafe_arena_release_im2seq_param();
// optional .caffe.Seq2outParameter seq2out_param = 208;
bool has_seq2out_param() const;
private:
bool _internal_has_seq2out_param() const;
public:
void clear_seq2out_param();
const ::caffe::Seq2outParameter& seq2out_param() const;
PROTOBUF_NODISCARD ::caffe::Seq2outParameter* release_seq2out_param();
::caffe::Seq2outParameter* mutable_seq2out_param();
void set_allocated_seq2out_param(::caffe::Seq2outParameter* seq2out_param);
private:
const ::caffe::Seq2outParameter& _internal_seq2out_param() const;
::caffe::Seq2outParameter* _internal_mutable_seq2out_param();
public:
void unsafe_arena_set_allocated_seq2out_param(
::caffe::Seq2outParameter* seq2out_param);
::caffe::Seq2outParameter* unsafe_arena_release_seq2out_param();
// optional .caffe.ImgSizeParameter img_size_param = 209;
bool has_img_size_param() const;
private:
bool _internal_has_img_size_param() const;
public:
void clear_img_size_param();
const ::caffe::ImgSizeParameter& img_size_param() const;
PROTOBUF_NODISCARD ::caffe::ImgSizeParameter* release_img_size_param();
::caffe::ImgSizeParameter* mutable_img_size_param();
void set_allocated_img_size_param(::caffe::ImgSizeParameter* img_size_param);
private:
const ::caffe::ImgSizeParameter& _internal_img_size_param() const;
::caffe::ImgSizeParameter* _internal_mutable_img_size_param();
public:
void unsafe_arena_set_allocated_img_size_param(
::caffe::ImgSizeParameter* img_size_param);
::caffe::ImgSizeParameter* unsafe_arena_release_img_size_param();
// optional .caffe.LSTMParameter lstm_param = 210;
bool has_lstm_param() const;
private:
bool _internal_has_lstm_param() const;
public:
void clear_lstm_param();
const ::caffe::LSTMParameter& lstm_param() const;
PROTOBUF_NODISCARD ::caffe::LSTMParameter* release_lstm_param();
::caffe::LSTMParameter* mutable_lstm_param();
void set_allocated_lstm_param(::caffe::LSTMParameter* lstm_param);
private:
const ::caffe::LSTMParameter& _internal_lstm_param() const;
::caffe::LSTMParameter* _internal_mutable_lstm_param();
public:
void unsafe_arena_set_allocated_lstm_param(
::caffe::LSTMParameter* lstm_param);
::caffe::LSTMParameter* unsafe_arena_release_lstm_param();
// optional .caffe.CenterLossParameter center_loss_param = 211;
bool has_center_loss_param() const;
private:
bool _internal_has_center_loss_param() const;
public:
void clear_center_loss_param();
const ::caffe::CenterLossParameter& center_loss_param() const;
PROTOBUF_NODISCARD ::caffe::CenterLossParameter* release_center_loss_param();
::caffe::CenterLossParameter* mutable_center_loss_param();
void set_allocated_center_loss_param(::caffe::CenterLossParameter* center_loss_param);
private:
const ::caffe::CenterLossParameter& _internal_center_loss_param() const;
::caffe::CenterLossParameter* _internal_mutable_center_loss_param();
public:
void unsafe_arena_set_allocated_center_loss_param(
::caffe::CenterLossParameter* center_loss_param);
::caffe::CenterLossParameter* unsafe_arena_release_center_loss_param();
// optional .caffe.ShuffleChannelParameter shuffle_channel_param = 212;
bool has_shuffle_channel_param() const;
private:
bool _internal_has_shuffle_channel_param() const;
public:
void clear_shuffle_channel_param();
const ::caffe::ShuffleChannelParameter& shuffle_channel_param() const;
PROTOBUF_NODISCARD ::caffe::ShuffleChannelParameter* release_shuffle_channel_param();
::caffe::ShuffleChannelParameter* mutable_shuffle_channel_param();
void set_allocated_shuffle_channel_param(::caffe::ShuffleChannelParameter* shuffle_channel_param);
private:
const ::caffe::ShuffleChannelParameter& _internal_shuffle_channel_param() const;
::caffe::ShuffleChannelParameter* _internal_mutable_shuffle_channel_param();
public:
void unsafe_arena_set_allocated_shuffle_channel_param(
::caffe::ShuffleChannelParameter* shuffle_channel_param);
::caffe::ShuffleChannelParameter* unsafe_arena_release_shuffle_channel_param();
// optional .caffe.ROIPoolingParameter roi_pooling_param = 2201;
bool has_roi_pooling_param() const;
private:
bool _internal_has_roi_pooling_param() const;
public:
void clear_roi_pooling_param();
const ::caffe::ROIPoolingParameter& roi_pooling_param() const;
PROTOBUF_NODISCARD ::caffe::ROIPoolingParameter* release_roi_pooling_param();
::caffe::ROIPoolingParameter* mutable_roi_pooling_param();
void set_allocated_roi_pooling_param(::caffe::ROIPoolingParameter* roi_pooling_param);
private:
const ::caffe::ROIPoolingParameter& _internal_roi_pooling_param() const;
::caffe::ROIPoolingParameter* _internal_mutable_roi_pooling_param();
public:
void unsafe_arena_set_allocated_roi_pooling_param(
::caffe::ROIPoolingParameter* roi_pooling_param);
::caffe::ROIPoolingParameter* unsafe_arena_release_roi_pooling_param();
// optional .caffe.ClipParameter clip_param = 2202;
bool has_clip_param() const;
private:
bool _internal_has_clip_param() const;
public:
void clear_clip_param();
const ::caffe::ClipParameter& clip_param() const;
PROTOBUF_NODISCARD ::caffe::ClipParameter* release_clip_param();
::caffe::ClipParameter* mutable_clip_param();
void set_allocated_clip_param(::caffe::ClipParameter* clip_param);
private:
const ::caffe::ClipParameter& _internal_clip_param() const;
::caffe::ClipParameter* _internal_mutable_clip_param();
public:
void unsafe_arena_set_allocated_clip_param(
::caffe::ClipParameter* clip_param);
::caffe::ClipParameter* unsafe_arena_release_clip_param();
// optional .caffe.UpsampleParameter upsample_param = 2203;
bool has_upsample_param() const;
private:
bool _internal_has_upsample_param() const;
public:
void clear_upsample_param();
const ::caffe::UpsampleParameter& upsample_param() const;
PROTOBUF_NODISCARD ::caffe::UpsampleParameter* release_upsample_param();
::caffe::UpsampleParameter* mutable_upsample_param();
void set_allocated_upsample_param(::caffe::UpsampleParameter* upsample_param);
private:
const ::caffe::UpsampleParameter& _internal_upsample_param() const;
::caffe::UpsampleParameter* _internal_mutable_upsample_param();
public:
void unsafe_arena_set_allocated_upsample_param(
::caffe::UpsampleParameter* upsample_param);
::caffe::UpsampleParameter* unsafe_arena_release_upsample_param();
// optional .caffe.InterpParameter interp_param = 2210;
bool has_interp_param() const;
private:
bool _internal_has_interp_param() const;
public:
void clear_interp_param();
const ::caffe::InterpParameter& interp_param() const;
PROTOBUF_NODISCARD ::caffe::InterpParameter* release_interp_param();
::caffe::InterpParameter* mutable_interp_param();
void set_allocated_interp_param(::caffe::InterpParameter* interp_param);
private:
const ::caffe::InterpParameter& _internal_interp_param() const;
::caffe::InterpParameter* _internal_mutable_interp_param();
public:
void unsafe_arena_set_allocated_interp_param(
::caffe::InterpParameter* interp_param);
::caffe::InterpParameter* unsafe_arena_release_interp_param();
// optional .caffe.Phase phase = 10;
bool has_phase() const;
private:
bool _internal_has_phase() const;
public:
void clear_phase();
::caffe::Phase phase() const;
void set_phase(::caffe::Phase value);
private:
::caffe::Phase _internal_phase() const;
void _internal_set_phase(::caffe::Phase value);
public:
// @@protoc_insertion_point(class_scope:caffe.LayerParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<3> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> bottom_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> top_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > loss_weight_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::ParamSpec > param_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto > blobs_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule > include_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule > exclude_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > propagate_down_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
::caffe::TransformationParameter* transform_param_;
::caffe::LossParameter* loss_param_;
::caffe::AccuracyParameter* accuracy_param_;
::caffe::ArgMaxParameter* argmax_param_;
::caffe::ConcatParameter* concat_param_;
::caffe::ContrastiveLossParameter* contrastive_loss_param_;
::caffe::ConvolutionParameter* convolution_param_;
::caffe::DataParameter* data_param_;
::caffe::DropoutParameter* dropout_param_;
::caffe::DummyDataParameter* dummy_data_param_;
::caffe::EltwiseParameter* eltwise_param_;
::caffe::ExpParameter* exp_param_;
::caffe::HDF5DataParameter* hdf5_data_param_;
::caffe::HDF5OutputParameter* hdf5_output_param_;
::caffe::HingeLossParameter* hinge_loss_param_;
::caffe::ImageDataParameter* image_data_param_;
::caffe::InfogainLossParameter* infogain_loss_param_;
::caffe::InnerProductParameter* inner_product_param_;
::caffe::LRNParameter* lrn_param_;
::caffe::MemoryDataParameter* memory_data_param_;
::caffe::MVNParameter* mvn_param_;
::caffe::PoolingParameter* pooling_param_;
::caffe::PowerParameter* power_param_;
::caffe::ReLUParameter* relu_param_;
::caffe::SigmoidParameter* sigmoid_param_;
::caffe::SoftmaxParameter* softmax_param_;
::caffe::SliceParameter* slice_param_;
::caffe::TanHParameter* tanh_param_;
::caffe::ThresholdParameter* threshold_param_;
::caffe::WindowDataParameter* window_data_param_;
::caffe::PythonParameter* python_param_;
::caffe::PReLUParameter* prelu_param_;
::caffe::SPPParameter* spp_param_;
::caffe::ReshapeParameter* reshape_param_;
::caffe::LogParameter* log_param_;
::caffe::FlattenParameter* flatten_param_;
::caffe::ReductionParameter* reduction_param_;
::caffe::EmbedParameter* embed_param_;
::caffe::TileParameter* tile_param_;
::caffe::BatchNormParameter* batch_norm_param_;
::caffe::ELUParameter* elu_param_;
::caffe::BiasParameter* bias_param_;
::caffe::ScaleParameter* scale_param_;
::caffe::InputParameter* input_param_;
::caffe::CropParameter* crop_param_;
::caffe::ParameterParameter* parameter_param_;
::caffe::RecurrentParameter* recurrent_param_;
::caffe::Convolution3DParameter* convolution3d_param_;
::caffe::Pooling3DParameter* pooling3d_param_;
::caffe::AnnotatedDataParameter* annotated_data_param_;
::caffe::MultiBoxLossParameter* multibox_loss_param_;
::caffe::PermuteParameter* permute_param_;
::caffe::PriorBoxParameter* prior_box_param_;
::caffe::DetectionOutputParameter* detection_output_param_;
::caffe::DetectionEvaluateParameter* detection_evaluate_param_;
::caffe::NormalizeParameter* norm_param_;
::caffe::Im2seqParameter* im2seq_param_;
::caffe::Seq2outParameter* seq2out_param_;
::caffe::ImgSizeParameter* img_size_param_;
::caffe::LSTMParameter* lstm_param_;
::caffe::CenterLossParameter* center_loss_param_;
::caffe::ShuffleChannelParameter* shuffle_channel_param_;
::caffe::ROIPoolingParameter* roi_pooling_param_;
::caffe::ClipParameter* clip_param_;
::caffe::UpsampleParameter* upsample_param_;
::caffe::InterpParameter* interp_param_;
int phase_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ClipParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ClipParameter) */ {
public:
inline ClipParameter() : ClipParameter(nullptr) {}
~ClipParameter() override;
explicit constexpr ClipParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ClipParameter(const ClipParameter& from);
ClipParameter(ClipParameter&& from) noexcept
: ClipParameter() {
*this = ::std::move(from);
}
inline ClipParameter& operator=(const ClipParameter& from) {
CopyFrom(from);
return *this;
}
inline ClipParameter& operator=(ClipParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ClipParameter& default_instance() {
return *internal_default_instance();
}
static inline const ClipParameter* internal_default_instance() {
return reinterpret_cast<const ClipParameter*>(
&_ClipParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
24;
friend void swap(ClipParameter& a, ClipParameter& b) {
a.Swap(&b);
}
inline void Swap(ClipParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ClipParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ClipParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ClipParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ClipParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ClipParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ClipParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ClipParameter";
}
protected:
explicit ClipParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMinFieldNumber = 1,
kMaxFieldNumber = 2,
};
// required float min = 1;
bool has_min() const;
private:
bool _internal_has_min() const;
public:
void clear_min();
float min() const;
void set_min(float value);
private:
float _internal_min() const;
void _internal_set_min(float value);
public:
// required float max = 2;
bool has_max() const;
private:
bool _internal_has_max() const;
public:
void clear_max();
float max() const;
void set_max(float value);
private:
float _internal_max() const;
void _internal_set_max(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ClipParameter)
private:
class _Internal;
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float min_;
float max_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ROIPoolingParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ROIPoolingParameter) */ {
public:
inline ROIPoolingParameter() : ROIPoolingParameter(nullptr) {}
~ROIPoolingParameter() override;
explicit constexpr ROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ROIPoolingParameter(const ROIPoolingParameter& from);
ROIPoolingParameter(ROIPoolingParameter&& from) noexcept
: ROIPoolingParameter() {
*this = ::std::move(from);
}
inline ROIPoolingParameter& operator=(const ROIPoolingParameter& from) {
CopyFrom(from);
return *this;
}
inline ROIPoolingParameter& operator=(ROIPoolingParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ROIPoolingParameter& default_instance() {
return *internal_default_instance();
}
static inline const ROIPoolingParameter* internal_default_instance() {
return reinterpret_cast<const ROIPoolingParameter*>(
&_ROIPoolingParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
25;
friend void swap(ROIPoolingParameter& a, ROIPoolingParameter& b) {
a.Swap(&b);
}
inline void Swap(ROIPoolingParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ROIPoolingParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ROIPoolingParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ROIPoolingParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ROIPoolingParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ROIPoolingParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ROIPoolingParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ROIPoolingParameter";
}
protected:
explicit ROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kPooledHFieldNumber = 1,
kPooledWFieldNumber = 2,
kSpatialScaleFieldNumber = 3,
};
// optional uint32 pooled_h = 1 [default = 0];
bool has_pooled_h() const;
private:
bool _internal_has_pooled_h() const;
public:
void clear_pooled_h();
uint32_t pooled_h() const;
void set_pooled_h(uint32_t value);
private:
uint32_t _internal_pooled_h() const;
void _internal_set_pooled_h(uint32_t value);
public:
// optional uint32 pooled_w = 2 [default = 0];
bool has_pooled_w() const;
private:
bool _internal_has_pooled_w() const;
public:
void clear_pooled_w();
uint32_t pooled_w() const;
void set_pooled_w(uint32_t value);
private:
uint32_t _internal_pooled_w() const;
void _internal_set_pooled_w(uint32_t value);
public:
// optional float spatial_scale = 3 [default = 1];
bool has_spatial_scale() const;
private:
bool _internal_has_spatial_scale() const;
public:
void clear_spatial_scale();
float spatial_scale() const;
void set_spatial_scale(float value);
private:
float _internal_spatial_scale() const;
void _internal_set_spatial_scale(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ROIPoolingParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t pooled_h_;
uint32_t pooled_w_;
float spatial_scale_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class InterpParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.InterpParameter) */ {
public:
inline InterpParameter() : InterpParameter(nullptr) {}
~InterpParameter() override;
explicit constexpr InterpParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
InterpParameter(const InterpParameter& from);
InterpParameter(InterpParameter&& from) noexcept
: InterpParameter() {
*this = ::std::move(from);
}
inline InterpParameter& operator=(const InterpParameter& from) {
CopyFrom(from);
return *this;
}
inline InterpParameter& operator=(InterpParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const InterpParameter& default_instance() {
return *internal_default_instance();
}
static inline const InterpParameter* internal_default_instance() {
return reinterpret_cast<const InterpParameter*>(
&_InterpParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
26;
friend void swap(InterpParameter& a, InterpParameter& b) {
a.Swap(&b);
}
inline void Swap(InterpParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(InterpParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
InterpParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<InterpParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const InterpParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const InterpParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(InterpParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.InterpParameter";
}
protected:
explicit InterpParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kHeightFieldNumber = 1,
kWidthFieldNumber = 2,
kPadBegFieldNumber = 5,
kPadEndFieldNumber = 6,
kZoomFactorFieldNumber = 3,
kShrinkFactorFieldNumber = 4,
};
// optional int32 height = 1 [default = 0];
bool has_height() const;
private:
bool _internal_has_height() const;
public:
void clear_height();
int32_t height() const;
void set_height(int32_t value);
private:
int32_t _internal_height() const;
void _internal_set_height(int32_t value);
public:
// optional int32 width = 2 [default = 0];
bool has_width() const;
private:
bool _internal_has_width() const;
public:
void clear_width();
int32_t width() const;
void set_width(int32_t value);
private:
int32_t _internal_width() const;
void _internal_set_width(int32_t value);
public:
// optional int32 pad_beg = 5 [default = 0];
bool has_pad_beg() const;
private:
bool _internal_has_pad_beg() const;
public:
void clear_pad_beg();
int32_t pad_beg() const;
void set_pad_beg(int32_t value);
private:
int32_t _internal_pad_beg() const;
void _internal_set_pad_beg(int32_t value);
public:
// optional int32 pad_end = 6 [default = 0];
bool has_pad_end() const;
private:
bool _internal_has_pad_end() const;
public:
void clear_pad_end();
int32_t pad_end() const;
void set_pad_end(int32_t value);
private:
int32_t _internal_pad_end() const;
void _internal_set_pad_end(int32_t value);
public:
// optional int32 zoom_factor = 3 [default = 1];
bool has_zoom_factor() const;
private:
bool _internal_has_zoom_factor() const;
public:
void clear_zoom_factor();
int32_t zoom_factor() const;
void set_zoom_factor(int32_t value);
private:
int32_t _internal_zoom_factor() const;
void _internal_set_zoom_factor(int32_t value);
public:
// optional int32 shrink_factor = 4 [default = 1];
bool has_shrink_factor() const;
private:
bool _internal_has_shrink_factor() const;
public:
void clear_shrink_factor();
int32_t shrink_factor() const;
void set_shrink_factor(int32_t value);
private:
int32_t _internal_shrink_factor() const;
void _internal_set_shrink_factor(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.InterpParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int32_t height_;
int32_t width_;
int32_t pad_beg_;
int32_t pad_end_;
int32_t zoom_factor_;
int32_t shrink_factor_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class LSTMParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.LSTMParameter) */ {
public:
inline LSTMParameter() : LSTMParameter(nullptr) {}
~LSTMParameter() override;
explicit constexpr LSTMParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
LSTMParameter(const LSTMParameter& from);
LSTMParameter(LSTMParameter&& from) noexcept
: LSTMParameter() {
*this = ::std::move(from);
}
inline LSTMParameter& operator=(const LSTMParameter& from) {
CopyFrom(from);
return *this;
}
inline LSTMParameter& operator=(LSTMParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const LSTMParameter& default_instance() {
return *internal_default_instance();
}
static inline const LSTMParameter* internal_default_instance() {
return reinterpret_cast<const LSTMParameter*>(
&_LSTMParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
27;
friend void swap(LSTMParameter& a, LSTMParameter& b) {
a.Swap(&b);
}
inline void Swap(LSTMParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(LSTMParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
LSTMParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<LSTMParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const LSTMParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const LSTMParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(LSTMParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.LSTMParameter";
}
protected:
explicit LSTMParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kWeightFillerFieldNumber = 3,
kBiasFillerFieldNumber = 4,
kNumOutputFieldNumber = 1,
kClippingThresholdFieldNumber = 2,
kParamqFieldNumber = 6,
kScaleInFieldNumber = 7,
kScaleOutFieldNumber = 8,
kAMaxFieldNumber = 10,
kBatchSizeFieldNumber = 5,
kAMinFieldNumber = 9,
};
// optional .caffe.FillerParameter weight_filler = 3;
bool has_weight_filler() const;
private:
bool _internal_has_weight_filler() const;
public:
void clear_weight_filler();
const ::caffe::FillerParameter& weight_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_weight_filler();
::caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);
private:
const ::caffe::FillerParameter& _internal_weight_filler() const;
::caffe::FillerParameter* _internal_mutable_weight_filler();
public:
void unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler);
::caffe::FillerParameter* unsafe_arena_release_weight_filler();
// optional .caffe.FillerParameter bias_filler = 4;
bool has_bias_filler() const;
private:
bool _internal_has_bias_filler() const;
public:
void clear_bias_filler();
const ::caffe::FillerParameter& bias_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_bias_filler();
::caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);
private:
const ::caffe::FillerParameter& _internal_bias_filler() const;
::caffe::FillerParameter* _internal_mutable_bias_filler();
public:
void unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler);
::caffe::FillerParameter* unsafe_arena_release_bias_filler();
// optional uint32 num_output = 1;
bool has_num_output() const;
private:
bool _internal_has_num_output() const;
public:
void clear_num_output();
uint32_t num_output() const;
void set_num_output(uint32_t value);
private:
uint32_t _internal_num_output() const;
void _internal_set_num_output(uint32_t value);
public:
// optional float clipping_threshold = 2 [default = 0];
bool has_clipping_threshold() const;
private:
bool _internal_has_clipping_threshold() const;
public:
void clear_clipping_threshold();
float clipping_threshold() const;
void set_clipping_threshold(float value);
private:
float _internal_clipping_threshold() const;
void _internal_set_clipping_threshold(float value);
public:
// optional uint32 paramq = 6;
bool has_paramq() const;
private:
bool _internal_has_paramq() const;
public:
void clear_paramq();
uint32_t paramq() const;
void set_paramq(uint32_t value);
private:
uint32_t _internal_paramq() const;
void _internal_set_paramq(uint32_t value);
public:
// optional float scale_in = 7;
bool has_scale_in() const;
private:
bool _internal_has_scale_in() const;
public:
void clear_scale_in();
float scale_in() const;
void set_scale_in(float value);
private:
float _internal_scale_in() const;
void _internal_set_scale_in(float value);
public:
// optional float scale_out = 8;
bool has_scale_out() const;
private:
bool _internal_has_scale_out() const;
public:
void clear_scale_out();
float scale_out() const;
void set_scale_out(float value);
private:
float _internal_scale_out() const;
void _internal_set_scale_out(float value);
public:
// optional int32 a_max = 10 [default = 127];
bool has_a_max() const;
private:
bool _internal_has_a_max() const;
public:
void clear_a_max();
int32_t a_max() const;
void set_a_max(int32_t value);
private:
int32_t _internal_a_max() const;
void _internal_set_a_max(int32_t value);
public:
// optional uint32 batch_size = 5 [default = 1];
bool has_batch_size() const;
private:
bool _internal_has_batch_size() const;
public:
void clear_batch_size();
uint32_t batch_size() const;
void set_batch_size(uint32_t value);
private:
uint32_t _internal_batch_size() const;
void _internal_set_batch_size(uint32_t value);
public:
// optional int32 a_min = 9 [default = -128];
bool has_a_min() const;
private:
bool _internal_has_a_min() const;
public:
void clear_a_min();
int32_t a_min() const;
void set_a_min(int32_t value);
private:
int32_t _internal_a_min() const;
void _internal_set_a_min(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.LSTMParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* weight_filler_;
::caffe::FillerParameter* bias_filler_;
uint32_t num_output_;
float clipping_threshold_;
uint32_t paramq_;
float scale_in_;
float scale_out_;
int32_t a_max_;
uint32_t batch_size_;
int32_t a_min_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class Im2seqParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.Im2seqParameter) */ {
public:
inline Im2seqParameter() : Im2seqParameter(nullptr) {}
~Im2seqParameter() override;
explicit constexpr Im2seqParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Im2seqParameter(const Im2seqParameter& from);
Im2seqParameter(Im2seqParameter&& from) noexcept
: Im2seqParameter() {
*this = ::std::move(from);
}
inline Im2seqParameter& operator=(const Im2seqParameter& from) {
CopyFrom(from);
return *this;
}
inline Im2seqParameter& operator=(Im2seqParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Im2seqParameter& default_instance() {
return *internal_default_instance();
}
static inline const Im2seqParameter* internal_default_instance() {
return reinterpret_cast<const Im2seqParameter*>(
&_Im2seqParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
28;
friend void swap(Im2seqParameter& a, Im2seqParameter& b) {
a.Swap(&b);
}
inline void Swap(Im2seqParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Im2seqParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Im2seqParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Im2seqParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Im2seqParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Im2seqParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Im2seqParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.Im2seqParameter";
}
protected:
explicit Im2seqParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef Im2seqParameter_Direction Direction;
static constexpr Direction FORWARD =
Im2seqParameter_Direction_FORWARD;
static constexpr Direction REVERSED =
Im2seqParameter_Direction_REVERSED;
static constexpr Direction TOPDOWN =
Im2seqParameter_Direction_TOPDOWN;
static constexpr Direction BOTTOMUP =
Im2seqParameter_Direction_BOTTOMUP;
static inline bool Direction_IsValid(int value) {
return Im2seqParameter_Direction_IsValid(value);
}
static constexpr Direction Direction_MIN =
Im2seqParameter_Direction_Direction_MIN;
static constexpr Direction Direction_MAX =
Im2seqParameter_Direction_Direction_MAX;
static constexpr int Direction_ARRAYSIZE =
Im2seqParameter_Direction_Direction_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Direction_descriptor() {
return Im2seqParameter_Direction_descriptor();
}
template<typename T>
static inline const std::string& Direction_Name(T enum_t_value) {
static_assert(::std::is_same<T, Direction>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Direction_Name.");
return Im2seqParameter_Direction_Name(enum_t_value);
}
static inline bool Direction_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Direction* value) {
return Im2seqParameter_Direction_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kDirectionFieldNumber = 1,
kLine2TimeLossFieldNumber = 4,
kSizeFieldNumber = 2,
kStrideFieldNumber = 3,
};
// optional .caffe.Im2seqParameter.Direction direction = 1 [default = FORWARD];
bool has_direction() const;
private:
bool _internal_has_direction() const;
public:
void clear_direction();
::caffe::Im2seqParameter_Direction direction() const;
void set_direction(::caffe::Im2seqParameter_Direction value);
private:
::caffe::Im2seqParameter_Direction _internal_direction() const;
void _internal_set_direction(::caffe::Im2seqParameter_Direction value);
public:
// optional bool line2time_loss = 4 [default = false];
bool has_line2time_loss() const;
private:
bool _internal_has_line2time_loss() const;
public:
void clear_line2time_loss();
bool line2time_loss() const;
void set_line2time_loss(bool value);
private:
bool _internal_line2time_loss() const;
void _internal_set_line2time_loss(bool value);
public:
// optional uint32 size = 2 [default = 1];
bool has_size() const;
private:
bool _internal_has_size() const;
public:
void clear_size();
uint32_t size() const;
void set_size(uint32_t value);
private:
uint32_t _internal_size() const;
void _internal_set_size(uint32_t value);
public:
// optional uint32 stride = 3 [default = 1];
bool has_stride() const;
private:
bool _internal_has_stride() const;
public:
void clear_stride();
uint32_t stride() const;
void set_stride(uint32_t value);
private:
uint32_t _internal_stride() const;
void _internal_set_stride(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.Im2seqParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int direction_;
bool line2time_loss_;
uint32_t size_;
uint32_t stride_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class CenterLossParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.CenterLossParameter) */ {
public:
inline CenterLossParameter() : CenterLossParameter(nullptr) {}
~CenterLossParameter() override;
explicit constexpr CenterLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
CenterLossParameter(const CenterLossParameter& from);
CenterLossParameter(CenterLossParameter&& from) noexcept
: CenterLossParameter() {
*this = ::std::move(from);
}
inline CenterLossParameter& operator=(const CenterLossParameter& from) {
CopyFrom(from);
return *this;
}
inline CenterLossParameter& operator=(CenterLossParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const CenterLossParameter& default_instance() {
return *internal_default_instance();
}
static inline const CenterLossParameter* internal_default_instance() {
return reinterpret_cast<const CenterLossParameter*>(
&_CenterLossParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
29;
friend void swap(CenterLossParameter& a, CenterLossParameter& b) {
a.Swap(&b);
}
inline void Swap(CenterLossParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(CenterLossParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
CenterLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<CenterLossParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const CenterLossParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const CenterLossParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(CenterLossParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.CenterLossParameter";
}
protected:
explicit CenterLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDistanceTypeFieldNumber = 29,
kCenterFillerFieldNumber = 2,
kNumOutputFieldNumber = 1,
kAxisFieldNumber = 3,
};
// optional string distance_type = 29 [default = "L2"];
bool has_distance_type() const;
private:
bool _internal_has_distance_type() const;
public:
void clear_distance_type();
const std::string& distance_type() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_distance_type(ArgT0&& arg0, ArgT... args);
std::string* mutable_distance_type();
PROTOBUF_NODISCARD std::string* release_distance_type();
void set_allocated_distance_type(std::string* distance_type);
private:
const std::string& _internal_distance_type() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_distance_type(const std::string& value);
std::string* _internal_mutable_distance_type();
public:
// optional .caffe.FillerParameter center_filler = 2;
bool has_center_filler() const;
private:
bool _internal_has_center_filler() const;
public:
void clear_center_filler();
const ::caffe::FillerParameter& center_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_center_filler();
::caffe::FillerParameter* mutable_center_filler();
void set_allocated_center_filler(::caffe::FillerParameter* center_filler);
private:
const ::caffe::FillerParameter& _internal_center_filler() const;
::caffe::FillerParameter* _internal_mutable_center_filler();
public:
void unsafe_arena_set_allocated_center_filler(
::caffe::FillerParameter* center_filler);
::caffe::FillerParameter* unsafe_arena_release_center_filler();
// optional uint32 num_output = 1;
bool has_num_output() const;
private:
bool _internal_has_num_output() const;
public:
void clear_num_output();
uint32_t num_output() const;
void set_num_output(uint32_t value);
private:
uint32_t _internal_num_output() const;
void _internal_set_num_output(uint32_t value);
public:
// optional int32 axis = 3 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.CenterLossParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_distance_type_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr distance_type_;
::caffe::FillerParameter* center_filler_;
uint32_t num_output_;
int32_t axis_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class Seq2outParameter final :
public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:caffe.Seq2outParameter) */ {
public:
inline Seq2outParameter() : Seq2outParameter(nullptr) {}
explicit constexpr Seq2outParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Seq2outParameter(const Seq2outParameter& from);
Seq2outParameter(Seq2outParameter&& from) noexcept
: Seq2outParameter() {
*this = ::std::move(from);
}
inline Seq2outParameter& operator=(const Seq2outParameter& from) {
CopyFrom(from);
return *this;
}
inline Seq2outParameter& operator=(Seq2outParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Seq2outParameter& default_instance() {
return *internal_default_instance();
}
static inline const Seq2outParameter* internal_default_instance() {
return reinterpret_cast<const Seq2outParameter*>(
&_Seq2outParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
30;
friend void swap(Seq2outParameter& a, Seq2outParameter& b) {
a.Swap(&b);
}
inline void Swap(Seq2outParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Seq2outParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Seq2outParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Seq2outParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
inline void CopyFrom(const Seq2outParameter& from) {
::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
}
using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
void MergeFrom(const Seq2outParameter& from) {
::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
}
public:
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.Seq2outParameter";
}
protected:
explicit Seq2outParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// @@protoc_insertion_point(class_scope:caffe.Seq2outParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ImgSizeParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ImgSizeParameter) */ {
public:
inline ImgSizeParameter() : ImgSizeParameter(nullptr) {}
~ImgSizeParameter() override;
explicit constexpr ImgSizeParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ImgSizeParameter(const ImgSizeParameter& from);
ImgSizeParameter(ImgSizeParameter&& from) noexcept
: ImgSizeParameter() {
*this = ::std::move(from);
}
inline ImgSizeParameter& operator=(const ImgSizeParameter& from) {
CopyFrom(from);
return *this;
}
inline ImgSizeParameter& operator=(ImgSizeParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ImgSizeParameter& default_instance() {
return *internal_default_instance();
}
static inline const ImgSizeParameter* internal_default_instance() {
return reinterpret_cast<const ImgSizeParameter*>(
&_ImgSizeParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
31;
friend void swap(ImgSizeParameter& a, ImgSizeParameter& b) {
a.Swap(&b);
}
inline void Swap(ImgSizeParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ImgSizeParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ImgSizeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ImgSizeParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ImgSizeParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ImgSizeParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ImgSizeParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ImgSizeParameter";
}
protected:
explicit ImgSizeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kPretrainedFileFieldNumber = 500,
kPretrainedLayerNameFieldNumber = 501,
kPretrainedLayerBinFieldNumber = 502,
kXScalingFieldNumber = 1,
kYScalingFieldNumber = 2,
};
// optional string pretrained_file = 500;
bool has_pretrained_file() const;
private:
bool _internal_has_pretrained_file() const;
public:
void clear_pretrained_file();
const std::string& pretrained_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_pretrained_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_pretrained_file();
PROTOBUF_NODISCARD std::string* release_pretrained_file();
void set_allocated_pretrained_file(std::string* pretrained_file);
private:
const std::string& _internal_pretrained_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_pretrained_file(const std::string& value);
std::string* _internal_mutable_pretrained_file();
public:
// optional string pretrained_layer_name = 501;
bool has_pretrained_layer_name() const;
private:
bool _internal_has_pretrained_layer_name() const;
public:
void clear_pretrained_layer_name();
const std::string& pretrained_layer_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_pretrained_layer_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_pretrained_layer_name();
PROTOBUF_NODISCARD std::string* release_pretrained_layer_name();
void set_allocated_pretrained_layer_name(std::string* pretrained_layer_name);
private:
const std::string& _internal_pretrained_layer_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_pretrained_layer_name(const std::string& value);
std::string* _internal_mutable_pretrained_layer_name();
public:
// optional string pretrained_layer_bin = 502;
bool has_pretrained_layer_bin() const;
private:
bool _internal_has_pretrained_layer_bin() const;
public:
void clear_pretrained_layer_bin();
const std::string& pretrained_layer_bin() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_pretrained_layer_bin(ArgT0&& arg0, ArgT... args);
std::string* mutable_pretrained_layer_bin();
PROTOBUF_NODISCARD std::string* release_pretrained_layer_bin();
void set_allocated_pretrained_layer_bin(std::string* pretrained_layer_bin);
private:
const std::string& _internal_pretrained_layer_bin() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_pretrained_layer_bin(const std::string& value);
std::string* _internal_mutable_pretrained_layer_bin();
public:
// optional float x_scaling = 1 [default = 1];
bool has_x_scaling() const;
private:
bool _internal_has_x_scaling() const;
public:
void clear_x_scaling();
float x_scaling() const;
void set_x_scaling(float value);
private:
float _internal_x_scaling() const;
void _internal_set_x_scaling(float value);
public:
// optional float y_scaling = 2 [default = 1];
bool has_y_scaling() const;
private:
bool _internal_has_y_scaling() const;
public:
void clear_y_scaling();
float y_scaling() const;
void set_y_scaling(float value);
private:
float _internal_y_scaling() const;
void _internal_set_y_scaling(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ImgSizeParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pretrained_file_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pretrained_layer_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pretrained_layer_bin_;
float x_scaling_;
float y_scaling_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class TransformationParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.TransformationParameter) */ {
public:
inline TransformationParameter() : TransformationParameter(nullptr) {}
~TransformationParameter() override;
explicit constexpr TransformationParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TransformationParameter(const TransformationParameter& from);
TransformationParameter(TransformationParameter&& from) noexcept
: TransformationParameter() {
*this = ::std::move(from);
}
inline TransformationParameter& operator=(const TransformationParameter& from) {
CopyFrom(from);
return *this;
}
inline TransformationParameter& operator=(TransformationParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const TransformationParameter& default_instance() {
return *internal_default_instance();
}
static inline const TransformationParameter* internal_default_instance() {
return reinterpret_cast<const TransformationParameter*>(
&_TransformationParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
32;
friend void swap(TransformationParameter& a, TransformationParameter& b) {
a.Swap(&b);
}
inline void Swap(TransformationParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(TransformationParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TransformationParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TransformationParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const TransformationParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const TransformationParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(TransformationParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.TransformationParameter";
}
protected:
explicit TransformationParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMeanValueFieldNumber = 5,
kMeanFileFieldNumber = 4,
kResizeParamFieldNumber = 8,
kNoiseParamFieldNumber = 9,
kEmitConstraintFieldNumber = 10,
kDistortParamFieldNumber = 13,
kExpandParamFieldNumber = 14,
kCropSizeFieldNumber = 3,
kMirrorFieldNumber = 2,
kForceColorFieldNumber = 6,
kForceGrayFieldNumber = 7,
kCropHFieldNumber = 11,
kCropWFieldNumber = 12,
kScaleFieldNumber = 1,
};
// repeated float mean_value = 5;
int mean_value_size() const;
private:
int _internal_mean_value_size() const;
public:
void clear_mean_value();
private:
float _internal_mean_value(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_mean_value() const;
void _internal_add_mean_value(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_mean_value();
public:
float mean_value(int index) const;
void set_mean_value(int index, float value);
void add_mean_value(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
mean_value() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_mean_value();
// optional string mean_file = 4;
bool has_mean_file() const;
private:
bool _internal_has_mean_file() const;
public:
void clear_mean_file();
const std::string& mean_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_mean_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_mean_file();
PROTOBUF_NODISCARD std::string* release_mean_file();
void set_allocated_mean_file(std::string* mean_file);
private:
const std::string& _internal_mean_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value);
std::string* _internal_mutable_mean_file();
public:
// optional .caffe.ResizeParameter resize_param = 8;
bool has_resize_param() const;
private:
bool _internal_has_resize_param() const;
public:
void clear_resize_param();
const ::caffe::ResizeParameter& resize_param() const;
PROTOBUF_NODISCARD ::caffe::ResizeParameter* release_resize_param();
::caffe::ResizeParameter* mutable_resize_param();
void set_allocated_resize_param(::caffe::ResizeParameter* resize_param);
private:
const ::caffe::ResizeParameter& _internal_resize_param() const;
::caffe::ResizeParameter* _internal_mutable_resize_param();
public:
void unsafe_arena_set_allocated_resize_param(
::caffe::ResizeParameter* resize_param);
::caffe::ResizeParameter* unsafe_arena_release_resize_param();
// optional .caffe.NoiseParameter noise_param = 9;
bool has_noise_param() const;
private:
bool _internal_has_noise_param() const;
public:
void clear_noise_param();
const ::caffe::NoiseParameter& noise_param() const;
PROTOBUF_NODISCARD ::caffe::NoiseParameter* release_noise_param();
::caffe::NoiseParameter* mutable_noise_param();
void set_allocated_noise_param(::caffe::NoiseParameter* noise_param);
private:
const ::caffe::NoiseParameter& _internal_noise_param() const;
::caffe::NoiseParameter* _internal_mutable_noise_param();
public:
void unsafe_arena_set_allocated_noise_param(
::caffe::NoiseParameter* noise_param);
::caffe::NoiseParameter* unsafe_arena_release_noise_param();
// optional .caffe.EmitConstraint emit_constraint = 10;
bool has_emit_constraint() const;
private:
bool _internal_has_emit_constraint() const;
public:
void clear_emit_constraint();
const ::caffe::EmitConstraint& emit_constraint() const;
PROTOBUF_NODISCARD ::caffe::EmitConstraint* release_emit_constraint();
::caffe::EmitConstraint* mutable_emit_constraint();
void set_allocated_emit_constraint(::caffe::EmitConstraint* emit_constraint);
private:
const ::caffe::EmitConstraint& _internal_emit_constraint() const;
::caffe::EmitConstraint* _internal_mutable_emit_constraint();
public:
void unsafe_arena_set_allocated_emit_constraint(
::caffe::EmitConstraint* emit_constraint);
::caffe::EmitConstraint* unsafe_arena_release_emit_constraint();
// optional .caffe.DistortionParameter distort_param = 13;
bool has_distort_param() const;
private:
bool _internal_has_distort_param() const;
public:
void clear_distort_param();
const ::caffe::DistortionParameter& distort_param() const;
PROTOBUF_NODISCARD ::caffe::DistortionParameter* release_distort_param();
::caffe::DistortionParameter* mutable_distort_param();
void set_allocated_distort_param(::caffe::DistortionParameter* distort_param);
private:
const ::caffe::DistortionParameter& _internal_distort_param() const;
::caffe::DistortionParameter* _internal_mutable_distort_param();
public:
void unsafe_arena_set_allocated_distort_param(
::caffe::DistortionParameter* distort_param);
::caffe::DistortionParameter* unsafe_arena_release_distort_param();
// optional .caffe.ExpansionParameter expand_param = 14;
bool has_expand_param() const;
private:
bool _internal_has_expand_param() const;
public:
void clear_expand_param();
const ::caffe::ExpansionParameter& expand_param() const;
PROTOBUF_NODISCARD ::caffe::ExpansionParameter* release_expand_param();
::caffe::ExpansionParameter* mutable_expand_param();
void set_allocated_expand_param(::caffe::ExpansionParameter* expand_param);
private:
const ::caffe::ExpansionParameter& _internal_expand_param() const;
::caffe::ExpansionParameter* _internal_mutable_expand_param();
public:
void unsafe_arena_set_allocated_expand_param(
::caffe::ExpansionParameter* expand_param);
::caffe::ExpansionParameter* unsafe_arena_release_expand_param();
// optional uint32 crop_size = 3 [default = 0];
bool has_crop_size() const;
private:
bool _internal_has_crop_size() const;
public:
void clear_crop_size();
uint32_t crop_size() const;
void set_crop_size(uint32_t value);
private:
uint32_t _internal_crop_size() const;
void _internal_set_crop_size(uint32_t value);
public:
// optional bool mirror = 2 [default = false];
bool has_mirror() const;
private:
bool _internal_has_mirror() const;
public:
void clear_mirror();
bool mirror() const;
void set_mirror(bool value);
private:
bool _internal_mirror() const;
void _internal_set_mirror(bool value);
public:
// optional bool force_color = 6 [default = false];
bool has_force_color() const;
private:
bool _internal_has_force_color() const;
public:
void clear_force_color();
bool force_color() const;
void set_force_color(bool value);
private:
bool _internal_force_color() const;
void _internal_set_force_color(bool value);
public:
// optional bool force_gray = 7 [default = false];
bool has_force_gray() const;
private:
bool _internal_has_force_gray() const;
public:
void clear_force_gray();
bool force_gray() const;
void set_force_gray(bool value);
private:
bool _internal_force_gray() const;
void _internal_set_force_gray(bool value);
public:
// optional uint32 crop_h = 11 [default = 0];
bool has_crop_h() const;
private:
bool _internal_has_crop_h() const;
public:
void clear_crop_h();
uint32_t crop_h() const;
void set_crop_h(uint32_t value);
private:
uint32_t _internal_crop_h() const;
void _internal_set_crop_h(uint32_t value);
public:
// optional uint32 crop_w = 12 [default = 0];
bool has_crop_w() const;
private:
bool _internal_has_crop_w() const;
public:
void clear_crop_w();
uint32_t crop_w() const;
void set_crop_w(uint32_t value);
private:
uint32_t _internal_crop_w() const;
void _internal_set_crop_w(uint32_t value);
public:
// optional float scale = 1 [default = 1];
bool has_scale() const;
private:
bool _internal_has_scale() const;
public:
void clear_scale();
float scale() const;
void set_scale(float value);
private:
float _internal_scale() const;
void _internal_set_scale(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.TransformationParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > mean_value_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_;
::caffe::ResizeParameter* resize_param_;
::caffe::NoiseParameter* noise_param_;
::caffe::EmitConstraint* emit_constraint_;
::caffe::DistortionParameter* distort_param_;
::caffe::ExpansionParameter* expand_param_;
uint32_t crop_size_;
bool mirror_;
bool force_color_;
bool force_gray_;
uint32_t crop_h_;
uint32_t crop_w_;
float scale_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ResizeParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ResizeParameter) */ {
public:
inline ResizeParameter() : ResizeParameter(nullptr) {}
~ResizeParameter() override;
explicit constexpr ResizeParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ResizeParameter(const ResizeParameter& from);
ResizeParameter(ResizeParameter&& from) noexcept
: ResizeParameter() {
*this = ::std::move(from);
}
inline ResizeParameter& operator=(const ResizeParameter& from) {
CopyFrom(from);
return *this;
}
inline ResizeParameter& operator=(ResizeParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ResizeParameter& default_instance() {
return *internal_default_instance();
}
static inline const ResizeParameter* internal_default_instance() {
return reinterpret_cast<const ResizeParameter*>(
&_ResizeParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
33;
friend void swap(ResizeParameter& a, ResizeParameter& b) {
a.Swap(&b);
}
inline void Swap(ResizeParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ResizeParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ResizeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ResizeParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ResizeParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ResizeParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ResizeParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ResizeParameter";
}
protected:
explicit ResizeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef ResizeParameter_Resize_mode Resize_mode;
static constexpr Resize_mode WARP =
ResizeParameter_Resize_mode_WARP;
static constexpr Resize_mode FIT_SMALL_SIZE =
ResizeParameter_Resize_mode_FIT_SMALL_SIZE;
static constexpr Resize_mode FIT_LARGE_SIZE_AND_PAD =
ResizeParameter_Resize_mode_FIT_LARGE_SIZE_AND_PAD;
static inline bool Resize_mode_IsValid(int value) {
return ResizeParameter_Resize_mode_IsValid(value);
}
static constexpr Resize_mode Resize_mode_MIN =
ResizeParameter_Resize_mode_Resize_mode_MIN;
static constexpr Resize_mode Resize_mode_MAX =
ResizeParameter_Resize_mode_Resize_mode_MAX;
static constexpr int Resize_mode_ARRAYSIZE =
ResizeParameter_Resize_mode_Resize_mode_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Resize_mode_descriptor() {
return ResizeParameter_Resize_mode_descriptor();
}
template<typename T>
static inline const std::string& Resize_mode_Name(T enum_t_value) {
static_assert(::std::is_same<T, Resize_mode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Resize_mode_Name.");
return ResizeParameter_Resize_mode_Name(enum_t_value);
}
static inline bool Resize_mode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Resize_mode* value) {
return ResizeParameter_Resize_mode_Parse(name, value);
}
typedef ResizeParameter_Pad_mode Pad_mode;
static constexpr Pad_mode CONSTANT =
ResizeParameter_Pad_mode_CONSTANT;
static constexpr Pad_mode MIRRORED =
ResizeParameter_Pad_mode_MIRRORED;
static constexpr Pad_mode REPEAT_NEAREST =
ResizeParameter_Pad_mode_REPEAT_NEAREST;
static inline bool Pad_mode_IsValid(int value) {
return ResizeParameter_Pad_mode_IsValid(value);
}
static constexpr Pad_mode Pad_mode_MIN =
ResizeParameter_Pad_mode_Pad_mode_MIN;
static constexpr Pad_mode Pad_mode_MAX =
ResizeParameter_Pad_mode_Pad_mode_MAX;
static constexpr int Pad_mode_ARRAYSIZE =
ResizeParameter_Pad_mode_Pad_mode_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Pad_mode_descriptor() {
return ResizeParameter_Pad_mode_descriptor();
}
template<typename T>
static inline const std::string& Pad_mode_Name(T enum_t_value) {
static_assert(::std::is_same<T, Pad_mode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Pad_mode_Name.");
return ResizeParameter_Pad_mode_Name(enum_t_value);
}
static inline bool Pad_mode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Pad_mode* value) {
return ResizeParameter_Pad_mode_Parse(name, value);
}
typedef ResizeParameter_Interp_mode Interp_mode;
static constexpr Interp_mode LINEAR =
ResizeParameter_Interp_mode_LINEAR;
static constexpr Interp_mode AREA =
ResizeParameter_Interp_mode_AREA;
static constexpr Interp_mode NEAREST =
ResizeParameter_Interp_mode_NEAREST;
static constexpr Interp_mode CUBIC =
ResizeParameter_Interp_mode_CUBIC;
static constexpr Interp_mode LANCZOS4 =
ResizeParameter_Interp_mode_LANCZOS4;
static inline bool Interp_mode_IsValid(int value) {
return ResizeParameter_Interp_mode_IsValid(value);
}
static constexpr Interp_mode Interp_mode_MIN =
ResizeParameter_Interp_mode_Interp_mode_MIN;
static constexpr Interp_mode Interp_mode_MAX =
ResizeParameter_Interp_mode_Interp_mode_MAX;
static constexpr int Interp_mode_ARRAYSIZE =
ResizeParameter_Interp_mode_Interp_mode_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Interp_mode_descriptor() {
return ResizeParameter_Interp_mode_descriptor();
}
template<typename T>
static inline const std::string& Interp_mode_Name(T enum_t_value) {
static_assert(::std::is_same<T, Interp_mode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Interp_mode_Name.");
return ResizeParameter_Interp_mode_Name(enum_t_value);
}
static inline bool Interp_mode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Interp_mode* value) {
return ResizeParameter_Interp_mode_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kPadValueFieldNumber = 6,
kInterpModeFieldNumber = 7,
kHeightFieldNumber = 3,
kWidthFieldNumber = 4,
kHeightScaleFieldNumber = 8,
kWidthScaleFieldNumber = 9,
kPadModeFieldNumber = 5,
kProbFieldNumber = 1,
kResizeModeFieldNumber = 2,
};
// repeated float pad_value = 6;
int pad_value_size() const;
private:
int _internal_pad_value_size() const;
public:
void clear_pad_value();
private:
float _internal_pad_value(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_pad_value() const;
void _internal_add_pad_value(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_pad_value();
public:
float pad_value(int index) const;
void set_pad_value(int index, float value);
void add_pad_value(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
pad_value() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_pad_value();
// repeated .caffe.ResizeParameter.Interp_mode interp_mode = 7;
int interp_mode_size() const;
private:
int _internal_interp_mode_size() const;
public:
void clear_interp_mode();
private:
::caffe::ResizeParameter_Interp_mode _internal_interp_mode(int index) const;
void _internal_add_interp_mode(::caffe::ResizeParameter_Interp_mode value);
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_interp_mode();
public:
::caffe::ResizeParameter_Interp_mode interp_mode(int index) const;
void set_interp_mode(int index, ::caffe::ResizeParameter_Interp_mode value);
void add_interp_mode(::caffe::ResizeParameter_Interp_mode value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& interp_mode() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_interp_mode();
// optional uint32 height = 3 [default = 0];
bool has_height() const;
private:
bool _internal_has_height() const;
public:
void clear_height();
uint32_t height() const;
void set_height(uint32_t value);
private:
uint32_t _internal_height() const;
void _internal_set_height(uint32_t value);
public:
// optional uint32 width = 4 [default = 0];
bool has_width() const;
private:
bool _internal_has_width() const;
public:
void clear_width();
uint32_t width() const;
void set_width(uint32_t value);
private:
uint32_t _internal_width() const;
void _internal_set_width(uint32_t value);
public:
// optional uint32 height_scale = 8 [default = 0];
bool has_height_scale() const;
private:
bool _internal_has_height_scale() const;
public:
void clear_height_scale();
uint32_t height_scale() const;
void set_height_scale(uint32_t value);
private:
uint32_t _internal_height_scale() const;
void _internal_set_height_scale(uint32_t value);
public:
// optional uint32 width_scale = 9 [default = 0];
bool has_width_scale() const;
private:
bool _internal_has_width_scale() const;
public:
void clear_width_scale();
uint32_t width_scale() const;
void set_width_scale(uint32_t value);
private:
uint32_t _internal_width_scale() const;
void _internal_set_width_scale(uint32_t value);
public:
// optional .caffe.ResizeParameter.Pad_mode pad_mode = 5 [default = CONSTANT];
bool has_pad_mode() const;
private:
bool _internal_has_pad_mode() const;
public:
void clear_pad_mode();
::caffe::ResizeParameter_Pad_mode pad_mode() const;
void set_pad_mode(::caffe::ResizeParameter_Pad_mode value);
private:
::caffe::ResizeParameter_Pad_mode _internal_pad_mode() const;
void _internal_set_pad_mode(::caffe::ResizeParameter_Pad_mode value);
public:
// optional float prob = 1 [default = 1];
bool has_prob() const;
private:
bool _internal_has_prob() const;
public:
void clear_prob();
float prob() const;
void set_prob(float value);
private:
float _internal_prob() const;
void _internal_set_prob(float value);
public:
// optional .caffe.ResizeParameter.Resize_mode resize_mode = 2 [default = WARP];
bool has_resize_mode() const;
private:
bool _internal_has_resize_mode() const;
public:
void clear_resize_mode();
::caffe::ResizeParameter_Resize_mode resize_mode() const;
void set_resize_mode(::caffe::ResizeParameter_Resize_mode value);
private:
::caffe::ResizeParameter_Resize_mode _internal_resize_mode() const;
void _internal_set_resize_mode(::caffe::ResizeParameter_Resize_mode value);
public:
// @@protoc_insertion_point(class_scope:caffe.ResizeParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > pad_value_;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int> interp_mode_;
uint32_t height_;
uint32_t width_;
uint32_t height_scale_;
uint32_t width_scale_;
int pad_mode_;
float prob_;
int resize_mode_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class SaltPepperParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.SaltPepperParameter) */ {
public:
inline SaltPepperParameter() : SaltPepperParameter(nullptr) {}
~SaltPepperParameter() override;
explicit constexpr SaltPepperParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SaltPepperParameter(const SaltPepperParameter& from);
SaltPepperParameter(SaltPepperParameter&& from) noexcept
: SaltPepperParameter() {
*this = ::std::move(from);
}
inline SaltPepperParameter& operator=(const SaltPepperParameter& from) {
CopyFrom(from);
return *this;
}
inline SaltPepperParameter& operator=(SaltPepperParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SaltPepperParameter& default_instance() {
return *internal_default_instance();
}
static inline const SaltPepperParameter* internal_default_instance() {
return reinterpret_cast<const SaltPepperParameter*>(
&_SaltPepperParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
34;
friend void swap(SaltPepperParameter& a, SaltPepperParameter& b) {
a.Swap(&b);
}
inline void Swap(SaltPepperParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SaltPepperParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SaltPepperParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SaltPepperParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SaltPepperParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const SaltPepperParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SaltPepperParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.SaltPepperParameter";
}
protected:
explicit SaltPepperParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kValueFieldNumber = 2,
kFractionFieldNumber = 1,
};
// repeated float value = 2;
int value_size() const;
private:
int _internal_value_size() const;
public:
void clear_value();
private:
float _internal_value(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_value() const;
void _internal_add_value(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_value();
public:
float value(int index) const;
void set_value(int index, float value);
void add_value(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
value() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_value();
// optional float fraction = 1 [default = 0];
bool has_fraction() const;
private:
bool _internal_has_fraction() const;
public:
void clear_fraction();
float fraction() const;
void set_fraction(float value);
private:
float _internal_fraction() const;
void _internal_set_fraction(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.SaltPepperParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > value_;
float fraction_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class NoiseParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.NoiseParameter) */ {
public:
inline NoiseParameter() : NoiseParameter(nullptr) {}
~NoiseParameter() override;
explicit constexpr NoiseParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NoiseParameter(const NoiseParameter& from);
NoiseParameter(NoiseParameter&& from) noexcept
: NoiseParameter() {
*this = ::std::move(from);
}
inline NoiseParameter& operator=(const NoiseParameter& from) {
CopyFrom(from);
return *this;
}
inline NoiseParameter& operator=(NoiseParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const NoiseParameter& default_instance() {
return *internal_default_instance();
}
static inline const NoiseParameter* internal_default_instance() {
return reinterpret_cast<const NoiseParameter*>(
&_NoiseParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
35;
friend void swap(NoiseParameter& a, NoiseParameter& b) {
a.Swap(&b);
}
inline void Swap(NoiseParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(NoiseParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NoiseParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NoiseParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const NoiseParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const NoiseParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(NoiseParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.NoiseParameter";
}
protected:
explicit NoiseParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSaltpepperParamFieldNumber = 10,
kProbFieldNumber = 1,
kHistEqFieldNumber = 2,
kInverseFieldNumber = 3,
kDecolorizeFieldNumber = 4,
kGaussBlurFieldNumber = 5,
kPosterizeFieldNumber = 7,
kErodeFieldNumber = 8,
kSaltpepperFieldNumber = 9,
kClaheFieldNumber = 11,
kConvertToHsvFieldNumber = 12,
kConvertToLabFieldNumber = 13,
kJpegFieldNumber = 6,
};
// optional .caffe.SaltPepperParameter saltpepper_param = 10;
bool has_saltpepper_param() const;
private:
bool _internal_has_saltpepper_param() const;
public:
void clear_saltpepper_param();
const ::caffe::SaltPepperParameter& saltpepper_param() const;
PROTOBUF_NODISCARD ::caffe::SaltPepperParameter* release_saltpepper_param();
::caffe::SaltPepperParameter* mutable_saltpepper_param();
void set_allocated_saltpepper_param(::caffe::SaltPepperParameter* saltpepper_param);
private:
const ::caffe::SaltPepperParameter& _internal_saltpepper_param() const;
::caffe::SaltPepperParameter* _internal_mutable_saltpepper_param();
public:
void unsafe_arena_set_allocated_saltpepper_param(
::caffe::SaltPepperParameter* saltpepper_param);
::caffe::SaltPepperParameter* unsafe_arena_release_saltpepper_param();
// optional float prob = 1 [default = 0];
bool has_prob() const;
private:
bool _internal_has_prob() const;
public:
void clear_prob();
float prob() const;
void set_prob(float value);
private:
float _internal_prob() const;
void _internal_set_prob(float value);
public:
// optional bool hist_eq = 2 [default = false];
bool has_hist_eq() const;
private:
bool _internal_has_hist_eq() const;
public:
void clear_hist_eq();
bool hist_eq() const;
void set_hist_eq(bool value);
private:
bool _internal_hist_eq() const;
void _internal_set_hist_eq(bool value);
public:
// optional bool inverse = 3 [default = false];
bool has_inverse() const;
private:
bool _internal_has_inverse() const;
public:
void clear_inverse();
bool inverse() const;
void set_inverse(bool value);
private:
bool _internal_inverse() const;
void _internal_set_inverse(bool value);
public:
// optional bool decolorize = 4 [default = false];
bool has_decolorize() const;
private:
bool _internal_has_decolorize() const;
public:
void clear_decolorize();
bool decolorize() const;
void set_decolorize(bool value);
private:
bool _internal_decolorize() const;
void _internal_set_decolorize(bool value);
public:
// optional bool gauss_blur = 5 [default = false];
bool has_gauss_blur() const;
private:
bool _internal_has_gauss_blur() const;
public:
void clear_gauss_blur();
bool gauss_blur() const;
void set_gauss_blur(bool value);
private:
bool _internal_gauss_blur() const;
void _internal_set_gauss_blur(bool value);
public:
// optional bool posterize = 7 [default = false];
bool has_posterize() const;
private:
bool _internal_has_posterize() const;
public:
void clear_posterize();
bool posterize() const;
void set_posterize(bool value);
private:
bool _internal_posterize() const;
void _internal_set_posterize(bool value);
public:
// optional bool erode = 8 [default = false];
bool has_erode() const;
private:
bool _internal_has_erode() const;
public:
void clear_erode();
bool erode() const;
void set_erode(bool value);
private:
bool _internal_erode() const;
void _internal_set_erode(bool value);
public:
// optional bool saltpepper = 9 [default = false];
bool has_saltpepper() const;
private:
bool _internal_has_saltpepper() const;
public:
void clear_saltpepper();
bool saltpepper() const;
void set_saltpepper(bool value);
private:
bool _internal_saltpepper() const;
void _internal_set_saltpepper(bool value);
public:
// optional bool clahe = 11 [default = false];
bool has_clahe() const;
private:
bool _internal_has_clahe() const;
public:
void clear_clahe();
bool clahe() const;
void set_clahe(bool value);
private:
bool _internal_clahe() const;
void _internal_set_clahe(bool value);
public:
// optional bool convert_to_hsv = 12 [default = false];
bool has_convert_to_hsv() const;
private:
bool _internal_has_convert_to_hsv() const;
public:
void clear_convert_to_hsv();
bool convert_to_hsv() const;
void set_convert_to_hsv(bool value);
private:
bool _internal_convert_to_hsv() const;
void _internal_set_convert_to_hsv(bool value);
public:
// optional bool convert_to_lab = 13 [default = false];
bool has_convert_to_lab() const;
private:
bool _internal_has_convert_to_lab() const;
public:
void clear_convert_to_lab();
bool convert_to_lab() const;
void set_convert_to_lab(bool value);
private:
bool _internal_convert_to_lab() const;
void _internal_set_convert_to_lab(bool value);
public:
// optional float jpeg = 6 [default = -1];
bool has_jpeg() const;
private:
bool _internal_has_jpeg() const;
public:
void clear_jpeg();
float jpeg() const;
void set_jpeg(float value);
private:
float _internal_jpeg() const;
void _internal_set_jpeg(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.NoiseParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::SaltPepperParameter* saltpepper_param_;
float prob_;
bool hist_eq_;
bool inverse_;
bool decolorize_;
bool gauss_blur_;
bool posterize_;
bool erode_;
bool saltpepper_;
bool clahe_;
bool convert_to_hsv_;
bool convert_to_lab_;
float jpeg_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class DistortionParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.DistortionParameter) */ {
public:
inline DistortionParameter() : DistortionParameter(nullptr) {}
~DistortionParameter() override;
explicit constexpr DistortionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DistortionParameter(const DistortionParameter& from);
DistortionParameter(DistortionParameter&& from) noexcept
: DistortionParameter() {
*this = ::std::move(from);
}
inline DistortionParameter& operator=(const DistortionParameter& from) {
CopyFrom(from);
return *this;
}
inline DistortionParameter& operator=(DistortionParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const DistortionParameter& default_instance() {
return *internal_default_instance();
}
static inline const DistortionParameter* internal_default_instance() {
return reinterpret_cast<const DistortionParameter*>(
&_DistortionParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
36;
friend void swap(DistortionParameter& a, DistortionParameter& b) {
a.Swap(&b);
}
inline void Swap(DistortionParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DistortionParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DistortionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DistortionParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const DistortionParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const DistortionParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DistortionParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.DistortionParameter";
}
protected:
explicit DistortionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBrightnessProbFieldNumber = 1,
kBrightnessDeltaFieldNumber = 2,
kContrastProbFieldNumber = 3,
kContrastLowerFieldNumber = 4,
kContrastUpperFieldNumber = 5,
kHueProbFieldNumber = 6,
kHueDeltaFieldNumber = 7,
kSaturationProbFieldNumber = 8,
kSaturationLowerFieldNumber = 9,
kSaturationUpperFieldNumber = 10,
kRandomOrderProbFieldNumber = 11,
};
// optional float brightness_prob = 1 [default = 0];
bool has_brightness_prob() const;
private:
bool _internal_has_brightness_prob() const;
public:
void clear_brightness_prob();
float brightness_prob() const;
void set_brightness_prob(float value);
private:
float _internal_brightness_prob() const;
void _internal_set_brightness_prob(float value);
public:
// optional float brightness_delta = 2 [default = 0];
bool has_brightness_delta() const;
private:
bool _internal_has_brightness_delta() const;
public:
void clear_brightness_delta();
float brightness_delta() const;
void set_brightness_delta(float value);
private:
float _internal_brightness_delta() const;
void _internal_set_brightness_delta(float value);
public:
// optional float contrast_prob = 3 [default = 0];
bool has_contrast_prob() const;
private:
bool _internal_has_contrast_prob() const;
public:
void clear_contrast_prob();
float contrast_prob() const;
void set_contrast_prob(float value);
private:
float _internal_contrast_prob() const;
void _internal_set_contrast_prob(float value);
public:
// optional float contrast_lower = 4 [default = 0];
bool has_contrast_lower() const;
private:
bool _internal_has_contrast_lower() const;
public:
void clear_contrast_lower();
float contrast_lower() const;
void set_contrast_lower(float value);
private:
float _internal_contrast_lower() const;
void _internal_set_contrast_lower(float value);
public:
// optional float contrast_upper = 5 [default = 0];
bool has_contrast_upper() const;
private:
bool _internal_has_contrast_upper() const;
public:
void clear_contrast_upper();
float contrast_upper() const;
void set_contrast_upper(float value);
private:
float _internal_contrast_upper() const;
void _internal_set_contrast_upper(float value);
public:
// optional float hue_prob = 6 [default = 0];
bool has_hue_prob() const;
private:
bool _internal_has_hue_prob() const;
public:
void clear_hue_prob();
float hue_prob() const;
void set_hue_prob(float value);
private:
float _internal_hue_prob() const;
void _internal_set_hue_prob(float value);
public:
// optional float hue_delta = 7 [default = 0];
bool has_hue_delta() const;
private:
bool _internal_has_hue_delta() const;
public:
void clear_hue_delta();
float hue_delta() const;
void set_hue_delta(float value);
private:
float _internal_hue_delta() const;
void _internal_set_hue_delta(float value);
public:
// optional float saturation_prob = 8 [default = 0];
bool has_saturation_prob() const;
private:
bool _internal_has_saturation_prob() const;
public:
void clear_saturation_prob();
float saturation_prob() const;
void set_saturation_prob(float value);
private:
float _internal_saturation_prob() const;
void _internal_set_saturation_prob(float value);
public:
// optional float saturation_lower = 9 [default = 0];
bool has_saturation_lower() const;
private:
bool _internal_has_saturation_lower() const;
public:
void clear_saturation_lower();
float saturation_lower() const;
void set_saturation_lower(float value);
private:
float _internal_saturation_lower() const;
void _internal_set_saturation_lower(float value);
public:
// optional float saturation_upper = 10 [default = 0];
bool has_saturation_upper() const;
private:
bool _internal_has_saturation_upper() const;
public:
void clear_saturation_upper();
float saturation_upper() const;
void set_saturation_upper(float value);
private:
float _internal_saturation_upper() const;
void _internal_set_saturation_upper(float value);
public:
// optional float random_order_prob = 11 [default = 0];
bool has_random_order_prob() const;
private:
bool _internal_has_random_order_prob() const;
public:
void clear_random_order_prob();
float random_order_prob() const;
void set_random_order_prob(float value);
private:
float _internal_random_order_prob() const;
void _internal_set_random_order_prob(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.DistortionParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float brightness_prob_;
float brightness_delta_;
float contrast_prob_;
float contrast_lower_;
float contrast_upper_;
float hue_prob_;
float hue_delta_;
float saturation_prob_;
float saturation_lower_;
float saturation_upper_;
float random_order_prob_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ExpansionParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ExpansionParameter) */ {
public:
inline ExpansionParameter() : ExpansionParameter(nullptr) {}
~ExpansionParameter() override;
explicit constexpr ExpansionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ExpansionParameter(const ExpansionParameter& from);
ExpansionParameter(ExpansionParameter&& from) noexcept
: ExpansionParameter() {
*this = ::std::move(from);
}
inline ExpansionParameter& operator=(const ExpansionParameter& from) {
CopyFrom(from);
return *this;
}
inline ExpansionParameter& operator=(ExpansionParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ExpansionParameter& default_instance() {
return *internal_default_instance();
}
static inline const ExpansionParameter* internal_default_instance() {
return reinterpret_cast<const ExpansionParameter*>(
&_ExpansionParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
37;
friend void swap(ExpansionParameter& a, ExpansionParameter& b) {
a.Swap(&b);
}
inline void Swap(ExpansionParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ExpansionParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ExpansionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ExpansionParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ExpansionParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ExpansionParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ExpansionParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ExpansionParameter";
}
protected:
explicit ExpansionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kProbFieldNumber = 1,
kMaxExpandRatioFieldNumber = 2,
};
// optional float prob = 1 [default = 1];
bool has_prob() const;
private:
bool _internal_has_prob() const;
public:
void clear_prob();
float prob() const;
void set_prob(float value);
private:
float _internal_prob() const;
void _internal_set_prob(float value);
public:
// optional float max_expand_ratio = 2 [default = 1];
bool has_max_expand_ratio() const;
private:
bool _internal_has_max_expand_ratio() const;
public:
void clear_max_expand_ratio();
float max_expand_ratio() const;
void set_max_expand_ratio(float value);
private:
float _internal_max_expand_ratio() const;
void _internal_set_max_expand_ratio(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ExpansionParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float prob_;
float max_expand_ratio_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class LossParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.LossParameter) */ {
public:
inline LossParameter() : LossParameter(nullptr) {}
~LossParameter() override;
explicit constexpr LossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
LossParameter(const LossParameter& from);
LossParameter(LossParameter&& from) noexcept
: LossParameter() {
*this = ::std::move(from);
}
inline LossParameter& operator=(const LossParameter& from) {
CopyFrom(from);
return *this;
}
inline LossParameter& operator=(LossParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const LossParameter& default_instance() {
return *internal_default_instance();
}
static inline const LossParameter* internal_default_instance() {
return reinterpret_cast<const LossParameter*>(
&_LossParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
38;
friend void swap(LossParameter& a, LossParameter& b) {
a.Swap(&b);
}
inline void Swap(LossParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(LossParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
LossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<LossParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const LossParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const LossParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(LossParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.LossParameter";
}
protected:
explicit LossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef LossParameter_NormalizationMode NormalizationMode;
static constexpr NormalizationMode FULL =
LossParameter_NormalizationMode_FULL;
static constexpr NormalizationMode VALID =
LossParameter_NormalizationMode_VALID;
static constexpr NormalizationMode BATCH_SIZE =
LossParameter_NormalizationMode_BATCH_SIZE;
static constexpr NormalizationMode NONE =
LossParameter_NormalizationMode_NONE;
static inline bool NormalizationMode_IsValid(int value) {
return LossParameter_NormalizationMode_IsValid(value);
}
static constexpr NormalizationMode NormalizationMode_MIN =
LossParameter_NormalizationMode_NormalizationMode_MIN;
static constexpr NormalizationMode NormalizationMode_MAX =
LossParameter_NormalizationMode_NormalizationMode_MAX;
static constexpr int NormalizationMode_ARRAYSIZE =
LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
NormalizationMode_descriptor() {
return LossParameter_NormalizationMode_descriptor();
}
template<typename T>
static inline const std::string& NormalizationMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, NormalizationMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function NormalizationMode_Name.");
return LossParameter_NormalizationMode_Name(enum_t_value);
}
static inline bool NormalizationMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
NormalizationMode* value) {
return LossParameter_NormalizationMode_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kIgnoreLabelFieldNumber = 1,
kNormalizeFieldNumber = 2,
kNormalizationFieldNumber = 3,
kIsNumScaleFieldNumber = 4,
};
// optional int32 ignore_label = 1;
bool has_ignore_label() const;
private:
bool _internal_has_ignore_label() const;
public:
void clear_ignore_label();
int32_t ignore_label() const;
void set_ignore_label(int32_t value);
private:
int32_t _internal_ignore_label() const;
void _internal_set_ignore_label(int32_t value);
public:
// optional bool normalize = 2;
bool has_normalize() const;
private:
bool _internal_has_normalize() const;
public:
void clear_normalize();
bool normalize() const;
void set_normalize(bool value);
private:
bool _internal_normalize() const;
void _internal_set_normalize(bool value);
public:
// optional .caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
bool has_normalization() const;
private:
bool _internal_has_normalization() const;
public:
void clear_normalization();
::caffe::LossParameter_NormalizationMode normalization() const;
void set_normalization(::caffe::LossParameter_NormalizationMode value);
private:
::caffe::LossParameter_NormalizationMode _internal_normalization() const;
void _internal_set_normalization(::caffe::LossParameter_NormalizationMode value);
public:
// optional bool is_num_scale = 4 [default = true];
bool has_is_num_scale() const;
private:
bool _internal_has_is_num_scale() const;
public:
void clear_is_num_scale();
bool is_num_scale() const;
void set_is_num_scale(bool value);
private:
bool _internal_is_num_scale() const;
void _internal_set_is_num_scale(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.LossParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int32_t ignore_label_;
bool normalize_;
int normalization_;
bool is_num_scale_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class AccuracyParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.AccuracyParameter) */ {
public:
inline AccuracyParameter() : AccuracyParameter(nullptr) {}
~AccuracyParameter() override;
explicit constexpr AccuracyParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AccuracyParameter(const AccuracyParameter& from);
AccuracyParameter(AccuracyParameter&& from) noexcept
: AccuracyParameter() {
*this = ::std::move(from);
}
inline AccuracyParameter& operator=(const AccuracyParameter& from) {
CopyFrom(from);
return *this;
}
inline AccuracyParameter& operator=(AccuracyParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AccuracyParameter& default_instance() {
return *internal_default_instance();
}
static inline const AccuracyParameter* internal_default_instance() {
return reinterpret_cast<const AccuracyParameter*>(
&_AccuracyParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
39;
friend void swap(AccuracyParameter& a, AccuracyParameter& b) {
a.Swap(&b);
}
inline void Swap(AccuracyParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AccuracyParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AccuracyParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AccuracyParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AccuracyParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const AccuracyParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AccuracyParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.AccuracyParameter";
}
protected:
explicit AccuracyParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kIgnoreLabelFieldNumber = 3,
kTopKFieldNumber = 1,
kAxisFieldNumber = 2,
};
// optional int32 ignore_label = 3;
bool has_ignore_label() const;
private:
bool _internal_has_ignore_label() const;
public:
void clear_ignore_label();
int32_t ignore_label() const;
void set_ignore_label(int32_t value);
private:
int32_t _internal_ignore_label() const;
void _internal_set_ignore_label(int32_t value);
public:
// optional uint32 top_k = 1 [default = 1];
bool has_top_k() const;
private:
bool _internal_has_top_k() const;
public:
void clear_top_k();
uint32_t top_k() const;
void set_top_k(uint32_t value);
private:
uint32_t _internal_top_k() const;
void _internal_set_top_k(uint32_t value);
public:
// optional int32 axis = 2 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.AccuracyParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int32_t ignore_label_;
uint32_t top_k_;
int32_t axis_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class AnnotatedDataParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.AnnotatedDataParameter) */ {
public:
inline AnnotatedDataParameter() : AnnotatedDataParameter(nullptr) {}
~AnnotatedDataParameter() override;
explicit constexpr AnnotatedDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AnnotatedDataParameter(const AnnotatedDataParameter& from);
AnnotatedDataParameter(AnnotatedDataParameter&& from) noexcept
: AnnotatedDataParameter() {
*this = ::std::move(from);
}
inline AnnotatedDataParameter& operator=(const AnnotatedDataParameter& from) {
CopyFrom(from);
return *this;
}
inline AnnotatedDataParameter& operator=(AnnotatedDataParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const AnnotatedDataParameter& default_instance() {
return *internal_default_instance();
}
static inline const AnnotatedDataParameter* internal_default_instance() {
return reinterpret_cast<const AnnotatedDataParameter*>(
&_AnnotatedDataParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
40;
friend void swap(AnnotatedDataParameter& a, AnnotatedDataParameter& b) {
a.Swap(&b);
}
inline void Swap(AnnotatedDataParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(AnnotatedDataParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AnnotatedDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AnnotatedDataParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const AnnotatedDataParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const AnnotatedDataParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(AnnotatedDataParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.AnnotatedDataParameter";
}
protected:
explicit AnnotatedDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBatchSamplerFieldNumber = 1,
kLabelMapFileFieldNumber = 2,
kAnnoTypeFieldNumber = 3,
};
// repeated .caffe.BatchSampler batch_sampler = 1;
int batch_sampler_size() const;
private:
int _internal_batch_sampler_size() const;
public:
void clear_batch_sampler();
::caffe::BatchSampler* mutable_batch_sampler(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BatchSampler >*
mutable_batch_sampler();
private:
const ::caffe::BatchSampler& _internal_batch_sampler(int index) const;
::caffe::BatchSampler* _internal_add_batch_sampler();
public:
const ::caffe::BatchSampler& batch_sampler(int index) const;
::caffe::BatchSampler* add_batch_sampler();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BatchSampler >&
batch_sampler() const;
// optional string label_map_file = 2;
bool has_label_map_file() const;
private:
bool _internal_has_label_map_file() const;
public:
void clear_label_map_file();
const std::string& label_map_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_label_map_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_label_map_file();
PROTOBUF_NODISCARD std::string* release_label_map_file();
void set_allocated_label_map_file(std::string* label_map_file);
private:
const std::string& _internal_label_map_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_label_map_file(const std::string& value);
std::string* _internal_mutable_label_map_file();
public:
// optional .caffe.AnnotatedDatum.AnnotationType anno_type = 3;
bool has_anno_type() const;
private:
bool _internal_has_anno_type() const;
public:
void clear_anno_type();
::caffe::AnnotatedDatum_AnnotationType anno_type() const;
void set_anno_type(::caffe::AnnotatedDatum_AnnotationType value);
private:
::caffe::AnnotatedDatum_AnnotationType _internal_anno_type() const;
void _internal_set_anno_type(::caffe::AnnotatedDatum_AnnotationType value);
public:
// @@protoc_insertion_point(class_scope:caffe.AnnotatedDataParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BatchSampler > batch_sampler_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr label_map_file_;
int anno_type_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ArgMaxParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ArgMaxParameter) */ {
public:
inline ArgMaxParameter() : ArgMaxParameter(nullptr) {}
~ArgMaxParameter() override;
explicit constexpr ArgMaxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ArgMaxParameter(const ArgMaxParameter& from);
ArgMaxParameter(ArgMaxParameter&& from) noexcept
: ArgMaxParameter() {
*this = ::std::move(from);
}
inline ArgMaxParameter& operator=(const ArgMaxParameter& from) {
CopyFrom(from);
return *this;
}
inline ArgMaxParameter& operator=(ArgMaxParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ArgMaxParameter& default_instance() {
return *internal_default_instance();
}
static inline const ArgMaxParameter* internal_default_instance() {
return reinterpret_cast<const ArgMaxParameter*>(
&_ArgMaxParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
41;
friend void swap(ArgMaxParameter& a, ArgMaxParameter& b) {
a.Swap(&b);
}
inline void Swap(ArgMaxParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ArgMaxParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ArgMaxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ArgMaxParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ArgMaxParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ArgMaxParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ArgMaxParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ArgMaxParameter";
}
protected:
explicit ArgMaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kOutMaxValFieldNumber = 1,
kSoftmaxThresholdFieldNumber = 4,
kAxisFieldNumber = 3,
kTopKFieldNumber = 2,
};
// optional bool out_max_val = 1 [default = false];
bool has_out_max_val() const;
private:
bool _internal_has_out_max_val() const;
public:
void clear_out_max_val();
bool out_max_val() const;
void set_out_max_val(bool value);
private:
bool _internal_out_max_val() const;
void _internal_set_out_max_val(bool value);
public:
// optional bool softmax_threshold = 4 [default = false];
bool has_softmax_threshold() const;
private:
bool _internal_has_softmax_threshold() const;
public:
void clear_softmax_threshold();
bool softmax_threshold() const;
void set_softmax_threshold(bool value);
private:
bool _internal_softmax_threshold() const;
void _internal_set_softmax_threshold(bool value);
public:
// optional int32 axis = 3;
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// optional uint32 top_k = 2 [default = 1];
bool has_top_k() const;
private:
bool _internal_has_top_k() const;
public:
void clear_top_k();
uint32_t top_k() const;
void set_top_k(uint32_t value);
private:
uint32_t _internal_top_k() const;
void _internal_set_top_k(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.ArgMaxParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
bool out_max_val_;
bool softmax_threshold_;
int32_t axis_;
uint32_t top_k_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ConcatParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ConcatParameter) */ {
public:
inline ConcatParameter() : ConcatParameter(nullptr) {}
~ConcatParameter() override;
explicit constexpr ConcatParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ConcatParameter(const ConcatParameter& from);
ConcatParameter(ConcatParameter&& from) noexcept
: ConcatParameter() {
*this = ::std::move(from);
}
inline ConcatParameter& operator=(const ConcatParameter& from) {
CopyFrom(from);
return *this;
}
inline ConcatParameter& operator=(ConcatParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ConcatParameter& default_instance() {
return *internal_default_instance();
}
static inline const ConcatParameter* internal_default_instance() {
return reinterpret_cast<const ConcatParameter*>(
&_ConcatParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
42;
friend void swap(ConcatParameter& a, ConcatParameter& b) {
a.Swap(&b);
}
inline void Swap(ConcatParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ConcatParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ConcatParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ConcatParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ConcatParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ConcatParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ConcatParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ConcatParameter";
}
protected:
explicit ConcatParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kConcatDimFieldNumber = 1,
kAxisFieldNumber = 2,
};
// optional uint32 concat_dim = 1 [default = 1];
bool has_concat_dim() const;
private:
bool _internal_has_concat_dim() const;
public:
void clear_concat_dim();
uint32_t concat_dim() const;
void set_concat_dim(uint32_t value);
private:
uint32_t _internal_concat_dim() const;
void _internal_set_concat_dim(uint32_t value);
public:
// optional int32 axis = 2 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.ConcatParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t concat_dim_;
int32_t axis_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class BatchNormParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.BatchNormParameter) */ {
public:
inline BatchNormParameter() : BatchNormParameter(nullptr) {}
~BatchNormParameter() override;
explicit constexpr BatchNormParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
BatchNormParameter(const BatchNormParameter& from);
BatchNormParameter(BatchNormParameter&& from) noexcept
: BatchNormParameter() {
*this = ::std::move(from);
}
inline BatchNormParameter& operator=(const BatchNormParameter& from) {
CopyFrom(from);
return *this;
}
inline BatchNormParameter& operator=(BatchNormParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const BatchNormParameter& default_instance() {
return *internal_default_instance();
}
static inline const BatchNormParameter* internal_default_instance() {
return reinterpret_cast<const BatchNormParameter*>(
&_BatchNormParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
43;
friend void swap(BatchNormParameter& a, BatchNormParameter& b) {
a.Swap(&b);
}
inline void Swap(BatchNormParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(BatchNormParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
BatchNormParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<BatchNormParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const BatchNormParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const BatchNormParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(BatchNormParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.BatchNormParameter";
}
protected:
explicit BatchNormParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kFillerFieldNumber = 7,
kBiasFillerFieldNumber = 8,
kScaleFillerFieldNumber = 9,
kUseGlobalStatsFieldNumber = 1,
kUseWeightBiasFieldNumber = 5,
kBiasTermFieldNumber = 6,
kMovingAverageFractionFieldNumber = 2,
kEpsFieldNumber = 3,
};
// optional .caffe.FillerParameter filler = 7;
bool has_filler() const;
private:
bool _internal_has_filler() const;
public:
void clear_filler();
const ::caffe::FillerParameter& filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_filler();
::caffe::FillerParameter* mutable_filler();
void set_allocated_filler(::caffe::FillerParameter* filler);
private:
const ::caffe::FillerParameter& _internal_filler() const;
::caffe::FillerParameter* _internal_mutable_filler();
public:
void unsafe_arena_set_allocated_filler(
::caffe::FillerParameter* filler);
::caffe::FillerParameter* unsafe_arena_release_filler();
// optional .caffe.FillerParameter bias_filler = 8;
bool has_bias_filler() const;
private:
bool _internal_has_bias_filler() const;
public:
void clear_bias_filler();
const ::caffe::FillerParameter& bias_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_bias_filler();
::caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);
private:
const ::caffe::FillerParameter& _internal_bias_filler() const;
::caffe::FillerParameter* _internal_mutable_bias_filler();
public:
void unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler);
::caffe::FillerParameter* unsafe_arena_release_bias_filler();
// optional .caffe.FillerParameter scale_filler = 9;
bool has_scale_filler() const;
private:
bool _internal_has_scale_filler() const;
public:
void clear_scale_filler();
const ::caffe::FillerParameter& scale_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_scale_filler();
::caffe::FillerParameter* mutable_scale_filler();
void set_allocated_scale_filler(::caffe::FillerParameter* scale_filler);
private:
const ::caffe::FillerParameter& _internal_scale_filler() const;
::caffe::FillerParameter* _internal_mutable_scale_filler();
public:
void unsafe_arena_set_allocated_scale_filler(
::caffe::FillerParameter* scale_filler);
::caffe::FillerParameter* unsafe_arena_release_scale_filler();
// optional bool use_global_stats = 1;
bool has_use_global_stats() const;
private:
bool _internal_has_use_global_stats() const;
public:
void clear_use_global_stats();
bool use_global_stats() const;
void set_use_global_stats(bool value);
private:
bool _internal_use_global_stats() const;
void _internal_set_use_global_stats(bool value);
public:
// optional bool use_weight_bias = 5 [default = true];
bool has_use_weight_bias() const;
private:
bool _internal_has_use_weight_bias() const;
public:
void clear_use_weight_bias();
bool use_weight_bias() const;
void set_use_weight_bias(bool value);
private:
bool _internal_use_weight_bias() const;
void _internal_set_use_weight_bias(bool value);
public:
// optional bool bias_term = 6 [default = true];
bool has_bias_term() const;
private:
bool _internal_has_bias_term() const;
public:
void clear_bias_term();
bool bias_term() const;
void set_bias_term(bool value);
private:
bool _internal_bias_term() const;
void _internal_set_bias_term(bool value);
public:
// optional float moving_average_fraction = 2 [default = 0.999];
bool has_moving_average_fraction() const;
private:
bool _internal_has_moving_average_fraction() const;
public:
void clear_moving_average_fraction();
float moving_average_fraction() const;
void set_moving_average_fraction(float value);
private:
float _internal_moving_average_fraction() const;
void _internal_set_moving_average_fraction(float value);
public:
// optional float eps = 3 [default = 1e-05];
bool has_eps() const;
private:
bool _internal_has_eps() const;
public:
void clear_eps();
float eps() const;
void set_eps(float value);
private:
float _internal_eps() const;
void _internal_set_eps(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.BatchNormParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* filler_;
::caffe::FillerParameter* bias_filler_;
::caffe::FillerParameter* scale_filler_;
bool use_global_stats_;
bool use_weight_bias_;
bool bias_term_;
float moving_average_fraction_;
float eps_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class BiasParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.BiasParameter) */ {
public:
inline BiasParameter() : BiasParameter(nullptr) {}
~BiasParameter() override;
explicit constexpr BiasParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
BiasParameter(const BiasParameter& from);
BiasParameter(BiasParameter&& from) noexcept
: BiasParameter() {
*this = ::std::move(from);
}
inline BiasParameter& operator=(const BiasParameter& from) {
CopyFrom(from);
return *this;
}
inline BiasParameter& operator=(BiasParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const BiasParameter& default_instance() {
return *internal_default_instance();
}
static inline const BiasParameter* internal_default_instance() {
return reinterpret_cast<const BiasParameter*>(
&_BiasParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
44;
friend void swap(BiasParameter& a, BiasParameter& b) {
a.Swap(&b);
}
inline void Swap(BiasParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(BiasParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
BiasParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<BiasParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const BiasParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const BiasParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(BiasParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.BiasParameter";
}
protected:
explicit BiasParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kFillerFieldNumber = 3,
kAxisFieldNumber = 1,
kNumAxesFieldNumber = 2,
};
// optional .caffe.FillerParameter filler = 3;
bool has_filler() const;
private:
bool _internal_has_filler() const;
public:
void clear_filler();
const ::caffe::FillerParameter& filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_filler();
::caffe::FillerParameter* mutable_filler();
void set_allocated_filler(::caffe::FillerParameter* filler);
private:
const ::caffe::FillerParameter& _internal_filler() const;
::caffe::FillerParameter* _internal_mutable_filler();
public:
void unsafe_arena_set_allocated_filler(
::caffe::FillerParameter* filler);
::caffe::FillerParameter* unsafe_arena_release_filler();
// optional int32 axis = 1 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// optional int32 num_axes = 2 [default = 1];
bool has_num_axes() const;
private:
bool _internal_has_num_axes() const;
public:
void clear_num_axes();
int32_t num_axes() const;
void set_num_axes(int32_t value);
private:
int32_t _internal_num_axes() const;
void _internal_set_num_axes(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.BiasParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* filler_;
int32_t axis_;
int32_t num_axes_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ContrastiveLossParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ContrastiveLossParameter) */ {
public:
inline ContrastiveLossParameter() : ContrastiveLossParameter(nullptr) {}
~ContrastiveLossParameter() override;
explicit constexpr ContrastiveLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ContrastiveLossParameter(const ContrastiveLossParameter& from);
ContrastiveLossParameter(ContrastiveLossParameter&& from) noexcept
: ContrastiveLossParameter() {
*this = ::std::move(from);
}
inline ContrastiveLossParameter& operator=(const ContrastiveLossParameter& from) {
CopyFrom(from);
return *this;
}
inline ContrastiveLossParameter& operator=(ContrastiveLossParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ContrastiveLossParameter& default_instance() {
return *internal_default_instance();
}
static inline const ContrastiveLossParameter* internal_default_instance() {
return reinterpret_cast<const ContrastiveLossParameter*>(
&_ContrastiveLossParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
45;
friend void swap(ContrastiveLossParameter& a, ContrastiveLossParameter& b) {
a.Swap(&b);
}
inline void Swap(ContrastiveLossParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ContrastiveLossParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ContrastiveLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ContrastiveLossParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ContrastiveLossParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ContrastiveLossParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ContrastiveLossParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ContrastiveLossParameter";
}
protected:
explicit ContrastiveLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kLegacyVersionFieldNumber = 2,
kMarginFieldNumber = 1,
};
// optional bool legacy_version = 2 [default = false];
bool has_legacy_version() const;
private:
bool _internal_has_legacy_version() const;
public:
void clear_legacy_version();
bool legacy_version() const;
void set_legacy_version(bool value);
private:
bool _internal_legacy_version() const;
void _internal_set_legacy_version(bool value);
public:
// optional float margin = 1 [default = 1];
bool has_margin() const;
private:
bool _internal_has_margin() const;
public:
void clear_margin();
float margin() const;
void set_margin(float value);
private:
float _internal_margin() const;
void _internal_set_margin(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ContrastiveLossParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
bool legacy_version_;
float margin_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ConvolutionParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ConvolutionParameter) */ {
public:
inline ConvolutionParameter() : ConvolutionParameter(nullptr) {}
~ConvolutionParameter() override;
explicit constexpr ConvolutionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ConvolutionParameter(const ConvolutionParameter& from);
ConvolutionParameter(ConvolutionParameter&& from) noexcept
: ConvolutionParameter() {
*this = ::std::move(from);
}
inline ConvolutionParameter& operator=(const ConvolutionParameter& from) {
CopyFrom(from);
return *this;
}
inline ConvolutionParameter& operator=(ConvolutionParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ConvolutionParameter& default_instance() {
return *internal_default_instance();
}
static inline const ConvolutionParameter* internal_default_instance() {
return reinterpret_cast<const ConvolutionParameter*>(
&_ConvolutionParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
46;
friend void swap(ConvolutionParameter& a, ConvolutionParameter& b) {
a.Swap(&b);
}
inline void Swap(ConvolutionParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ConvolutionParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ConvolutionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ConvolutionParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ConvolutionParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ConvolutionParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ConvolutionParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ConvolutionParameter";
}
protected:
explicit ConvolutionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef ConvolutionParameter_Engine Engine;
static constexpr Engine DEFAULT =
ConvolutionParameter_Engine_DEFAULT;
static constexpr Engine CAFFE =
ConvolutionParameter_Engine_CAFFE;
static constexpr Engine CUDNN =
ConvolutionParameter_Engine_CUDNN;
static constexpr Engine CUDNN_FORWARD =
ConvolutionParameter_Engine_CUDNN_FORWARD;
static inline bool Engine_IsValid(int value) {
return ConvolutionParameter_Engine_IsValid(value);
}
static constexpr Engine Engine_MIN =
ConvolutionParameter_Engine_Engine_MIN;
static constexpr Engine Engine_MAX =
ConvolutionParameter_Engine_Engine_MAX;
static constexpr int Engine_ARRAYSIZE =
ConvolutionParameter_Engine_Engine_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Engine_descriptor() {
return ConvolutionParameter_Engine_descriptor();
}
template<typename T>
static inline const std::string& Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Engine_Name.");
return ConvolutionParameter_Engine_Name(enum_t_value);
}
static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Engine* value) {
return ConvolutionParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kPadFieldNumber = 3,
kKernelSizeFieldNumber = 4,
kStrideFieldNumber = 6,
kDilationFieldNumber = 18,
kWeightFillerFieldNumber = 7,
kBiasFillerFieldNumber = 8,
kNumOutputFieldNumber = 1,
kPadHFieldNumber = 9,
kPadWFieldNumber = 10,
kKernelHFieldNumber = 11,
kKernelWFieldNumber = 12,
kStrideHFieldNumber = 13,
kStrideWFieldNumber = 14,
kEngineFieldNumber = 15,
kForceNdIm2ColFieldNumber = 17,
kParamqFieldNumber = 19,
kParamsFieldNumber = 20,
kScaleInFieldNumber = 21,
kScaleOutFieldNumber = 22,
kAMaxFieldNumber = 24,
kBiasTermFieldNumber = 2,
kGroupFieldNumber = 5,
kAxisFieldNumber = 16,
kAMinFieldNumber = 23,
};
// repeated uint32 pad = 3;
int pad_size() const;
private:
int _internal_pad_size() const;
public:
void clear_pad();
private:
uint32_t _internal_pad(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_pad() const;
void _internal_add_pad(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_pad();
public:
uint32_t pad(int index) const;
void set_pad(int index, uint32_t value);
void add_pad(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
pad() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_pad();
// repeated uint32 kernel_size = 4;
int kernel_size_size() const;
private:
int _internal_kernel_size_size() const;
public:
void clear_kernel_size();
private:
uint32_t _internal_kernel_size(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_kernel_size() const;
void _internal_add_kernel_size(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_kernel_size();
public:
uint32_t kernel_size(int index) const;
void set_kernel_size(int index, uint32_t value);
void add_kernel_size(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
kernel_size() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_kernel_size();
// repeated uint32 stride = 6;
int stride_size() const;
private:
int _internal_stride_size() const;
public:
void clear_stride();
private:
uint32_t _internal_stride(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_stride() const;
void _internal_add_stride(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_stride();
public:
uint32_t stride(int index) const;
void set_stride(int index, uint32_t value);
void add_stride(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
stride() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_stride();
// repeated uint32 dilation = 18;
int dilation_size() const;
private:
int _internal_dilation_size() const;
public:
void clear_dilation();
private:
uint32_t _internal_dilation(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_dilation() const;
void _internal_add_dilation(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_dilation();
public:
uint32_t dilation(int index) const;
void set_dilation(int index, uint32_t value);
void add_dilation(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
dilation() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_dilation();
// optional .caffe.FillerParameter weight_filler = 7;
bool has_weight_filler() const;
private:
bool _internal_has_weight_filler() const;
public:
void clear_weight_filler();
const ::caffe::FillerParameter& weight_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_weight_filler();
::caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);
private:
const ::caffe::FillerParameter& _internal_weight_filler() const;
::caffe::FillerParameter* _internal_mutable_weight_filler();
public:
void unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler);
::caffe::FillerParameter* unsafe_arena_release_weight_filler();
// optional .caffe.FillerParameter bias_filler = 8;
bool has_bias_filler() const;
private:
bool _internal_has_bias_filler() const;
public:
void clear_bias_filler();
const ::caffe::FillerParameter& bias_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_bias_filler();
::caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);
private:
const ::caffe::FillerParameter& _internal_bias_filler() const;
::caffe::FillerParameter* _internal_mutable_bias_filler();
public:
void unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler);
::caffe::FillerParameter* unsafe_arena_release_bias_filler();
// optional uint32 num_output = 1;
bool has_num_output() const;
private:
bool _internal_has_num_output() const;
public:
void clear_num_output();
uint32_t num_output() const;
void set_num_output(uint32_t value);
private:
uint32_t _internal_num_output() const;
void _internal_set_num_output(uint32_t value);
public:
// optional uint32 pad_h = 9 [default = 0];
bool has_pad_h() const;
private:
bool _internal_has_pad_h() const;
public:
void clear_pad_h();
uint32_t pad_h() const;
void set_pad_h(uint32_t value);
private:
uint32_t _internal_pad_h() const;
void _internal_set_pad_h(uint32_t value);
public:
// optional uint32 pad_w = 10 [default = 0];
bool has_pad_w() const;
private:
bool _internal_has_pad_w() const;
public:
void clear_pad_w();
uint32_t pad_w() const;
void set_pad_w(uint32_t value);
private:
uint32_t _internal_pad_w() const;
void _internal_set_pad_w(uint32_t value);
public:
// optional uint32 kernel_h = 11;
bool has_kernel_h() const;
private:
bool _internal_has_kernel_h() const;
public:
void clear_kernel_h();
uint32_t kernel_h() const;
void set_kernel_h(uint32_t value);
private:
uint32_t _internal_kernel_h() const;
void _internal_set_kernel_h(uint32_t value);
public:
// optional uint32 kernel_w = 12;
bool has_kernel_w() const;
private:
bool _internal_has_kernel_w() const;
public:
void clear_kernel_w();
uint32_t kernel_w() const;
void set_kernel_w(uint32_t value);
private:
uint32_t _internal_kernel_w() const;
void _internal_set_kernel_w(uint32_t value);
public:
// optional uint32 stride_h = 13;
bool has_stride_h() const;
private:
bool _internal_has_stride_h() const;
public:
void clear_stride_h();
uint32_t stride_h() const;
void set_stride_h(uint32_t value);
private:
uint32_t _internal_stride_h() const;
void _internal_set_stride_h(uint32_t value);
public:
// optional uint32 stride_w = 14;
bool has_stride_w() const;
private:
bool _internal_has_stride_w() const;
public:
void clear_stride_w();
uint32_t stride_w() const;
void set_stride_w(uint32_t value);
private:
uint32_t _internal_stride_w() const;
void _internal_set_stride_w(uint32_t value);
public:
// optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
bool has_engine() const;
private:
bool _internal_has_engine() const;
public:
void clear_engine();
::caffe::ConvolutionParameter_Engine engine() const;
void set_engine(::caffe::ConvolutionParameter_Engine value);
private:
::caffe::ConvolutionParameter_Engine _internal_engine() const;
void _internal_set_engine(::caffe::ConvolutionParameter_Engine value);
public:
// optional bool force_nd_im2col = 17 [default = false];
bool has_force_nd_im2col() const;
private:
bool _internal_has_force_nd_im2col() const;
public:
void clear_force_nd_im2col();
bool force_nd_im2col() const;
void set_force_nd_im2col(bool value);
private:
bool _internal_force_nd_im2col() const;
void _internal_set_force_nd_im2col(bool value);
public:
// optional uint32 paramq = 19;
bool has_paramq() const;
private:
bool _internal_has_paramq() const;
public:
void clear_paramq();
uint32_t paramq() const;
void set_paramq(uint32_t value);
private:
uint32_t _internal_paramq() const;
void _internal_set_paramq(uint32_t value);
public:
// optional float params = 20 [default = 0];
bool has_params() const;
private:
bool _internal_has_params() const;
public:
void clear_params();
float params() const;
void set_params(float value);
private:
float _internal_params() const;
void _internal_set_params(float value);
public:
// optional float scale_in = 21;
bool has_scale_in() const;
private:
bool _internal_has_scale_in() const;
public:
void clear_scale_in();
float scale_in() const;
void set_scale_in(float value);
private:
float _internal_scale_in() const;
void _internal_set_scale_in(float value);
public:
// optional float scale_out = 22;
bool has_scale_out() const;
private:
bool _internal_has_scale_out() const;
public:
void clear_scale_out();
float scale_out() const;
void set_scale_out(float value);
private:
float _internal_scale_out() const;
void _internal_set_scale_out(float value);
public:
// optional int32 a_max = 24 [default = 127];
bool has_a_max() const;
private:
bool _internal_has_a_max() const;
public:
void clear_a_max();
int32_t a_max() const;
void set_a_max(int32_t value);
private:
int32_t _internal_a_max() const;
void _internal_set_a_max(int32_t value);
public:
// optional bool bias_term = 2 [default = true];
bool has_bias_term() const;
private:
bool _internal_has_bias_term() const;
public:
void clear_bias_term();
bool bias_term() const;
void set_bias_term(bool value);
private:
bool _internal_bias_term() const;
void _internal_set_bias_term(bool value);
public:
// optional uint32 group = 5 [default = 1];
bool has_group() const;
private:
bool _internal_has_group() const;
public:
void clear_group();
uint32_t group() const;
void set_group(uint32_t value);
private:
uint32_t _internal_group() const;
void _internal_set_group(uint32_t value);
public:
// optional int32 axis = 16 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// optional int32 a_min = 23 [default = -128];
bool has_a_min() const;
private:
bool _internal_has_a_min() const;
public:
void clear_a_min();
int32_t a_min() const;
void set_a_min(int32_t value);
private:
int32_t _internal_a_min() const;
void _internal_set_a_min(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.ConvolutionParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > pad_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > kernel_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > stride_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > dilation_;
::caffe::FillerParameter* weight_filler_;
::caffe::FillerParameter* bias_filler_;
uint32_t num_output_;
uint32_t pad_h_;
uint32_t pad_w_;
uint32_t kernel_h_;
uint32_t kernel_w_;
uint32_t stride_h_;
uint32_t stride_w_;
int engine_;
bool force_nd_im2col_;
uint32_t paramq_;
float params_;
float scale_in_;
float scale_out_;
int32_t a_max_;
bool bias_term_;
uint32_t group_;
int32_t axis_;
int32_t a_min_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class Convolution3DParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.Convolution3DParameter) */ {
public:
inline Convolution3DParameter() : Convolution3DParameter(nullptr) {}
~Convolution3DParameter() override;
explicit constexpr Convolution3DParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Convolution3DParameter(const Convolution3DParameter& from);
Convolution3DParameter(Convolution3DParameter&& from) noexcept
: Convolution3DParameter() {
*this = ::std::move(from);
}
inline Convolution3DParameter& operator=(const Convolution3DParameter& from) {
CopyFrom(from);
return *this;
}
inline Convolution3DParameter& operator=(Convolution3DParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Convolution3DParameter& default_instance() {
return *internal_default_instance();
}
static inline const Convolution3DParameter* internal_default_instance() {
return reinterpret_cast<const Convolution3DParameter*>(
&_Convolution3DParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
47;
friend void swap(Convolution3DParameter& a, Convolution3DParameter& b) {
a.Swap(&b);
}
inline void Swap(Convolution3DParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Convolution3DParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Convolution3DParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Convolution3DParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Convolution3DParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Convolution3DParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Convolution3DParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.Convolution3DParameter";
}
protected:
explicit Convolution3DParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kWeightFillerFieldNumber = 9,
kBiasFillerFieldNumber = 10,
kNumOutputFieldNumber = 1,
kPadFieldNumber = 3,
kKernelSizeFieldNumber = 4,
kKernelDepthFieldNumber = 6,
kTemporalPadFieldNumber = 12,
kFilterGroupFieldNumber = 11,
kBiasTermFieldNumber = 2,
kGroupFieldNumber = 5,
kStrideFieldNumber = 7,
kTemporalStrideFieldNumber = 8,
};
// optional .caffe.FillerParameter weight_filler = 9;
bool has_weight_filler() const;
private:
bool _internal_has_weight_filler() const;
public:
void clear_weight_filler();
const ::caffe::FillerParameter& weight_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_weight_filler();
::caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);
private:
const ::caffe::FillerParameter& _internal_weight_filler() const;
::caffe::FillerParameter* _internal_mutable_weight_filler();
public:
void unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler);
::caffe::FillerParameter* unsafe_arena_release_weight_filler();
// optional .caffe.FillerParameter bias_filler = 10;
bool has_bias_filler() const;
private:
bool _internal_has_bias_filler() const;
public:
void clear_bias_filler();
const ::caffe::FillerParameter& bias_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_bias_filler();
::caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);
private:
const ::caffe::FillerParameter& _internal_bias_filler() const;
::caffe::FillerParameter* _internal_mutable_bias_filler();
public:
void unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler);
::caffe::FillerParameter* unsafe_arena_release_bias_filler();
// optional uint32 num_output = 1;
bool has_num_output() const;
private:
bool _internal_has_num_output() const;
public:
void clear_num_output();
uint32_t num_output() const;
void set_num_output(uint32_t value);
private:
uint32_t _internal_num_output() const;
void _internal_set_num_output(uint32_t value);
public:
// optional uint32 pad = 3 [default = 0];
bool has_pad() const;
private:
bool _internal_has_pad() const;
public:
void clear_pad();
uint32_t pad() const;
void set_pad(uint32_t value);
private:
uint32_t _internal_pad() const;
void _internal_set_pad(uint32_t value);
public:
// optional uint32 kernel_size = 4;
bool has_kernel_size() const;
private:
bool _internal_has_kernel_size() const;
public:
void clear_kernel_size();
uint32_t kernel_size() const;
void set_kernel_size(uint32_t value);
private:
uint32_t _internal_kernel_size() const;
void _internal_set_kernel_size(uint32_t value);
public:
// optional uint32 kernel_depth = 6;
bool has_kernel_depth() const;
private:
bool _internal_has_kernel_depth() const;
public:
void clear_kernel_depth();
uint32_t kernel_depth() const;
void set_kernel_depth(uint32_t value);
private:
uint32_t _internal_kernel_depth() const;
void _internal_set_kernel_depth(uint32_t value);
public:
// optional uint32 temporal_pad = 12 [default = 0];
bool has_temporal_pad() const;
private:
bool _internal_has_temporal_pad() const;
public:
void clear_temporal_pad();
uint32_t temporal_pad() const;
void set_temporal_pad(uint32_t value);
private:
uint32_t _internal_temporal_pad() const;
void _internal_set_temporal_pad(uint32_t value);
public:
// optional uint32 filter_group = 11 [default = 1];
bool has_filter_group() const;
private:
bool _internal_has_filter_group() const;
public:
void clear_filter_group();
uint32_t filter_group() const;
void set_filter_group(uint32_t value);
private:
uint32_t _internal_filter_group() const;
void _internal_set_filter_group(uint32_t value);
public:
// optional bool bias_term = 2 [default = true];
bool has_bias_term() const;
private:
bool _internal_has_bias_term() const;
public:
void clear_bias_term();
bool bias_term() const;
void set_bias_term(bool value);
private:
bool _internal_bias_term() const;
void _internal_set_bias_term(bool value);
public:
// optional uint32 group = 5 [default = 1];
bool has_group() const;
private:
bool _internal_has_group() const;
public:
void clear_group();
uint32_t group() const;
void set_group(uint32_t value);
private:
uint32_t _internal_group() const;
void _internal_set_group(uint32_t value);
public:
// optional uint32 stride = 7 [default = 1];
bool has_stride() const;
private:
bool _internal_has_stride() const;
public:
void clear_stride();
uint32_t stride() const;
void set_stride(uint32_t value);
private:
uint32_t _internal_stride() const;
void _internal_set_stride(uint32_t value);
public:
// optional uint32 temporal_stride = 8 [default = 1];
bool has_temporal_stride() const;
private:
bool _internal_has_temporal_stride() const;
public:
void clear_temporal_stride();
uint32_t temporal_stride() const;
void set_temporal_stride(uint32_t value);
private:
uint32_t _internal_temporal_stride() const;
void _internal_set_temporal_stride(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.Convolution3DParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* weight_filler_;
::caffe::FillerParameter* bias_filler_;
uint32_t num_output_;
uint32_t pad_;
uint32_t kernel_size_;
uint32_t kernel_depth_;
uint32_t temporal_pad_;
uint32_t filter_group_;
bool bias_term_;
uint32_t group_;
uint32_t stride_;
uint32_t temporal_stride_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class CropParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.CropParameter) */ {
public:
inline CropParameter() : CropParameter(nullptr) {}
~CropParameter() override;
explicit constexpr CropParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
CropParameter(const CropParameter& from);
CropParameter(CropParameter&& from) noexcept
: CropParameter() {
*this = ::std::move(from);
}
inline CropParameter& operator=(const CropParameter& from) {
CopyFrom(from);
return *this;
}
inline CropParameter& operator=(CropParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const CropParameter& default_instance() {
return *internal_default_instance();
}
static inline const CropParameter* internal_default_instance() {
return reinterpret_cast<const CropParameter*>(
&_CropParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
48;
friend void swap(CropParameter& a, CropParameter& b) {
a.Swap(&b);
}
inline void Swap(CropParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(CropParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
CropParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<CropParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const CropParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const CropParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(CropParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.CropParameter";
}
protected:
explicit CropParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kOffsetFieldNumber = 2,
kAxisFieldNumber = 1,
};
// repeated uint32 offset = 2;
int offset_size() const;
private:
int _internal_offset_size() const;
public:
void clear_offset();
private:
uint32_t _internal_offset(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_offset() const;
void _internal_add_offset(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_offset();
public:
uint32_t offset(int index) const;
void set_offset(int index, uint32_t value);
void add_offset(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
offset() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_offset();
// optional int32 axis = 1 [default = 2];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.CropParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > offset_;
int32_t axis_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class DataParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.DataParameter) */ {
public:
inline DataParameter() : DataParameter(nullptr) {}
~DataParameter() override;
explicit constexpr DataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DataParameter(const DataParameter& from);
DataParameter(DataParameter&& from) noexcept
: DataParameter() {
*this = ::std::move(from);
}
inline DataParameter& operator=(const DataParameter& from) {
CopyFrom(from);
return *this;
}
inline DataParameter& operator=(DataParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const DataParameter& default_instance() {
return *internal_default_instance();
}
static inline const DataParameter* internal_default_instance() {
return reinterpret_cast<const DataParameter*>(
&_DataParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
49;
friend void swap(DataParameter& a, DataParameter& b) {
a.Swap(&b);
}
inline void Swap(DataParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DataParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DataParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const DataParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const DataParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DataParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.DataParameter";
}
protected:
explicit DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef DataParameter_DB DB;
static constexpr DB LEVELDB =
DataParameter_DB_LEVELDB;
static constexpr DB LMDB =
DataParameter_DB_LMDB;
static inline bool DB_IsValid(int value) {
return DataParameter_DB_IsValid(value);
}
static constexpr DB DB_MIN =
DataParameter_DB_DB_MIN;
static constexpr DB DB_MAX =
DataParameter_DB_DB_MAX;
static constexpr int DB_ARRAYSIZE =
DataParameter_DB_DB_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
DB_descriptor() {
return DataParameter_DB_descriptor();
}
template<typename T>
static inline const std::string& DB_Name(T enum_t_value) {
static_assert(::std::is_same<T, DB>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DB_Name.");
return DataParameter_DB_Name(enum_t_value);
}
static inline bool DB_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
DB* value) {
return DataParameter_DB_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kSourceFieldNumber = 1,
kMeanFileFieldNumber = 3,
kBatchSizeFieldNumber = 4,
kCropSizeFieldNumber = 5,
kRandSkipFieldNumber = 7,
kBackendFieldNumber = 8,
kMirrorFieldNumber = 6,
kForceEncodedColorFieldNumber = 9,
kOutputWidthFieldNumber = 13,
kLabelSizeFieldNumber = 11,
kDataWidthFieldNumber = 12,
kScaleFieldNumber = 2,
kPrefetchFieldNumber = 10,
};
// optional string source = 1;
bool has_source() const;
private:
bool _internal_has_source() const;
public:
void clear_source();
const std::string& source() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_source(ArgT0&& arg0, ArgT... args);
std::string* mutable_source();
PROTOBUF_NODISCARD std::string* release_source();
void set_allocated_source(std::string* source);
private:
const std::string& _internal_source() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
std::string* _internal_mutable_source();
public:
// optional string mean_file = 3;
bool has_mean_file() const;
private:
bool _internal_has_mean_file() const;
public:
void clear_mean_file();
const std::string& mean_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_mean_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_mean_file();
PROTOBUF_NODISCARD std::string* release_mean_file();
void set_allocated_mean_file(std::string* mean_file);
private:
const std::string& _internal_mean_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value);
std::string* _internal_mutable_mean_file();
public:
// optional uint32 batch_size = 4;
bool has_batch_size() const;
private:
bool _internal_has_batch_size() const;
public:
void clear_batch_size();
uint32_t batch_size() const;
void set_batch_size(uint32_t value);
private:
uint32_t _internal_batch_size() const;
void _internal_set_batch_size(uint32_t value);
public:
// optional uint32 crop_size = 5 [default = 0];
bool has_crop_size() const;
private:
bool _internal_has_crop_size() const;
public:
void clear_crop_size();
uint32_t crop_size() const;
void set_crop_size(uint32_t value);
private:
uint32_t _internal_crop_size() const;
void _internal_set_crop_size(uint32_t value);
public:
// optional uint32 rand_skip = 7 [default = 0];
bool has_rand_skip() const;
private:
bool _internal_has_rand_skip() const;
public:
void clear_rand_skip();
uint32_t rand_skip() const;
void set_rand_skip(uint32_t value);
private:
uint32_t _internal_rand_skip() const;
void _internal_set_rand_skip(uint32_t value);
public:
// optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB];
bool has_backend() const;
private:
bool _internal_has_backend() const;
public:
void clear_backend();
::caffe::DataParameter_DB backend() const;
void set_backend(::caffe::DataParameter_DB value);
private:
::caffe::DataParameter_DB _internal_backend() const;
void _internal_set_backend(::caffe::DataParameter_DB value);
public:
// optional bool mirror = 6 [default = false];
bool has_mirror() const;
private:
bool _internal_has_mirror() const;
public:
void clear_mirror();
bool mirror() const;
void set_mirror(bool value);
private:
bool _internal_mirror() const;
void _internal_set_mirror(bool value);
public:
// optional bool force_encoded_color = 9 [default = false];
bool has_force_encoded_color() const;
private:
bool _internal_has_force_encoded_color() const;
public:
void clear_force_encoded_color();
bool force_encoded_color() const;
void set_force_encoded_color(bool value);
private:
bool _internal_force_encoded_color() const;
void _internal_set_force_encoded_color(bool value);
public:
// optional bool output_width = 13 [default = false];
bool has_output_width() const;
private:
bool _internal_has_output_width() const;
public:
void clear_output_width();
bool output_width() const;
void set_output_width(bool value);
private:
bool _internal_output_width() const;
void _internal_set_output_width(bool value);
public:
// optional uint32 label_size = 11 [default = 0];
bool has_label_size() const;
private:
bool _internal_has_label_size() const;
public:
void clear_label_size();
uint32_t label_size() const;
void set_label_size(uint32_t value);
private:
uint32_t _internal_label_size() const;
void _internal_set_label_size(uint32_t value);
public:
// optional uint32 data_width = 12 [default = 0];
bool has_data_width() const;
private:
bool _internal_has_data_width() const;
public:
void clear_data_width();
uint32_t data_width() const;
void set_data_width(uint32_t value);
private:
uint32_t _internal_data_width() const;
void _internal_set_data_width(uint32_t value);
public:
// optional float scale = 2 [default = 1];
bool has_scale() const;
private:
bool _internal_has_scale() const;
public:
void clear_scale();
float scale() const;
void set_scale(float value);
private:
float _internal_scale() const;
void _internal_set_scale(float value);
public:
// optional uint32 prefetch = 10 [default = 4];
bool has_prefetch() const;
private:
bool _internal_has_prefetch() const;
public:
void clear_prefetch();
uint32_t prefetch() const;
void set_prefetch(uint32_t value);
private:
uint32_t _internal_prefetch() const;
void _internal_set_prefetch(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.DataParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_;
uint32_t batch_size_;
uint32_t crop_size_;
uint32_t rand_skip_;
int backend_;
bool mirror_;
bool force_encoded_color_;
bool output_width_;
uint32_t label_size_;
uint32_t data_width_;
float scale_;
uint32_t prefetch_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class DetectionEvaluateParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.DetectionEvaluateParameter) */ {
public:
inline DetectionEvaluateParameter() : DetectionEvaluateParameter(nullptr) {}
~DetectionEvaluateParameter() override;
explicit constexpr DetectionEvaluateParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DetectionEvaluateParameter(const DetectionEvaluateParameter& from);
DetectionEvaluateParameter(DetectionEvaluateParameter&& from) noexcept
: DetectionEvaluateParameter() {
*this = ::std::move(from);
}
inline DetectionEvaluateParameter& operator=(const DetectionEvaluateParameter& from) {
CopyFrom(from);
return *this;
}
inline DetectionEvaluateParameter& operator=(DetectionEvaluateParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const DetectionEvaluateParameter& default_instance() {
return *internal_default_instance();
}
static inline const DetectionEvaluateParameter* internal_default_instance() {
return reinterpret_cast<const DetectionEvaluateParameter*>(
&_DetectionEvaluateParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
50;
friend void swap(DetectionEvaluateParameter& a, DetectionEvaluateParameter& b) {
a.Swap(&b);
}
inline void Swap(DetectionEvaluateParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DetectionEvaluateParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DetectionEvaluateParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DetectionEvaluateParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const DetectionEvaluateParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const DetectionEvaluateParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DetectionEvaluateParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.DetectionEvaluateParameter";
}
protected:
explicit DetectionEvaluateParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNameSizeFileFieldNumber = 5,
kResizeParamFieldNumber = 6,
kNumClassesFieldNumber = 1,
kBackgroundLabelIdFieldNumber = 2,
kOverlapThresholdFieldNumber = 3,
kEvaluateDifficultGtFieldNumber = 4,
};
// optional string name_size_file = 5;
bool has_name_size_file() const;
private:
bool _internal_has_name_size_file() const;
public:
void clear_name_size_file();
const std::string& name_size_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name_size_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_name_size_file();
PROTOBUF_NODISCARD std::string* release_name_size_file();
void set_allocated_name_size_file(std::string* name_size_file);
private:
const std::string& _internal_name_size_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name_size_file(const std::string& value);
std::string* _internal_mutable_name_size_file();
public:
// optional .caffe.ResizeParameter resize_param = 6;
bool has_resize_param() const;
private:
bool _internal_has_resize_param() const;
public:
void clear_resize_param();
const ::caffe::ResizeParameter& resize_param() const;
PROTOBUF_NODISCARD ::caffe::ResizeParameter* release_resize_param();
::caffe::ResizeParameter* mutable_resize_param();
void set_allocated_resize_param(::caffe::ResizeParameter* resize_param);
private:
const ::caffe::ResizeParameter& _internal_resize_param() const;
::caffe::ResizeParameter* _internal_mutable_resize_param();
public:
void unsafe_arena_set_allocated_resize_param(
::caffe::ResizeParameter* resize_param);
::caffe::ResizeParameter* unsafe_arena_release_resize_param();
// optional uint32 num_classes = 1;
bool has_num_classes() const;
private:
bool _internal_has_num_classes() const;
public:
void clear_num_classes();
uint32_t num_classes() const;
void set_num_classes(uint32_t value);
private:
uint32_t _internal_num_classes() const;
void _internal_set_num_classes(uint32_t value);
public:
// optional uint32 background_label_id = 2 [default = 0];
bool has_background_label_id() const;
private:
bool _internal_has_background_label_id() const;
public:
void clear_background_label_id();
uint32_t background_label_id() const;
void set_background_label_id(uint32_t value);
private:
uint32_t _internal_background_label_id() const;
void _internal_set_background_label_id(uint32_t value);
public:
// optional float overlap_threshold = 3 [default = 0.5];
bool has_overlap_threshold() const;
private:
bool _internal_has_overlap_threshold() const;
public:
void clear_overlap_threshold();
float overlap_threshold() const;
void set_overlap_threshold(float value);
private:
float _internal_overlap_threshold() const;
void _internal_set_overlap_threshold(float value);
public:
// optional bool evaluate_difficult_gt = 4 [default = true];
bool has_evaluate_difficult_gt() const;
private:
bool _internal_has_evaluate_difficult_gt() const;
public:
void clear_evaluate_difficult_gt();
bool evaluate_difficult_gt() const;
void set_evaluate_difficult_gt(bool value);
private:
bool _internal_evaluate_difficult_gt() const;
void _internal_set_evaluate_difficult_gt(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.DetectionEvaluateParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_size_file_;
::caffe::ResizeParameter* resize_param_;
uint32_t num_classes_;
uint32_t background_label_id_;
float overlap_threshold_;
bool evaluate_difficult_gt_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class NonMaximumSuppressionParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.NonMaximumSuppressionParameter) */ {
public:
inline NonMaximumSuppressionParameter() : NonMaximumSuppressionParameter(nullptr) {}
~NonMaximumSuppressionParameter() override;
explicit constexpr NonMaximumSuppressionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NonMaximumSuppressionParameter(const NonMaximumSuppressionParameter& from);
NonMaximumSuppressionParameter(NonMaximumSuppressionParameter&& from) noexcept
: NonMaximumSuppressionParameter() {
*this = ::std::move(from);
}
inline NonMaximumSuppressionParameter& operator=(const NonMaximumSuppressionParameter& from) {
CopyFrom(from);
return *this;
}
inline NonMaximumSuppressionParameter& operator=(NonMaximumSuppressionParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const NonMaximumSuppressionParameter& default_instance() {
return *internal_default_instance();
}
static inline const NonMaximumSuppressionParameter* internal_default_instance() {
return reinterpret_cast<const NonMaximumSuppressionParameter*>(
&_NonMaximumSuppressionParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
51;
friend void swap(NonMaximumSuppressionParameter& a, NonMaximumSuppressionParameter& b) {
a.Swap(&b);
}
inline void Swap(NonMaximumSuppressionParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(NonMaximumSuppressionParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NonMaximumSuppressionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NonMaximumSuppressionParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const NonMaximumSuppressionParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const NonMaximumSuppressionParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(NonMaximumSuppressionParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.NonMaximumSuppressionParameter";
}
protected:
explicit NonMaximumSuppressionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kTopKFieldNumber = 2,
kNmsThresholdFieldNumber = 1,
kEtaFieldNumber = 3,
};
// optional int32 top_k = 2;
bool has_top_k() const;
private:
bool _internal_has_top_k() const;
public:
void clear_top_k();
int32_t top_k() const;
void set_top_k(int32_t value);
private:
int32_t _internal_top_k() const;
void _internal_set_top_k(int32_t value);
public:
// optional float nms_threshold = 1 [default = 0.3];
bool has_nms_threshold() const;
private:
bool _internal_has_nms_threshold() const;
public:
void clear_nms_threshold();
float nms_threshold() const;
void set_nms_threshold(float value);
private:
float _internal_nms_threshold() const;
void _internal_set_nms_threshold(float value);
public:
// optional float eta = 3 [default = 1];
bool has_eta() const;
private:
bool _internal_has_eta() const;
public:
void clear_eta();
float eta() const;
void set_eta(float value);
private:
float _internal_eta() const;
void _internal_set_eta(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.NonMaximumSuppressionParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int32_t top_k_;
float nms_threshold_;
float eta_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class SaveOutputParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.SaveOutputParameter) */ {
public:
inline SaveOutputParameter() : SaveOutputParameter(nullptr) {}
~SaveOutputParameter() override;
explicit constexpr SaveOutputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SaveOutputParameter(const SaveOutputParameter& from);
SaveOutputParameter(SaveOutputParameter&& from) noexcept
: SaveOutputParameter() {
*this = ::std::move(from);
}
inline SaveOutputParameter& operator=(const SaveOutputParameter& from) {
CopyFrom(from);
return *this;
}
inline SaveOutputParameter& operator=(SaveOutputParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SaveOutputParameter& default_instance() {
return *internal_default_instance();
}
static inline const SaveOutputParameter* internal_default_instance() {
return reinterpret_cast<const SaveOutputParameter*>(
&_SaveOutputParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
52;
friend void swap(SaveOutputParameter& a, SaveOutputParameter& b) {
a.Swap(&b);
}
inline void Swap(SaveOutputParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SaveOutputParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SaveOutputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SaveOutputParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SaveOutputParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const SaveOutputParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SaveOutputParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.SaveOutputParameter";
}
protected:
explicit SaveOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kOutputDirectoryFieldNumber = 1,
kOutputNamePrefixFieldNumber = 2,
kOutputFormatFieldNumber = 3,
kLabelMapFileFieldNumber = 4,
kNameSizeFileFieldNumber = 5,
kResizeParamFieldNumber = 7,
kNumTestImageFieldNumber = 6,
};
// optional string output_directory = 1;
bool has_output_directory() const;
private:
bool _internal_has_output_directory() const;
public:
void clear_output_directory();
const std::string& output_directory() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_output_directory(ArgT0&& arg0, ArgT... args);
std::string* mutable_output_directory();
PROTOBUF_NODISCARD std::string* release_output_directory();
void set_allocated_output_directory(std::string* output_directory);
private:
const std::string& _internal_output_directory() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_directory(const std::string& value);
std::string* _internal_mutable_output_directory();
public:
// optional string output_name_prefix = 2;
bool has_output_name_prefix() const;
private:
bool _internal_has_output_name_prefix() const;
public:
void clear_output_name_prefix();
const std::string& output_name_prefix() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_output_name_prefix(ArgT0&& arg0, ArgT... args);
std::string* mutable_output_name_prefix();
PROTOBUF_NODISCARD std::string* release_output_name_prefix();
void set_allocated_output_name_prefix(std::string* output_name_prefix);
private:
const std::string& _internal_output_name_prefix() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_name_prefix(const std::string& value);
std::string* _internal_mutable_output_name_prefix();
public:
// optional string output_format = 3;
bool has_output_format() const;
private:
bool _internal_has_output_format() const;
public:
void clear_output_format();
const std::string& output_format() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_output_format(ArgT0&& arg0, ArgT... args);
std::string* mutable_output_format();
PROTOBUF_NODISCARD std::string* release_output_format();
void set_allocated_output_format(std::string* output_format);
private:
const std::string& _internal_output_format() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_format(const std::string& value);
std::string* _internal_mutable_output_format();
public:
// optional string label_map_file = 4;
bool has_label_map_file() const;
private:
bool _internal_has_label_map_file() const;
public:
void clear_label_map_file();
const std::string& label_map_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_label_map_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_label_map_file();
PROTOBUF_NODISCARD std::string* release_label_map_file();
void set_allocated_label_map_file(std::string* label_map_file);
private:
const std::string& _internal_label_map_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_label_map_file(const std::string& value);
std::string* _internal_mutable_label_map_file();
public:
// optional string name_size_file = 5;
bool has_name_size_file() const;
private:
bool _internal_has_name_size_file() const;
public:
void clear_name_size_file();
const std::string& name_size_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name_size_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_name_size_file();
PROTOBUF_NODISCARD std::string* release_name_size_file();
void set_allocated_name_size_file(std::string* name_size_file);
private:
const std::string& _internal_name_size_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name_size_file(const std::string& value);
std::string* _internal_mutable_name_size_file();
public:
// optional .caffe.ResizeParameter resize_param = 7;
bool has_resize_param() const;
private:
bool _internal_has_resize_param() const;
public:
void clear_resize_param();
const ::caffe::ResizeParameter& resize_param() const;
PROTOBUF_NODISCARD ::caffe::ResizeParameter* release_resize_param();
::caffe::ResizeParameter* mutable_resize_param();
void set_allocated_resize_param(::caffe::ResizeParameter* resize_param);
private:
const ::caffe::ResizeParameter& _internal_resize_param() const;
::caffe::ResizeParameter* _internal_mutable_resize_param();
public:
void unsafe_arena_set_allocated_resize_param(
::caffe::ResizeParameter* resize_param);
::caffe::ResizeParameter* unsafe_arena_release_resize_param();
// optional uint32 num_test_image = 6;
bool has_num_test_image() const;
private:
bool _internal_has_num_test_image() const;
public:
void clear_num_test_image();
uint32_t num_test_image() const;
void set_num_test_image(uint32_t value);
private:
uint32_t _internal_num_test_image() const;
void _internal_set_num_test_image(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.SaveOutputParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_directory_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_name_prefix_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_format_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr label_map_file_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_size_file_;
::caffe::ResizeParameter* resize_param_;
uint32_t num_test_image_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class DetectionOutputParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.DetectionOutputParameter) */ {
public:
inline DetectionOutputParameter() : DetectionOutputParameter(nullptr) {}
~DetectionOutputParameter() override;
explicit constexpr DetectionOutputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DetectionOutputParameter(const DetectionOutputParameter& from);
DetectionOutputParameter(DetectionOutputParameter&& from) noexcept
: DetectionOutputParameter() {
*this = ::std::move(from);
}
inline DetectionOutputParameter& operator=(const DetectionOutputParameter& from) {
CopyFrom(from);
return *this;
}
inline DetectionOutputParameter& operator=(DetectionOutputParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const DetectionOutputParameter& default_instance() {
return *internal_default_instance();
}
static inline const DetectionOutputParameter* internal_default_instance() {
return reinterpret_cast<const DetectionOutputParameter*>(
&_DetectionOutputParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
53;
friend void swap(DetectionOutputParameter& a, DetectionOutputParameter& b) {
a.Swap(&b);
}
inline void Swap(DetectionOutputParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DetectionOutputParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DetectionOutputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DetectionOutputParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const DetectionOutputParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const DetectionOutputParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DetectionOutputParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.DetectionOutputParameter";
}
protected:
explicit DetectionOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSaveFileFieldNumber = 12,
kNmsParamFieldNumber = 4,
kSaveOutputParamFieldNumber = 5,
kNumClassesFieldNumber = 1,
kBackgroundLabelIdFieldNumber = 3,
kConfidenceThresholdFieldNumber = 9,
kVarianceEncodedInTargetFieldNumber = 8,
kVisualizeFieldNumber = 10,
kVisualizeThresholdFieldNumber = 11,
kShareLocationFieldNumber = 2,
kCodeTypeFieldNumber = 6,
kKeepTopKFieldNumber = 7,
kObjectnessScoreFieldNumber = 24,
};
// optional string save_file = 12;
bool has_save_file() const;
private:
bool _internal_has_save_file() const;
public:
void clear_save_file();
const std::string& save_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_save_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_save_file();
PROTOBUF_NODISCARD std::string* release_save_file();
void set_allocated_save_file(std::string* save_file);
private:
const std::string& _internal_save_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_save_file(const std::string& value);
std::string* _internal_mutable_save_file();
public:
// optional .caffe.NonMaximumSuppressionParameter nms_param = 4;
bool has_nms_param() const;
private:
bool _internal_has_nms_param() const;
public:
void clear_nms_param();
const ::caffe::NonMaximumSuppressionParameter& nms_param() const;
PROTOBUF_NODISCARD ::caffe::NonMaximumSuppressionParameter* release_nms_param();
::caffe::NonMaximumSuppressionParameter* mutable_nms_param();
void set_allocated_nms_param(::caffe::NonMaximumSuppressionParameter* nms_param);
private:
const ::caffe::NonMaximumSuppressionParameter& _internal_nms_param() const;
::caffe::NonMaximumSuppressionParameter* _internal_mutable_nms_param();
public:
void unsafe_arena_set_allocated_nms_param(
::caffe::NonMaximumSuppressionParameter* nms_param);
::caffe::NonMaximumSuppressionParameter* unsafe_arena_release_nms_param();
// optional .caffe.SaveOutputParameter save_output_param = 5;
bool has_save_output_param() const;
private:
bool _internal_has_save_output_param() const;
public:
void clear_save_output_param();
const ::caffe::SaveOutputParameter& save_output_param() const;
PROTOBUF_NODISCARD ::caffe::SaveOutputParameter* release_save_output_param();
::caffe::SaveOutputParameter* mutable_save_output_param();
void set_allocated_save_output_param(::caffe::SaveOutputParameter* save_output_param);
private:
const ::caffe::SaveOutputParameter& _internal_save_output_param() const;
::caffe::SaveOutputParameter* _internal_mutable_save_output_param();
public:
void unsafe_arena_set_allocated_save_output_param(
::caffe::SaveOutputParameter* save_output_param);
::caffe::SaveOutputParameter* unsafe_arena_release_save_output_param();
// optional uint32 num_classes = 1;
bool has_num_classes() const;
private:
bool _internal_has_num_classes() const;
public:
void clear_num_classes();
uint32_t num_classes() const;
void set_num_classes(uint32_t value);
private:
uint32_t _internal_num_classes() const;
void _internal_set_num_classes(uint32_t value);
public:
// optional int32 background_label_id = 3 [default = 0];
bool has_background_label_id() const;
private:
bool _internal_has_background_label_id() const;
public:
void clear_background_label_id();
int32_t background_label_id() const;
void set_background_label_id(int32_t value);
private:
int32_t _internal_background_label_id() const;
void _internal_set_background_label_id(int32_t value);
public:
// optional float confidence_threshold = 9;
bool has_confidence_threshold() const;
private:
bool _internal_has_confidence_threshold() const;
public:
void clear_confidence_threshold();
float confidence_threshold() const;
void set_confidence_threshold(float value);
private:
float _internal_confidence_threshold() const;
void _internal_set_confidence_threshold(float value);
public:
// optional bool variance_encoded_in_target = 8 [default = false];
bool has_variance_encoded_in_target() const;
private:
bool _internal_has_variance_encoded_in_target() const;
public:
void clear_variance_encoded_in_target();
bool variance_encoded_in_target() const;
void set_variance_encoded_in_target(bool value);
private:
bool _internal_variance_encoded_in_target() const;
void _internal_set_variance_encoded_in_target(bool value);
public:
// optional bool visualize = 10 [default = false];
bool has_visualize() const;
private:
bool _internal_has_visualize() const;
public:
void clear_visualize();
bool visualize() const;
void set_visualize(bool value);
private:
bool _internal_visualize() const;
void _internal_set_visualize(bool value);
public:
// optional float visualize_threshold = 11;
bool has_visualize_threshold() const;
private:
bool _internal_has_visualize_threshold() const;
public:
void clear_visualize_threshold();
float visualize_threshold() const;
void set_visualize_threshold(float value);
private:
float _internal_visualize_threshold() const;
void _internal_set_visualize_threshold(float value);
public:
// optional bool share_location = 2 [default = true];
bool has_share_location() const;
private:
bool _internal_has_share_location() const;
public:
void clear_share_location();
bool share_location() const;
void set_share_location(bool value);
private:
bool _internal_share_location() const;
void _internal_set_share_location(bool value);
public:
// optional .caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
bool has_code_type() const;
private:
bool _internal_has_code_type() const;
public:
void clear_code_type();
::caffe::PriorBoxParameter_CodeType code_type() const;
void set_code_type(::caffe::PriorBoxParameter_CodeType value);
private:
::caffe::PriorBoxParameter_CodeType _internal_code_type() const;
void _internal_set_code_type(::caffe::PriorBoxParameter_CodeType value);
public:
// optional int32 keep_top_k = 7 [default = -1];
bool has_keep_top_k() const;
private:
bool _internal_has_keep_top_k() const;
public:
void clear_keep_top_k();
int32_t keep_top_k() const;
void set_keep_top_k(int32_t value);
private:
int32_t _internal_keep_top_k() const;
void _internal_set_keep_top_k(int32_t value);
public:
// optional float objectness_score = 24 [default = 0.01];
bool has_objectness_score() const;
private:
bool _internal_has_objectness_score() const;
public:
void clear_objectness_score();
float objectness_score() const;
void set_objectness_score(float value);
private:
float _internal_objectness_score() const;
void _internal_set_objectness_score(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.DetectionOutputParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr save_file_;
::caffe::NonMaximumSuppressionParameter* nms_param_;
::caffe::SaveOutputParameter* save_output_param_;
uint32_t num_classes_;
int32_t background_label_id_;
float confidence_threshold_;
bool variance_encoded_in_target_;
bool visualize_;
float visualize_threshold_;
bool share_location_;
int code_type_;
int32_t keep_top_k_;
float objectness_score_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class DropoutParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.DropoutParameter) */ {
public:
inline DropoutParameter() : DropoutParameter(nullptr) {}
~DropoutParameter() override;
explicit constexpr DropoutParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DropoutParameter(const DropoutParameter& from);
DropoutParameter(DropoutParameter&& from) noexcept
: DropoutParameter() {
*this = ::std::move(from);
}
inline DropoutParameter& operator=(const DropoutParameter& from) {
CopyFrom(from);
return *this;
}
inline DropoutParameter& operator=(DropoutParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const DropoutParameter& default_instance() {
return *internal_default_instance();
}
static inline const DropoutParameter* internal_default_instance() {
return reinterpret_cast<const DropoutParameter*>(
&_DropoutParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
54;
friend void swap(DropoutParameter& a, DropoutParameter& b) {
a.Swap(&b);
}
inline void Swap(DropoutParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DropoutParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DropoutParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DropoutParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const DropoutParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const DropoutParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DropoutParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.DropoutParameter";
}
protected:
explicit DropoutParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDropoutRatioFieldNumber = 1,
};
// optional float dropout_ratio = 1 [default = 0.5];
bool has_dropout_ratio() const;
private:
bool _internal_has_dropout_ratio() const;
public:
void clear_dropout_ratio();
float dropout_ratio() const;
void set_dropout_ratio(float value);
private:
float _internal_dropout_ratio() const;
void _internal_set_dropout_ratio(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.DropoutParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float dropout_ratio_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class DummyDataParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.DummyDataParameter) */ {
public:
inline DummyDataParameter() : DummyDataParameter(nullptr) {}
~DummyDataParameter() override;
explicit constexpr DummyDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DummyDataParameter(const DummyDataParameter& from);
DummyDataParameter(DummyDataParameter&& from) noexcept
: DummyDataParameter() {
*this = ::std::move(from);
}
inline DummyDataParameter& operator=(const DummyDataParameter& from) {
CopyFrom(from);
return *this;
}
inline DummyDataParameter& operator=(DummyDataParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const DummyDataParameter& default_instance() {
return *internal_default_instance();
}
static inline const DummyDataParameter* internal_default_instance() {
return reinterpret_cast<const DummyDataParameter*>(
&_DummyDataParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
55;
friend void swap(DummyDataParameter& a, DummyDataParameter& b) {
a.Swap(&b);
}
inline void Swap(DummyDataParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DummyDataParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DummyDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DummyDataParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const DummyDataParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const DummyDataParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DummyDataParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.DummyDataParameter";
}
protected:
explicit DummyDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDataFillerFieldNumber = 1,
kNumFieldNumber = 2,
kChannelsFieldNumber = 3,
kHeightFieldNumber = 4,
kWidthFieldNumber = 5,
kShapeFieldNumber = 6,
};
// repeated .caffe.FillerParameter data_filler = 1;
int data_filler_size() const;
private:
int _internal_data_filler_size() const;
public:
void clear_data_filler();
::caffe::FillerParameter* mutable_data_filler(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::FillerParameter >*
mutable_data_filler();
private:
const ::caffe::FillerParameter& _internal_data_filler(int index) const;
::caffe::FillerParameter* _internal_add_data_filler();
public:
const ::caffe::FillerParameter& data_filler(int index) const;
::caffe::FillerParameter* add_data_filler();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::FillerParameter >&
data_filler() const;
// repeated uint32 num = 2;
int num_size() const;
private:
int _internal_num_size() const;
public:
void clear_num();
private:
uint32_t _internal_num(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_num() const;
void _internal_add_num(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_num();
public:
uint32_t num(int index) const;
void set_num(int index, uint32_t value);
void add_num(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
num() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_num();
// repeated uint32 channels = 3;
int channels_size() const;
private:
int _internal_channels_size() const;
public:
void clear_channels();
private:
uint32_t _internal_channels(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_channels() const;
void _internal_add_channels(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_channels();
public:
uint32_t channels(int index) const;
void set_channels(int index, uint32_t value);
void add_channels(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
channels() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_channels();
// repeated uint32 height = 4;
int height_size() const;
private:
int _internal_height_size() const;
public:
void clear_height();
private:
uint32_t _internal_height(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_height() const;
void _internal_add_height(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_height();
public:
uint32_t height(int index) const;
void set_height(int index, uint32_t value);
void add_height(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
height() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_height();
// repeated uint32 width = 5;
int width_size() const;
private:
int _internal_width_size() const;
public:
void clear_width();
private:
uint32_t _internal_width(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_width() const;
void _internal_add_width(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_width();
public:
uint32_t width(int index) const;
void set_width(int index, uint32_t value);
void add_width(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
width() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_width();
// repeated .caffe.BlobShape shape = 6;
int shape_size() const;
private:
int _internal_shape_size() const;
public:
void clear_shape();
::caffe::BlobShape* mutable_shape(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >*
mutable_shape();
private:
const ::caffe::BlobShape& _internal_shape(int index) const;
::caffe::BlobShape* _internal_add_shape();
public:
const ::caffe::BlobShape& shape(int index) const;
::caffe::BlobShape* add_shape();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >&
shape() const;
// @@protoc_insertion_point(class_scope:caffe.DummyDataParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::FillerParameter > data_filler_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > num_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > channels_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > height_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > width_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape > shape_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class EltwiseParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.EltwiseParameter) */ {
public:
inline EltwiseParameter() : EltwiseParameter(nullptr) {}
~EltwiseParameter() override;
explicit constexpr EltwiseParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
EltwiseParameter(const EltwiseParameter& from);
EltwiseParameter(EltwiseParameter&& from) noexcept
: EltwiseParameter() {
*this = ::std::move(from);
}
inline EltwiseParameter& operator=(const EltwiseParameter& from) {
CopyFrom(from);
return *this;
}
inline EltwiseParameter& operator=(EltwiseParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const EltwiseParameter& default_instance() {
return *internal_default_instance();
}
static inline const EltwiseParameter* internal_default_instance() {
return reinterpret_cast<const EltwiseParameter*>(
&_EltwiseParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
56;
friend void swap(EltwiseParameter& a, EltwiseParameter& b) {
a.Swap(&b);
}
inline void Swap(EltwiseParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(EltwiseParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
EltwiseParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<EltwiseParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const EltwiseParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const EltwiseParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(EltwiseParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.EltwiseParameter";
}
protected:
explicit EltwiseParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef EltwiseParameter_EltwiseOp EltwiseOp;
static constexpr EltwiseOp PROD =
EltwiseParameter_EltwiseOp_PROD;
static constexpr EltwiseOp SUM =
EltwiseParameter_EltwiseOp_SUM;
static constexpr EltwiseOp MAX =
EltwiseParameter_EltwiseOp_MAX;
static inline bool EltwiseOp_IsValid(int value) {
return EltwiseParameter_EltwiseOp_IsValid(value);
}
static constexpr EltwiseOp EltwiseOp_MIN =
EltwiseParameter_EltwiseOp_EltwiseOp_MIN;
static constexpr EltwiseOp EltwiseOp_MAX =
EltwiseParameter_EltwiseOp_EltwiseOp_MAX;
static constexpr int EltwiseOp_ARRAYSIZE =
EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
EltwiseOp_descriptor() {
return EltwiseParameter_EltwiseOp_descriptor();
}
template<typename T>
static inline const std::string& EltwiseOp_Name(T enum_t_value) {
static_assert(::std::is_same<T, EltwiseOp>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function EltwiseOp_Name.");
return EltwiseParameter_EltwiseOp_Name(enum_t_value);
}
static inline bool EltwiseOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
EltwiseOp* value) {
return EltwiseParameter_EltwiseOp_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kCoeffFieldNumber = 2,
kOperationFieldNumber = 1,
kStableProdGradFieldNumber = 3,
};
// repeated float coeff = 2;
int coeff_size() const;
private:
int _internal_coeff_size() const;
public:
void clear_coeff();
private:
float _internal_coeff(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_coeff() const;
void _internal_add_coeff(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_coeff();
public:
float coeff(int index) const;
void set_coeff(int index, float value);
void add_coeff(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
coeff() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_coeff();
// optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
bool has_operation() const;
private:
bool _internal_has_operation() const;
public:
void clear_operation();
::caffe::EltwiseParameter_EltwiseOp operation() const;
void set_operation(::caffe::EltwiseParameter_EltwiseOp value);
private:
::caffe::EltwiseParameter_EltwiseOp _internal_operation() const;
void _internal_set_operation(::caffe::EltwiseParameter_EltwiseOp value);
public:
// optional bool stable_prod_grad = 3 [default = true];
bool has_stable_prod_grad() const;
private:
bool _internal_has_stable_prod_grad() const;
public:
void clear_stable_prod_grad();
bool stable_prod_grad() const;
void set_stable_prod_grad(bool value);
private:
bool _internal_stable_prod_grad() const;
void _internal_set_stable_prod_grad(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.EltwiseParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > coeff_;
int operation_;
bool stable_prod_grad_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ELUParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ELUParameter) */ {
public:
inline ELUParameter() : ELUParameter(nullptr) {}
~ELUParameter() override;
explicit constexpr ELUParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ELUParameter(const ELUParameter& from);
ELUParameter(ELUParameter&& from) noexcept
: ELUParameter() {
*this = ::std::move(from);
}
inline ELUParameter& operator=(const ELUParameter& from) {
CopyFrom(from);
return *this;
}
inline ELUParameter& operator=(ELUParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ELUParameter& default_instance() {
return *internal_default_instance();
}
static inline const ELUParameter* internal_default_instance() {
return reinterpret_cast<const ELUParameter*>(
&_ELUParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
57;
friend void swap(ELUParameter& a, ELUParameter& b) {
a.Swap(&b);
}
inline void Swap(ELUParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ELUParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ELUParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ELUParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ELUParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ELUParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ELUParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ELUParameter";
}
protected:
explicit ELUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kAlphaFieldNumber = 1,
};
// optional float alpha = 1 [default = 1];
bool has_alpha() const;
private:
bool _internal_has_alpha() const;
public:
void clear_alpha();
float alpha() const;
void set_alpha(float value);
private:
float _internal_alpha() const;
void _internal_set_alpha(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ELUParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float alpha_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class EmbedParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.EmbedParameter) */ {
public:
inline EmbedParameter() : EmbedParameter(nullptr) {}
~EmbedParameter() override;
explicit constexpr EmbedParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
EmbedParameter(const EmbedParameter& from);
EmbedParameter(EmbedParameter&& from) noexcept
: EmbedParameter() {
*this = ::std::move(from);
}
inline EmbedParameter& operator=(const EmbedParameter& from) {
CopyFrom(from);
return *this;
}
inline EmbedParameter& operator=(EmbedParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const EmbedParameter& default_instance() {
return *internal_default_instance();
}
static inline const EmbedParameter* internal_default_instance() {
return reinterpret_cast<const EmbedParameter*>(
&_EmbedParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
58;
friend void swap(EmbedParameter& a, EmbedParameter& b) {
a.Swap(&b);
}
inline void Swap(EmbedParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(EmbedParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
EmbedParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<EmbedParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const EmbedParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const EmbedParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(EmbedParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.EmbedParameter";
}
protected:
explicit EmbedParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kWeightFillerFieldNumber = 4,
kBiasFillerFieldNumber = 5,
kNumOutputFieldNumber = 1,
kInputDimFieldNumber = 2,
kBiasTermFieldNumber = 3,
};
// optional .caffe.FillerParameter weight_filler = 4;
bool has_weight_filler() const;
private:
bool _internal_has_weight_filler() const;
public:
void clear_weight_filler();
const ::caffe::FillerParameter& weight_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_weight_filler();
::caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);
private:
const ::caffe::FillerParameter& _internal_weight_filler() const;
::caffe::FillerParameter* _internal_mutable_weight_filler();
public:
void unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler);
::caffe::FillerParameter* unsafe_arena_release_weight_filler();
// optional .caffe.FillerParameter bias_filler = 5;
bool has_bias_filler() const;
private:
bool _internal_has_bias_filler() const;
public:
void clear_bias_filler();
const ::caffe::FillerParameter& bias_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_bias_filler();
::caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);
private:
const ::caffe::FillerParameter& _internal_bias_filler() const;
::caffe::FillerParameter* _internal_mutable_bias_filler();
public:
void unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler);
::caffe::FillerParameter* unsafe_arena_release_bias_filler();
// optional uint32 num_output = 1;
bool has_num_output() const;
private:
bool _internal_has_num_output() const;
public:
void clear_num_output();
uint32_t num_output() const;
void set_num_output(uint32_t value);
private:
uint32_t _internal_num_output() const;
void _internal_set_num_output(uint32_t value);
public:
// optional uint32 input_dim = 2;
bool has_input_dim() const;
private:
bool _internal_has_input_dim() const;
public:
void clear_input_dim();
uint32_t input_dim() const;
void set_input_dim(uint32_t value);
private:
uint32_t _internal_input_dim() const;
void _internal_set_input_dim(uint32_t value);
public:
// optional bool bias_term = 3 [default = true];
bool has_bias_term() const;
private:
bool _internal_has_bias_term() const;
public:
void clear_bias_term();
bool bias_term() const;
void set_bias_term(bool value);
private:
bool _internal_bias_term() const;
void _internal_set_bias_term(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.EmbedParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* weight_filler_;
::caffe::FillerParameter* bias_filler_;
uint32_t num_output_;
uint32_t input_dim_;
bool bias_term_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ExpParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ExpParameter) */ {
public:
inline ExpParameter() : ExpParameter(nullptr) {}
~ExpParameter() override;
explicit constexpr ExpParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ExpParameter(const ExpParameter& from);
ExpParameter(ExpParameter&& from) noexcept
: ExpParameter() {
*this = ::std::move(from);
}
inline ExpParameter& operator=(const ExpParameter& from) {
CopyFrom(from);
return *this;
}
inline ExpParameter& operator=(ExpParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ExpParameter& default_instance() {
return *internal_default_instance();
}
static inline const ExpParameter* internal_default_instance() {
return reinterpret_cast<const ExpParameter*>(
&_ExpParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
59;
friend void swap(ExpParameter& a, ExpParameter& b) {
a.Swap(&b);
}
inline void Swap(ExpParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ExpParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ExpParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ExpParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ExpParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ExpParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ExpParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ExpParameter";
}
protected:
explicit ExpParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShiftFieldNumber = 3,
kBaseFieldNumber = 1,
kScaleFieldNumber = 2,
};
// optional float shift = 3 [default = 0];
bool has_shift() const;
private:
bool _internal_has_shift() const;
public:
void clear_shift();
float shift() const;
void set_shift(float value);
private:
float _internal_shift() const;
void _internal_set_shift(float value);
public:
// optional float base = 1 [default = -1];
bool has_base() const;
private:
bool _internal_has_base() const;
public:
void clear_base();
float base() const;
void set_base(float value);
private:
float _internal_base() const;
void _internal_set_base(float value);
public:
// optional float scale = 2 [default = 1];
bool has_scale() const;
private:
bool _internal_has_scale() const;
public:
void clear_scale();
float scale() const;
void set_scale(float value);
private:
float _internal_scale() const;
void _internal_set_scale(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ExpParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float shift_;
float base_;
float scale_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class FlattenParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.FlattenParameter) */ {
public:
inline FlattenParameter() : FlattenParameter(nullptr) {}
~FlattenParameter() override;
explicit constexpr FlattenParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FlattenParameter(const FlattenParameter& from);
FlattenParameter(FlattenParameter&& from) noexcept
: FlattenParameter() {
*this = ::std::move(from);
}
inline FlattenParameter& operator=(const FlattenParameter& from) {
CopyFrom(from);
return *this;
}
inline FlattenParameter& operator=(FlattenParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const FlattenParameter& default_instance() {
return *internal_default_instance();
}
static inline const FlattenParameter* internal_default_instance() {
return reinterpret_cast<const FlattenParameter*>(
&_FlattenParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
60;
friend void swap(FlattenParameter& a, FlattenParameter& b) {
a.Swap(&b);
}
inline void Swap(FlattenParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FlattenParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FlattenParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FlattenParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const FlattenParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const FlattenParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FlattenParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.FlattenParameter";
}
protected:
explicit FlattenParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kAxisFieldNumber = 1,
kEndAxisFieldNumber = 2,
};
// optional int32 axis = 1 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// optional int32 end_axis = 2 [default = -1];
bool has_end_axis() const;
private:
bool _internal_has_end_axis() const;
public:
void clear_end_axis();
int32_t end_axis() const;
void set_end_axis(int32_t value);
private:
int32_t _internal_end_axis() const;
void _internal_set_end_axis(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.FlattenParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int32_t axis_;
int32_t end_axis_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class HDF5DataParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.HDF5DataParameter) */ {
public:
inline HDF5DataParameter() : HDF5DataParameter(nullptr) {}
~HDF5DataParameter() override;
explicit constexpr HDF5DataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
HDF5DataParameter(const HDF5DataParameter& from);
HDF5DataParameter(HDF5DataParameter&& from) noexcept
: HDF5DataParameter() {
*this = ::std::move(from);
}
inline HDF5DataParameter& operator=(const HDF5DataParameter& from) {
CopyFrom(from);
return *this;
}
inline HDF5DataParameter& operator=(HDF5DataParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const HDF5DataParameter& default_instance() {
return *internal_default_instance();
}
static inline const HDF5DataParameter* internal_default_instance() {
return reinterpret_cast<const HDF5DataParameter*>(
&_HDF5DataParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
61;
friend void swap(HDF5DataParameter& a, HDF5DataParameter& b) {
a.Swap(&b);
}
inline void Swap(HDF5DataParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(HDF5DataParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
HDF5DataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<HDF5DataParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const HDF5DataParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const HDF5DataParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(HDF5DataParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.HDF5DataParameter";
}
protected:
explicit HDF5DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSourceFieldNumber = 1,
kBatchSizeFieldNumber = 2,
kShuffleFieldNumber = 3,
};
// optional string source = 1;
bool has_source() const;
private:
bool _internal_has_source() const;
public:
void clear_source();
const std::string& source() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_source(ArgT0&& arg0, ArgT... args);
std::string* mutable_source();
PROTOBUF_NODISCARD std::string* release_source();
void set_allocated_source(std::string* source);
private:
const std::string& _internal_source() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
std::string* _internal_mutable_source();
public:
// optional uint32 batch_size = 2;
bool has_batch_size() const;
private:
bool _internal_has_batch_size() const;
public:
void clear_batch_size();
uint32_t batch_size() const;
void set_batch_size(uint32_t value);
private:
uint32_t _internal_batch_size() const;
void _internal_set_batch_size(uint32_t value);
public:
// optional bool shuffle = 3 [default = false];
bool has_shuffle() const;
private:
bool _internal_has_shuffle() const;
public:
void clear_shuffle();
bool shuffle() const;
void set_shuffle(bool value);
private:
bool _internal_shuffle() const;
void _internal_set_shuffle(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.HDF5DataParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
uint32_t batch_size_;
bool shuffle_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class HDF5OutputParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.HDF5OutputParameter) */ {
public:
inline HDF5OutputParameter() : HDF5OutputParameter(nullptr) {}
~HDF5OutputParameter() override;
explicit constexpr HDF5OutputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
HDF5OutputParameter(const HDF5OutputParameter& from);
HDF5OutputParameter(HDF5OutputParameter&& from) noexcept
: HDF5OutputParameter() {
*this = ::std::move(from);
}
inline HDF5OutputParameter& operator=(const HDF5OutputParameter& from) {
CopyFrom(from);
return *this;
}
inline HDF5OutputParameter& operator=(HDF5OutputParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const HDF5OutputParameter& default_instance() {
return *internal_default_instance();
}
static inline const HDF5OutputParameter* internal_default_instance() {
return reinterpret_cast<const HDF5OutputParameter*>(
&_HDF5OutputParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
62;
friend void swap(HDF5OutputParameter& a, HDF5OutputParameter& b) {
a.Swap(&b);
}
inline void Swap(HDF5OutputParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(HDF5OutputParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
HDF5OutputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<HDF5OutputParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const HDF5OutputParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const HDF5OutputParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(HDF5OutputParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.HDF5OutputParameter";
}
protected:
explicit HDF5OutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kFileNameFieldNumber = 1,
};
// optional string file_name = 1;
bool has_file_name() const;
private:
bool _internal_has_file_name() const;
public:
void clear_file_name();
const std::string& file_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_file_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_file_name();
PROTOBUF_NODISCARD std::string* release_file_name();
void set_allocated_file_name(std::string* file_name);
private:
const std::string& _internal_file_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_name(const std::string& value);
std::string* _internal_mutable_file_name();
public:
// @@protoc_insertion_point(class_scope:caffe.HDF5OutputParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_name_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class HingeLossParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.HingeLossParameter) */ {
public:
inline HingeLossParameter() : HingeLossParameter(nullptr) {}
~HingeLossParameter() override;
explicit constexpr HingeLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
HingeLossParameter(const HingeLossParameter& from);
HingeLossParameter(HingeLossParameter&& from) noexcept
: HingeLossParameter() {
*this = ::std::move(from);
}
inline HingeLossParameter& operator=(const HingeLossParameter& from) {
CopyFrom(from);
return *this;
}
inline HingeLossParameter& operator=(HingeLossParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const HingeLossParameter& default_instance() {
return *internal_default_instance();
}
static inline const HingeLossParameter* internal_default_instance() {
return reinterpret_cast<const HingeLossParameter*>(
&_HingeLossParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
63;
friend void swap(HingeLossParameter& a, HingeLossParameter& b) {
a.Swap(&b);
}
inline void Swap(HingeLossParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(HingeLossParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
HingeLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<HingeLossParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const HingeLossParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const HingeLossParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(HingeLossParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.HingeLossParameter";
}
protected:
explicit HingeLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef HingeLossParameter_Norm Norm;
static constexpr Norm L1 =
HingeLossParameter_Norm_L1;
static constexpr Norm L2 =
HingeLossParameter_Norm_L2;
static inline bool Norm_IsValid(int value) {
return HingeLossParameter_Norm_IsValid(value);
}
static constexpr Norm Norm_MIN =
HingeLossParameter_Norm_Norm_MIN;
static constexpr Norm Norm_MAX =
HingeLossParameter_Norm_Norm_MAX;
static constexpr int Norm_ARRAYSIZE =
HingeLossParameter_Norm_Norm_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Norm_descriptor() {
return HingeLossParameter_Norm_descriptor();
}
template<typename T>
static inline const std::string& Norm_Name(T enum_t_value) {
static_assert(::std::is_same<T, Norm>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Norm_Name.");
return HingeLossParameter_Norm_Name(enum_t_value);
}
static inline bool Norm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Norm* value) {
return HingeLossParameter_Norm_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kNormFieldNumber = 1,
};
// optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1];
bool has_norm() const;
private:
bool _internal_has_norm() const;
public:
void clear_norm();
::caffe::HingeLossParameter_Norm norm() const;
void set_norm(::caffe::HingeLossParameter_Norm value);
private:
::caffe::HingeLossParameter_Norm _internal_norm() const;
void _internal_set_norm(::caffe::HingeLossParameter_Norm value);
public:
// @@protoc_insertion_point(class_scope:caffe.HingeLossParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int norm_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ImageDataParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ImageDataParameter) */ {
public:
inline ImageDataParameter() : ImageDataParameter(nullptr) {}
~ImageDataParameter() override;
explicit constexpr ImageDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ImageDataParameter(const ImageDataParameter& from);
ImageDataParameter(ImageDataParameter&& from) noexcept
: ImageDataParameter() {
*this = ::std::move(from);
}
inline ImageDataParameter& operator=(const ImageDataParameter& from) {
CopyFrom(from);
return *this;
}
inline ImageDataParameter& operator=(ImageDataParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ImageDataParameter& default_instance() {
return *internal_default_instance();
}
static inline const ImageDataParameter* internal_default_instance() {
return reinterpret_cast<const ImageDataParameter*>(
&_ImageDataParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
64;
friend void swap(ImageDataParameter& a, ImageDataParameter& b) {
a.Swap(&b);
}
inline void Swap(ImageDataParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ImageDataParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ImageDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ImageDataParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ImageDataParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ImageDataParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ImageDataParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ImageDataParameter";
}
protected:
explicit ImageDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSourceFieldNumber = 1,
kMeanFileFieldNumber = 3,
kRootFolderFieldNumber = 12,
kCropSizeFieldNumber = 5,
kRandSkipFieldNumber = 7,
kShuffleFieldNumber = 8,
kMirrorFieldNumber = 6,
kNewHeightFieldNumber = 9,
kNewWidthFieldNumber = 10,
kAttNumFieldNumber = 14,
kScaleFieldNumber = 2,
kBatchSizeFieldNumber = 4,
kIsColorFieldNumber = 11,
kLabelNumFieldNumber = 13,
};
// optional string source = 1;
bool has_source() const;
private:
bool _internal_has_source() const;
public:
void clear_source();
const std::string& source() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_source(ArgT0&& arg0, ArgT... args);
std::string* mutable_source();
PROTOBUF_NODISCARD std::string* release_source();
void set_allocated_source(std::string* source);
private:
const std::string& _internal_source() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
std::string* _internal_mutable_source();
public:
// optional string mean_file = 3;
bool has_mean_file() const;
private:
bool _internal_has_mean_file() const;
public:
void clear_mean_file();
const std::string& mean_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_mean_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_mean_file();
PROTOBUF_NODISCARD std::string* release_mean_file();
void set_allocated_mean_file(std::string* mean_file);
private:
const std::string& _internal_mean_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value);
std::string* _internal_mutable_mean_file();
public:
// optional string root_folder = 12 [default = ""];
bool has_root_folder() const;
private:
bool _internal_has_root_folder() const;
public:
void clear_root_folder();
const std::string& root_folder() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_root_folder(ArgT0&& arg0, ArgT... args);
std::string* mutable_root_folder();
PROTOBUF_NODISCARD std::string* release_root_folder();
void set_allocated_root_folder(std::string* root_folder);
private:
const std::string& _internal_root_folder() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_root_folder(const std::string& value);
std::string* _internal_mutable_root_folder();
public:
// optional uint32 crop_size = 5 [default = 0];
bool has_crop_size() const;
private:
bool _internal_has_crop_size() const;
public:
void clear_crop_size();
uint32_t crop_size() const;
void set_crop_size(uint32_t value);
private:
uint32_t _internal_crop_size() const;
void _internal_set_crop_size(uint32_t value);
public:
// optional uint32 rand_skip = 7 [default = 0];
bool has_rand_skip() const;
private:
bool _internal_has_rand_skip() const;
public:
void clear_rand_skip();
uint32_t rand_skip() const;
void set_rand_skip(uint32_t value);
private:
uint32_t _internal_rand_skip() const;
void _internal_set_rand_skip(uint32_t value);
public:
// optional bool shuffle = 8 [default = false];
bool has_shuffle() const;
private:
bool _internal_has_shuffle() const;
public:
void clear_shuffle();
bool shuffle() const;
void set_shuffle(bool value);
private:
bool _internal_shuffle() const;
void _internal_set_shuffle(bool value);
public:
// optional bool mirror = 6 [default = false];
bool has_mirror() const;
private:
bool _internal_has_mirror() const;
public:
void clear_mirror();
bool mirror() const;
void set_mirror(bool value);
private:
bool _internal_mirror() const;
void _internal_set_mirror(bool value);
public:
// optional uint32 new_height = 9 [default = 0];
bool has_new_height() const;
private:
bool _internal_has_new_height() const;
public:
void clear_new_height();
uint32_t new_height() const;
void set_new_height(uint32_t value);
private:
uint32_t _internal_new_height() const;
void _internal_set_new_height(uint32_t value);
public:
// optional uint32 new_width = 10 [default = 0];
bool has_new_width() const;
private:
bool _internal_has_new_width() const;
public:
void clear_new_width();
uint32_t new_width() const;
void set_new_width(uint32_t value);
private:
uint32_t _internal_new_width() const;
void _internal_set_new_width(uint32_t value);
public:
// optional uint32 att_num = 14 [default = 1];
bool has_att_num() const;
private:
bool _internal_has_att_num() const;
public:
void clear_att_num();
uint32_t att_num() const;
void set_att_num(uint32_t value);
private:
uint32_t _internal_att_num() const;
void _internal_set_att_num(uint32_t value);
public:
// optional float scale = 2 [default = 1];
bool has_scale() const;
private:
bool _internal_has_scale() const;
public:
void clear_scale();
float scale() const;
void set_scale(float value);
private:
float _internal_scale() const;
void _internal_set_scale(float value);
public:
// optional uint32 batch_size = 4 [default = 1];
bool has_batch_size() const;
private:
bool _internal_has_batch_size() const;
public:
void clear_batch_size();
uint32_t batch_size() const;
void set_batch_size(uint32_t value);
private:
uint32_t _internal_batch_size() const;
void _internal_set_batch_size(uint32_t value);
public:
// optional bool is_color = 11 [default = true];
bool has_is_color() const;
private:
bool _internal_has_is_color() const;
public:
void clear_is_color();
bool is_color() const;
void set_is_color(bool value);
private:
bool _internal_is_color() const;
void _internal_set_is_color(bool value);
public:
// optional uint32 label_num = 13 [default = 1];
bool has_label_num() const;
private:
bool _internal_has_label_num() const;
public:
void clear_label_num();
uint32_t label_num() const;
void set_label_num(uint32_t value);
private:
uint32_t _internal_label_num() const;
void _internal_set_label_num(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.ImageDataParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_folder_;
uint32_t crop_size_;
uint32_t rand_skip_;
bool shuffle_;
bool mirror_;
uint32_t new_height_;
uint32_t new_width_;
uint32_t att_num_;
float scale_;
uint32_t batch_size_;
bool is_color_;
uint32_t label_num_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class InfogainLossParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.InfogainLossParameter) */ {
public:
inline InfogainLossParameter() : InfogainLossParameter(nullptr) {}
~InfogainLossParameter() override;
explicit constexpr InfogainLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
InfogainLossParameter(const InfogainLossParameter& from);
InfogainLossParameter(InfogainLossParameter&& from) noexcept
: InfogainLossParameter() {
*this = ::std::move(from);
}
inline InfogainLossParameter& operator=(const InfogainLossParameter& from) {
CopyFrom(from);
return *this;
}
inline InfogainLossParameter& operator=(InfogainLossParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const InfogainLossParameter& default_instance() {
return *internal_default_instance();
}
static inline const InfogainLossParameter* internal_default_instance() {
return reinterpret_cast<const InfogainLossParameter*>(
&_InfogainLossParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
65;
friend void swap(InfogainLossParameter& a, InfogainLossParameter& b) {
a.Swap(&b);
}
inline void Swap(InfogainLossParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(InfogainLossParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
InfogainLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<InfogainLossParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const InfogainLossParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const InfogainLossParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(InfogainLossParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.InfogainLossParameter";
}
protected:
explicit InfogainLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSourceFieldNumber = 1,
kAxisFieldNumber = 2,
};
// optional string source = 1;
bool has_source() const;
private:
bool _internal_has_source() const;
public:
void clear_source();
const std::string& source() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_source(ArgT0&& arg0, ArgT... args);
std::string* mutable_source();
PROTOBUF_NODISCARD std::string* release_source();
void set_allocated_source(std::string* source);
private:
const std::string& _internal_source() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
std::string* _internal_mutable_source();
public:
// optional int32 axis = 2 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.InfogainLossParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
int32_t axis_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class InnerProductParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.InnerProductParameter) */ {
public:
inline InnerProductParameter() : InnerProductParameter(nullptr) {}
~InnerProductParameter() override;
explicit constexpr InnerProductParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
InnerProductParameter(const InnerProductParameter& from);
InnerProductParameter(InnerProductParameter&& from) noexcept
: InnerProductParameter() {
*this = ::std::move(from);
}
inline InnerProductParameter& operator=(const InnerProductParameter& from) {
CopyFrom(from);
return *this;
}
inline InnerProductParameter& operator=(InnerProductParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const InnerProductParameter& default_instance() {
return *internal_default_instance();
}
static inline const InnerProductParameter* internal_default_instance() {
return reinterpret_cast<const InnerProductParameter*>(
&_InnerProductParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
66;
friend void swap(InnerProductParameter& a, InnerProductParameter& b) {
a.Swap(&b);
}
inline void Swap(InnerProductParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(InnerProductParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
InnerProductParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<InnerProductParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const InnerProductParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const InnerProductParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(InnerProductParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.InnerProductParameter";
}
protected:
explicit InnerProductParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kWeightFillerFieldNumber = 3,
kBiasFillerFieldNumber = 4,
kNumOutputFieldNumber = 1,
kTransposeFieldNumber = 6,
kParamqFieldNumber = 7,
kParamsFieldNumber = 8,
kScaleInFieldNumber = 9,
kScaleOutFieldNumber = 10,
kBiasTermFieldNumber = 2,
kAxisFieldNumber = 5,
kAMinFieldNumber = 11,
kAMaxFieldNumber = 12,
};
// optional .caffe.FillerParameter weight_filler = 3;
bool has_weight_filler() const;
private:
bool _internal_has_weight_filler() const;
public:
void clear_weight_filler();
const ::caffe::FillerParameter& weight_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_weight_filler();
::caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);
private:
const ::caffe::FillerParameter& _internal_weight_filler() const;
::caffe::FillerParameter* _internal_mutable_weight_filler();
public:
void unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler);
::caffe::FillerParameter* unsafe_arena_release_weight_filler();
// optional .caffe.FillerParameter bias_filler = 4;
bool has_bias_filler() const;
private:
bool _internal_has_bias_filler() const;
public:
void clear_bias_filler();
const ::caffe::FillerParameter& bias_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_bias_filler();
::caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);
private:
const ::caffe::FillerParameter& _internal_bias_filler() const;
::caffe::FillerParameter* _internal_mutable_bias_filler();
public:
void unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler);
::caffe::FillerParameter* unsafe_arena_release_bias_filler();
// optional uint32 num_output = 1;
bool has_num_output() const;
private:
bool _internal_has_num_output() const;
public:
void clear_num_output();
uint32_t num_output() const;
void set_num_output(uint32_t value);
private:
uint32_t _internal_num_output() const;
void _internal_set_num_output(uint32_t value);
public:
// optional bool transpose = 6 [default = false];
bool has_transpose() const;
private:
bool _internal_has_transpose() const;
public:
void clear_transpose();
bool transpose() const;
void set_transpose(bool value);
private:
bool _internal_transpose() const;
void _internal_set_transpose(bool value);
public:
// optional uint32 paramq = 7 [default = 0];
bool has_paramq() const;
private:
bool _internal_has_paramq() const;
public:
void clear_paramq();
uint32_t paramq() const;
void set_paramq(uint32_t value);
private:
uint32_t _internal_paramq() const;
void _internal_set_paramq(uint32_t value);
public:
// optional float params = 8 [default = 0];
bool has_params() const;
private:
bool _internal_has_params() const;
public:
void clear_params();
float params() const;
void set_params(float value);
private:
float _internal_params() const;
void _internal_set_params(float value);
public:
// optional float scale_in = 9;
bool has_scale_in() const;
private:
bool _internal_has_scale_in() const;
public:
void clear_scale_in();
float scale_in() const;
void set_scale_in(float value);
private:
float _internal_scale_in() const;
void _internal_set_scale_in(float value);
public:
// optional float scale_out = 10;
bool has_scale_out() const;
private:
bool _internal_has_scale_out() const;
public:
void clear_scale_out();
float scale_out() const;
void set_scale_out(float value);
private:
float _internal_scale_out() const;
void _internal_set_scale_out(float value);
public:
// optional bool bias_term = 2 [default = true];
bool has_bias_term() const;
private:
bool _internal_has_bias_term() const;
public:
void clear_bias_term();
bool bias_term() const;
void set_bias_term(bool value);
private:
bool _internal_bias_term() const;
void _internal_set_bias_term(bool value);
public:
// optional int32 axis = 5 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// optional int32 a_min = 11 [default = -128];
bool has_a_min() const;
private:
bool _internal_has_a_min() const;
public:
void clear_a_min();
int32_t a_min() const;
void set_a_min(int32_t value);
private:
int32_t _internal_a_min() const;
void _internal_set_a_min(int32_t value);
public:
// optional int32 a_max = 12 [default = 127];
bool has_a_max() const;
private:
bool _internal_has_a_max() const;
public:
void clear_a_max();
int32_t a_max() const;
void set_a_max(int32_t value);
private:
int32_t _internal_a_max() const;
void _internal_set_a_max(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.InnerProductParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* weight_filler_;
::caffe::FillerParameter* bias_filler_;
uint32_t num_output_;
bool transpose_;
uint32_t paramq_;
float params_;
float scale_in_;
float scale_out_;
bool bias_term_;
int32_t axis_;
int32_t a_min_;
int32_t a_max_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class InputParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.InputParameter) */ {
public:
inline InputParameter() : InputParameter(nullptr) {}
~InputParameter() override;
explicit constexpr InputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
InputParameter(const InputParameter& from);
InputParameter(InputParameter&& from) noexcept
: InputParameter() {
*this = ::std::move(from);
}
inline InputParameter& operator=(const InputParameter& from) {
CopyFrom(from);
return *this;
}
inline InputParameter& operator=(InputParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const InputParameter& default_instance() {
return *internal_default_instance();
}
static inline const InputParameter* internal_default_instance() {
return reinterpret_cast<const InputParameter*>(
&_InputParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
67;
friend void swap(InputParameter& a, InputParameter& b) {
a.Swap(&b);
}
inline void Swap(InputParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(InputParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
InputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<InputParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const InputParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const InputParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(InputParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.InputParameter";
}
protected:
explicit InputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShapeFieldNumber = 1,
};
// repeated .caffe.BlobShape shape = 1;
int shape_size() const;
private:
int _internal_shape_size() const;
public:
void clear_shape();
::caffe::BlobShape* mutable_shape(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >*
mutable_shape();
private:
const ::caffe::BlobShape& _internal_shape(int index) const;
::caffe::BlobShape* _internal_add_shape();
public:
const ::caffe::BlobShape& shape(int index) const;
::caffe::BlobShape* add_shape();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >&
shape() const;
// @@protoc_insertion_point(class_scope:caffe.InputParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape > shape_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class LogParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.LogParameter) */ {
public:
inline LogParameter() : LogParameter(nullptr) {}
~LogParameter() override;
explicit constexpr LogParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
LogParameter(const LogParameter& from);
LogParameter(LogParameter&& from) noexcept
: LogParameter() {
*this = ::std::move(from);
}
inline LogParameter& operator=(const LogParameter& from) {
CopyFrom(from);
return *this;
}
inline LogParameter& operator=(LogParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const LogParameter& default_instance() {
return *internal_default_instance();
}
static inline const LogParameter* internal_default_instance() {
return reinterpret_cast<const LogParameter*>(
&_LogParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
68;
friend void swap(LogParameter& a, LogParameter& b) {
a.Swap(&b);
}
inline void Swap(LogParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(LogParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
LogParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<LogParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const LogParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const LogParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(LogParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.LogParameter";
}
protected:
explicit LogParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShiftFieldNumber = 3,
kBaseFieldNumber = 1,
kScaleFieldNumber = 2,
};
// optional float shift = 3 [default = 0];
bool has_shift() const;
private:
bool _internal_has_shift() const;
public:
void clear_shift();
float shift() const;
void set_shift(float value);
private:
float _internal_shift() const;
void _internal_set_shift(float value);
public:
// optional float base = 1 [default = -1];
bool has_base() const;
private:
bool _internal_has_base() const;
public:
void clear_base();
float base() const;
void set_base(float value);
private:
float _internal_base() const;
void _internal_set_base(float value);
public:
// optional float scale = 2 [default = 1];
bool has_scale() const;
private:
bool _internal_has_scale() const;
public:
void clear_scale();
float scale() const;
void set_scale(float value);
private:
float _internal_scale() const;
void _internal_set_scale(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.LogParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float shift_;
float base_;
float scale_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class LRNParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.LRNParameter) */ {
public:
inline LRNParameter() : LRNParameter(nullptr) {}
~LRNParameter() override;
explicit constexpr LRNParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
LRNParameter(const LRNParameter& from);
LRNParameter(LRNParameter&& from) noexcept
: LRNParameter() {
*this = ::std::move(from);
}
inline LRNParameter& operator=(const LRNParameter& from) {
CopyFrom(from);
return *this;
}
inline LRNParameter& operator=(LRNParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const LRNParameter& default_instance() {
return *internal_default_instance();
}
static inline const LRNParameter* internal_default_instance() {
return reinterpret_cast<const LRNParameter*>(
&_LRNParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
69;
friend void swap(LRNParameter& a, LRNParameter& b) {
a.Swap(&b);
}
inline void Swap(LRNParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(LRNParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
LRNParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<LRNParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const LRNParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const LRNParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(LRNParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.LRNParameter";
}
protected:
explicit LRNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef LRNParameter_NormRegion NormRegion;
static constexpr NormRegion ACROSS_CHANNELS =
LRNParameter_NormRegion_ACROSS_CHANNELS;
static constexpr NormRegion WITHIN_CHANNEL =
LRNParameter_NormRegion_WITHIN_CHANNEL;
static inline bool NormRegion_IsValid(int value) {
return LRNParameter_NormRegion_IsValid(value);
}
static constexpr NormRegion NormRegion_MIN =
LRNParameter_NormRegion_NormRegion_MIN;
static constexpr NormRegion NormRegion_MAX =
LRNParameter_NormRegion_NormRegion_MAX;
static constexpr int NormRegion_ARRAYSIZE =
LRNParameter_NormRegion_NormRegion_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
NormRegion_descriptor() {
return LRNParameter_NormRegion_descriptor();
}
template<typename T>
static inline const std::string& NormRegion_Name(T enum_t_value) {
static_assert(::std::is_same<T, NormRegion>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function NormRegion_Name.");
return LRNParameter_NormRegion_Name(enum_t_value);
}
static inline bool NormRegion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
NormRegion* value) {
return LRNParameter_NormRegion_Parse(name, value);
}
typedef LRNParameter_Engine Engine;
static constexpr Engine DEFAULT =
LRNParameter_Engine_DEFAULT;
static constexpr Engine CAFFE =
LRNParameter_Engine_CAFFE;
static constexpr Engine CUDNN =
LRNParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return LRNParameter_Engine_IsValid(value);
}
static constexpr Engine Engine_MIN =
LRNParameter_Engine_Engine_MIN;
static constexpr Engine Engine_MAX =
LRNParameter_Engine_Engine_MAX;
static constexpr int Engine_ARRAYSIZE =
LRNParameter_Engine_Engine_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Engine_descriptor() {
return LRNParameter_Engine_descriptor();
}
template<typename T>
static inline const std::string& Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Engine_Name.");
return LRNParameter_Engine_Name(enum_t_value);
}
static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Engine* value) {
return LRNParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kNormRegionFieldNumber = 4,
kEngineFieldNumber = 6,
kLocalSizeFieldNumber = 1,
kAlphaFieldNumber = 2,
kBetaFieldNumber = 3,
kKFieldNumber = 5,
};
// optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
bool has_norm_region() const;
private:
bool _internal_has_norm_region() const;
public:
void clear_norm_region();
::caffe::LRNParameter_NormRegion norm_region() const;
void set_norm_region(::caffe::LRNParameter_NormRegion value);
private:
::caffe::LRNParameter_NormRegion _internal_norm_region() const;
void _internal_set_norm_region(::caffe::LRNParameter_NormRegion value);
public:
// optional .caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
bool has_engine() const;
private:
bool _internal_has_engine() const;
public:
void clear_engine();
::caffe::LRNParameter_Engine engine() const;
void set_engine(::caffe::LRNParameter_Engine value);
private:
::caffe::LRNParameter_Engine _internal_engine() const;
void _internal_set_engine(::caffe::LRNParameter_Engine value);
public:
// optional uint32 local_size = 1 [default = 5];
bool has_local_size() const;
private:
bool _internal_has_local_size() const;
public:
void clear_local_size();
uint32_t local_size() const;
void set_local_size(uint32_t value);
private:
uint32_t _internal_local_size() const;
void _internal_set_local_size(uint32_t value);
public:
// optional float alpha = 2 [default = 1];
bool has_alpha() const;
private:
bool _internal_has_alpha() const;
public:
void clear_alpha();
float alpha() const;
void set_alpha(float value);
private:
float _internal_alpha() const;
void _internal_set_alpha(float value);
public:
// optional float beta = 3 [default = 0.75];
bool has_beta() const;
private:
bool _internal_has_beta() const;
public:
void clear_beta();
float beta() const;
void set_beta(float value);
private:
float _internal_beta() const;
void _internal_set_beta(float value);
public:
// optional float k = 5 [default = 1];
bool has_k() const;
private:
bool _internal_has_k() const;
public:
void clear_k();
float k() const;
void set_k(float value);
private:
float _internal_k() const;
void _internal_set_k(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.LRNParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int norm_region_;
int engine_;
uint32_t local_size_;
float alpha_;
float beta_;
float k_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class MemoryDataParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.MemoryDataParameter) */ {
public:
inline MemoryDataParameter() : MemoryDataParameter(nullptr) {}
~MemoryDataParameter() override;
explicit constexpr MemoryDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
MemoryDataParameter(const MemoryDataParameter& from);
MemoryDataParameter(MemoryDataParameter&& from) noexcept
: MemoryDataParameter() {
*this = ::std::move(from);
}
inline MemoryDataParameter& operator=(const MemoryDataParameter& from) {
CopyFrom(from);
return *this;
}
inline MemoryDataParameter& operator=(MemoryDataParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const MemoryDataParameter& default_instance() {
return *internal_default_instance();
}
static inline const MemoryDataParameter* internal_default_instance() {
return reinterpret_cast<const MemoryDataParameter*>(
&_MemoryDataParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
70;
friend void swap(MemoryDataParameter& a, MemoryDataParameter& b) {
a.Swap(&b);
}
inline void Swap(MemoryDataParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MemoryDataParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
MemoryDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<MemoryDataParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const MemoryDataParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const MemoryDataParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MemoryDataParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.MemoryDataParameter";
}
protected:
explicit MemoryDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBatchSizeFieldNumber = 1,
kChannelsFieldNumber = 2,
kHeightFieldNumber = 3,
kWidthFieldNumber = 4,
};
// optional uint32 batch_size = 1;
bool has_batch_size() const;
private:
bool _internal_has_batch_size() const;
public:
void clear_batch_size();
uint32_t batch_size() const;
void set_batch_size(uint32_t value);
private:
uint32_t _internal_batch_size() const;
void _internal_set_batch_size(uint32_t value);
public:
// optional uint32 channels = 2;
bool has_channels() const;
private:
bool _internal_has_channels() const;
public:
void clear_channels();
uint32_t channels() const;
void set_channels(uint32_t value);
private:
uint32_t _internal_channels() const;
void _internal_set_channels(uint32_t value);
public:
// optional uint32 height = 3;
bool has_height() const;
private:
bool _internal_has_height() const;
public:
void clear_height();
uint32_t height() const;
void set_height(uint32_t value);
private:
uint32_t _internal_height() const;
void _internal_set_height(uint32_t value);
public:
// optional uint32 width = 4;
bool has_width() const;
private:
bool _internal_has_width() const;
public:
void clear_width();
uint32_t width() const;
void set_width(uint32_t value);
private:
uint32_t _internal_width() const;
void _internal_set_width(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.MemoryDataParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t batch_size_;
uint32_t channels_;
uint32_t height_;
uint32_t width_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class MultiBoxLossParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.MultiBoxLossParameter) */ {
public:
inline MultiBoxLossParameter() : MultiBoxLossParameter(nullptr) {}
~MultiBoxLossParameter() override;
explicit constexpr MultiBoxLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
MultiBoxLossParameter(const MultiBoxLossParameter& from);
MultiBoxLossParameter(MultiBoxLossParameter&& from) noexcept
: MultiBoxLossParameter() {
*this = ::std::move(from);
}
inline MultiBoxLossParameter& operator=(const MultiBoxLossParameter& from) {
CopyFrom(from);
return *this;
}
inline MultiBoxLossParameter& operator=(MultiBoxLossParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const MultiBoxLossParameter& default_instance() {
return *internal_default_instance();
}
static inline const MultiBoxLossParameter* internal_default_instance() {
return reinterpret_cast<const MultiBoxLossParameter*>(
&_MultiBoxLossParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
71;
friend void swap(MultiBoxLossParameter& a, MultiBoxLossParameter& b) {
a.Swap(&b);
}
inline void Swap(MultiBoxLossParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MultiBoxLossParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
MultiBoxLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<MultiBoxLossParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const MultiBoxLossParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const MultiBoxLossParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MultiBoxLossParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.MultiBoxLossParameter";
}
protected:
explicit MultiBoxLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef MultiBoxLossParameter_LocLossType LocLossType;
static constexpr LocLossType L2 =
MultiBoxLossParameter_LocLossType_L2;
static constexpr LocLossType SMOOTH_L1 =
MultiBoxLossParameter_LocLossType_SMOOTH_L1;
static inline bool LocLossType_IsValid(int value) {
return MultiBoxLossParameter_LocLossType_IsValid(value);
}
static constexpr LocLossType LocLossType_MIN =
MultiBoxLossParameter_LocLossType_LocLossType_MIN;
static constexpr LocLossType LocLossType_MAX =
MultiBoxLossParameter_LocLossType_LocLossType_MAX;
static constexpr int LocLossType_ARRAYSIZE =
MultiBoxLossParameter_LocLossType_LocLossType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
LocLossType_descriptor() {
return MultiBoxLossParameter_LocLossType_descriptor();
}
template<typename T>
static inline const std::string& LocLossType_Name(T enum_t_value) {
static_assert(::std::is_same<T, LocLossType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function LocLossType_Name.");
return MultiBoxLossParameter_LocLossType_Name(enum_t_value);
}
static inline bool LocLossType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
LocLossType* value) {
return MultiBoxLossParameter_LocLossType_Parse(name, value);
}
typedef MultiBoxLossParameter_ConfLossType ConfLossType;
static constexpr ConfLossType SOFTMAX =
MultiBoxLossParameter_ConfLossType_SOFTMAX;
static constexpr ConfLossType LOGISTIC =
MultiBoxLossParameter_ConfLossType_LOGISTIC;
static inline bool ConfLossType_IsValid(int value) {
return MultiBoxLossParameter_ConfLossType_IsValid(value);
}
static constexpr ConfLossType ConfLossType_MIN =
MultiBoxLossParameter_ConfLossType_ConfLossType_MIN;
static constexpr ConfLossType ConfLossType_MAX =
MultiBoxLossParameter_ConfLossType_ConfLossType_MAX;
static constexpr int ConfLossType_ARRAYSIZE =
MultiBoxLossParameter_ConfLossType_ConfLossType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
ConfLossType_descriptor() {
return MultiBoxLossParameter_ConfLossType_descriptor();
}
template<typename T>
static inline const std::string& ConfLossType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConfLossType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConfLossType_Name.");
return MultiBoxLossParameter_ConfLossType_Name(enum_t_value);
}
static inline bool ConfLossType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
ConfLossType* value) {
return MultiBoxLossParameter_ConfLossType_Parse(name, value);
}
typedef MultiBoxLossParameter_MatchType MatchType;
static constexpr MatchType BIPARTITE =
MultiBoxLossParameter_MatchType_BIPARTITE;
static constexpr MatchType PER_PREDICTION =
MultiBoxLossParameter_MatchType_PER_PREDICTION;
static inline bool MatchType_IsValid(int value) {
return MultiBoxLossParameter_MatchType_IsValid(value);
}
static constexpr MatchType MatchType_MIN =
MultiBoxLossParameter_MatchType_MatchType_MIN;
static constexpr MatchType MatchType_MAX =
MultiBoxLossParameter_MatchType_MatchType_MAX;
static constexpr int MatchType_ARRAYSIZE =
MultiBoxLossParameter_MatchType_MatchType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
MatchType_descriptor() {
return MultiBoxLossParameter_MatchType_descriptor();
}
template<typename T>
static inline const std::string& MatchType_Name(T enum_t_value) {
static_assert(::std::is_same<T, MatchType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MatchType_Name.");
return MultiBoxLossParameter_MatchType_Name(enum_t_value);
}
static inline bool MatchType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
MatchType* value) {
return MultiBoxLossParameter_MatchType_Parse(name, value);
}
typedef MultiBoxLossParameter_MiningType MiningType;
static constexpr MiningType NONE =
MultiBoxLossParameter_MiningType_NONE;
static constexpr MiningType MAX_NEGATIVE =
MultiBoxLossParameter_MiningType_MAX_NEGATIVE;
static constexpr MiningType HARD_EXAMPLE =
MultiBoxLossParameter_MiningType_HARD_EXAMPLE;
static inline bool MiningType_IsValid(int value) {
return MultiBoxLossParameter_MiningType_IsValid(value);
}
static constexpr MiningType MiningType_MIN =
MultiBoxLossParameter_MiningType_MiningType_MIN;
static constexpr MiningType MiningType_MAX =
MultiBoxLossParameter_MiningType_MiningType_MAX;
static constexpr int MiningType_ARRAYSIZE =
MultiBoxLossParameter_MiningType_MiningType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
MiningType_descriptor() {
return MultiBoxLossParameter_MiningType_descriptor();
}
template<typename T>
static inline const std::string& MiningType_Name(T enum_t_value) {
static_assert(::std::is_same<T, MiningType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MiningType_Name.");
return MultiBoxLossParameter_MiningType_Name(enum_t_value);
}
static inline bool MiningType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
MiningType* value) {
return MultiBoxLossParameter_MiningType_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kNmsParamFieldNumber = 21,
kConfLossTypeFieldNumber = 2,
kNumClassesFieldNumber = 4,
kBackgroundLabelIdFieldNumber = 9,
kDoNegMiningFieldNumber = 11,
kEncodeVarianceInTargetFieldNumber = 16,
kMapObjectToAgnosticFieldNumber = 17,
kIgnoreCrossBoundaryBboxFieldNumber = 18,
kBpInsideFieldNumber = 19,
kUsePriorForNmsFieldNumber = 23,
kLocLossTypeFieldNumber = 1,
kLocWeightFieldNumber = 3,
kMatchTypeFieldNumber = 6,
kOverlapThresholdFieldNumber = 7,
kShareLocationFieldNumber = 5,
kUsePriorForMatchingFieldNumber = 8,
kUseDifficultGtFieldNumber = 10,
kNegPosRatioFieldNumber = 12,
kNegOverlapFieldNumber = 13,
kCodeTypeFieldNumber = 14,
kMiningTypeFieldNumber = 20,
kSampleSizeFieldNumber = 22,
};
// optional .caffe.NonMaximumSuppressionParameter nms_param = 21;
bool has_nms_param() const;
private:
bool _internal_has_nms_param() const;
public:
void clear_nms_param();
const ::caffe::NonMaximumSuppressionParameter& nms_param() const;
PROTOBUF_NODISCARD ::caffe::NonMaximumSuppressionParameter* release_nms_param();
::caffe::NonMaximumSuppressionParameter* mutable_nms_param();
void set_allocated_nms_param(::caffe::NonMaximumSuppressionParameter* nms_param);
private:
const ::caffe::NonMaximumSuppressionParameter& _internal_nms_param() const;
::caffe::NonMaximumSuppressionParameter* _internal_mutable_nms_param();
public:
void unsafe_arena_set_allocated_nms_param(
::caffe::NonMaximumSuppressionParameter* nms_param);
::caffe::NonMaximumSuppressionParameter* unsafe_arena_release_nms_param();
// optional .caffe.MultiBoxLossParameter.ConfLossType conf_loss_type = 2 [default = SOFTMAX];
bool has_conf_loss_type() const;
private:
bool _internal_has_conf_loss_type() const;
public:
void clear_conf_loss_type();
::caffe::MultiBoxLossParameter_ConfLossType conf_loss_type() const;
void set_conf_loss_type(::caffe::MultiBoxLossParameter_ConfLossType value);
private:
::caffe::MultiBoxLossParameter_ConfLossType _internal_conf_loss_type() const;
void _internal_set_conf_loss_type(::caffe::MultiBoxLossParameter_ConfLossType value);
public:
// optional uint32 num_classes = 4;
bool has_num_classes() const;
private:
bool _internal_has_num_classes() const;
public:
void clear_num_classes();
uint32_t num_classes() const;
void set_num_classes(uint32_t value);
private:
uint32_t _internal_num_classes() const;
void _internal_set_num_classes(uint32_t value);
public:
// optional uint32 background_label_id = 9 [default = 0];
bool has_background_label_id() const;
private:
bool _internal_has_background_label_id() const;
public:
void clear_background_label_id();
uint32_t background_label_id() const;
void set_background_label_id(uint32_t value);
private:
uint32_t _internal_background_label_id() const;
void _internal_set_background_label_id(uint32_t value);
public:
// optional bool do_neg_mining = 11;
bool has_do_neg_mining() const;
private:
bool _internal_has_do_neg_mining() const;
public:
void clear_do_neg_mining();
bool do_neg_mining() const;
void set_do_neg_mining(bool value);
private:
bool _internal_do_neg_mining() const;
void _internal_set_do_neg_mining(bool value);
public:
// optional bool encode_variance_in_target = 16 [default = false];
bool has_encode_variance_in_target() const;
private:
bool _internal_has_encode_variance_in_target() const;
public:
void clear_encode_variance_in_target();
bool encode_variance_in_target() const;
void set_encode_variance_in_target(bool value);
private:
bool _internal_encode_variance_in_target() const;
void _internal_set_encode_variance_in_target(bool value);
public:
// optional bool map_object_to_agnostic = 17 [default = false];
bool has_map_object_to_agnostic() const;
private:
bool _internal_has_map_object_to_agnostic() const;
public:
void clear_map_object_to_agnostic();
bool map_object_to_agnostic() const;
void set_map_object_to_agnostic(bool value);
private:
bool _internal_map_object_to_agnostic() const;
void _internal_set_map_object_to_agnostic(bool value);
public:
// optional bool ignore_cross_boundary_bbox = 18 [default = false];
bool has_ignore_cross_boundary_bbox() const;
private:
bool _internal_has_ignore_cross_boundary_bbox() const;
public:
void clear_ignore_cross_boundary_bbox();
bool ignore_cross_boundary_bbox() const;
void set_ignore_cross_boundary_bbox(bool value);
private:
bool _internal_ignore_cross_boundary_bbox() const;
void _internal_set_ignore_cross_boundary_bbox(bool value);
public:
// optional bool bp_inside = 19 [default = false];
bool has_bp_inside() const;
private:
bool _internal_has_bp_inside() const;
public:
void clear_bp_inside();
bool bp_inside() const;
void set_bp_inside(bool value);
private:
bool _internal_bp_inside() const;
void _internal_set_bp_inside(bool value);
public:
// optional bool use_prior_for_nms = 23 [default = false];
bool has_use_prior_for_nms() const;
private:
bool _internal_has_use_prior_for_nms() const;
public:
void clear_use_prior_for_nms();
bool use_prior_for_nms() const;
void set_use_prior_for_nms(bool value);
private:
bool _internal_use_prior_for_nms() const;
void _internal_set_use_prior_for_nms(bool value);
public:
// optional .caffe.MultiBoxLossParameter.LocLossType loc_loss_type = 1 [default = SMOOTH_L1];
bool has_loc_loss_type() const;
private:
bool _internal_has_loc_loss_type() const;
public:
void clear_loc_loss_type();
::caffe::MultiBoxLossParameter_LocLossType loc_loss_type() const;
void set_loc_loss_type(::caffe::MultiBoxLossParameter_LocLossType value);
private:
::caffe::MultiBoxLossParameter_LocLossType _internal_loc_loss_type() const;
void _internal_set_loc_loss_type(::caffe::MultiBoxLossParameter_LocLossType value);
public:
// optional float loc_weight = 3 [default = 1];
bool has_loc_weight() const;
private:
bool _internal_has_loc_weight() const;
public:
void clear_loc_weight();
float loc_weight() const;
void set_loc_weight(float value);
private:
float _internal_loc_weight() const;
void _internal_set_loc_weight(float value);
public:
// optional .caffe.MultiBoxLossParameter.MatchType match_type = 6 [default = PER_PREDICTION];
bool has_match_type() const;
private:
bool _internal_has_match_type() const;
public:
void clear_match_type();
::caffe::MultiBoxLossParameter_MatchType match_type() const;
void set_match_type(::caffe::MultiBoxLossParameter_MatchType value);
private:
::caffe::MultiBoxLossParameter_MatchType _internal_match_type() const;
void _internal_set_match_type(::caffe::MultiBoxLossParameter_MatchType value);
public:
// optional float overlap_threshold = 7 [default = 0.5];
bool has_overlap_threshold() const;
private:
bool _internal_has_overlap_threshold() const;
public:
void clear_overlap_threshold();
float overlap_threshold() const;
void set_overlap_threshold(float value);
private:
float _internal_overlap_threshold() const;
void _internal_set_overlap_threshold(float value);
public:
// optional bool share_location = 5 [default = true];
bool has_share_location() const;
private:
bool _internal_has_share_location() const;
public:
void clear_share_location();
bool share_location() const;
void set_share_location(bool value);
private:
bool _internal_share_location() const;
void _internal_set_share_location(bool value);
public:
// optional bool use_prior_for_matching = 8 [default = true];
bool has_use_prior_for_matching() const;
private:
bool _internal_has_use_prior_for_matching() const;
public:
void clear_use_prior_for_matching();
bool use_prior_for_matching() const;
void set_use_prior_for_matching(bool value);
private:
bool _internal_use_prior_for_matching() const;
void _internal_set_use_prior_for_matching(bool value);
public:
// optional bool use_difficult_gt = 10 [default = true];
bool has_use_difficult_gt() const;
private:
bool _internal_has_use_difficult_gt() const;
public:
void clear_use_difficult_gt();
bool use_difficult_gt() const;
void set_use_difficult_gt(bool value);
private:
bool _internal_use_difficult_gt() const;
void _internal_set_use_difficult_gt(bool value);
public:
// optional float neg_pos_ratio = 12 [default = 3];
bool has_neg_pos_ratio() const;
private:
bool _internal_has_neg_pos_ratio() const;
public:
void clear_neg_pos_ratio();
float neg_pos_ratio() const;
void set_neg_pos_ratio(float value);
private:
float _internal_neg_pos_ratio() const;
void _internal_set_neg_pos_ratio(float value);
public:
// optional float neg_overlap = 13 [default = 0.5];
bool has_neg_overlap() const;
private:
bool _internal_has_neg_overlap() const;
public:
void clear_neg_overlap();
float neg_overlap() const;
void set_neg_overlap(float value);
private:
float _internal_neg_overlap() const;
void _internal_set_neg_overlap(float value);
public:
// optional .caffe.PriorBoxParameter.CodeType code_type = 14 [default = CORNER];
bool has_code_type() const;
private:
bool _internal_has_code_type() const;
public:
void clear_code_type();
::caffe::PriorBoxParameter_CodeType code_type() const;
void set_code_type(::caffe::PriorBoxParameter_CodeType value);
private:
::caffe::PriorBoxParameter_CodeType _internal_code_type() const;
void _internal_set_code_type(::caffe::PriorBoxParameter_CodeType value);
public:
// optional .caffe.MultiBoxLossParameter.MiningType mining_type = 20 [default = MAX_NEGATIVE];
bool has_mining_type() const;
private:
bool _internal_has_mining_type() const;
public:
void clear_mining_type();
::caffe::MultiBoxLossParameter_MiningType mining_type() const;
void set_mining_type(::caffe::MultiBoxLossParameter_MiningType value);
private:
::caffe::MultiBoxLossParameter_MiningType _internal_mining_type() const;
void _internal_set_mining_type(::caffe::MultiBoxLossParameter_MiningType value);
public:
// optional int32 sample_size = 22 [default = 64];
bool has_sample_size() const;
private:
bool _internal_has_sample_size() const;
public:
void clear_sample_size();
int32_t sample_size() const;
void set_sample_size(int32_t value);
private:
int32_t _internal_sample_size() const;
void _internal_set_sample_size(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.MultiBoxLossParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::NonMaximumSuppressionParameter* nms_param_;
int conf_loss_type_;
uint32_t num_classes_;
uint32_t background_label_id_;
bool do_neg_mining_;
bool encode_variance_in_target_;
bool map_object_to_agnostic_;
bool ignore_cross_boundary_bbox_;
bool bp_inside_;
bool use_prior_for_nms_;
int loc_loss_type_;
float loc_weight_;
int match_type_;
float overlap_threshold_;
bool share_location_;
bool use_prior_for_matching_;
bool use_difficult_gt_;
float neg_pos_ratio_;
float neg_overlap_;
int code_type_;
int mining_type_;
int32_t sample_size_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class MVNParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.MVNParameter) */ {
public:
inline MVNParameter() : MVNParameter(nullptr) {}
~MVNParameter() override;
explicit constexpr MVNParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
MVNParameter(const MVNParameter& from);
MVNParameter(MVNParameter&& from) noexcept
: MVNParameter() {
*this = ::std::move(from);
}
inline MVNParameter& operator=(const MVNParameter& from) {
CopyFrom(from);
return *this;
}
inline MVNParameter& operator=(MVNParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const MVNParameter& default_instance() {
return *internal_default_instance();
}
static inline const MVNParameter* internal_default_instance() {
return reinterpret_cast<const MVNParameter*>(
&_MVNParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
72;
friend void swap(MVNParameter& a, MVNParameter& b) {
a.Swap(&b);
}
inline void Swap(MVNParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MVNParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
MVNParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<MVNParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const MVNParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const MVNParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MVNParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.MVNParameter";
}
protected:
explicit MVNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kAcrossChannelsFieldNumber = 2,
kNormalizeVarianceFieldNumber = 1,
kEpsFieldNumber = 3,
};
// optional bool across_channels = 2 [default = false];
bool has_across_channels() const;
private:
bool _internal_has_across_channels() const;
public:
void clear_across_channels();
bool across_channels() const;
void set_across_channels(bool value);
private:
bool _internal_across_channels() const;
void _internal_set_across_channels(bool value);
public:
// optional bool normalize_variance = 1 [default = true];
bool has_normalize_variance() const;
private:
bool _internal_has_normalize_variance() const;
public:
void clear_normalize_variance();
bool normalize_variance() const;
void set_normalize_variance(bool value);
private:
bool _internal_normalize_variance() const;
void _internal_set_normalize_variance(bool value);
public:
// optional float eps = 3 [default = 1e-09];
bool has_eps() const;
private:
bool _internal_has_eps() const;
public:
void clear_eps();
float eps() const;
void set_eps(float value);
private:
float _internal_eps() const;
void _internal_set_eps(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.MVNParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
bool across_channels_;
bool normalize_variance_;
float eps_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class NormalizeParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.NormalizeParameter) */ {
public:
inline NormalizeParameter() : NormalizeParameter(nullptr) {}
~NormalizeParameter() override;
explicit constexpr NormalizeParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NormalizeParameter(const NormalizeParameter& from);
NormalizeParameter(NormalizeParameter&& from) noexcept
: NormalizeParameter() {
*this = ::std::move(from);
}
inline NormalizeParameter& operator=(const NormalizeParameter& from) {
CopyFrom(from);
return *this;
}
inline NormalizeParameter& operator=(NormalizeParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const NormalizeParameter& default_instance() {
return *internal_default_instance();
}
static inline const NormalizeParameter* internal_default_instance() {
return reinterpret_cast<const NormalizeParameter*>(
&_NormalizeParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
73;
friend void swap(NormalizeParameter& a, NormalizeParameter& b) {
a.Swap(&b);
}
inline void Swap(NormalizeParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(NormalizeParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NormalizeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NormalizeParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const NormalizeParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const NormalizeParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(NormalizeParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.NormalizeParameter";
}
protected:
explicit NormalizeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kScaleFillerFieldNumber = 2,
kAcrossSpatialFieldNumber = 1,
kChannelSharedFieldNumber = 3,
kEpsFieldNumber = 4,
};
// optional .caffe.FillerParameter scale_filler = 2;
bool has_scale_filler() const;
private:
bool _internal_has_scale_filler() const;
public:
void clear_scale_filler();
const ::caffe::FillerParameter& scale_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_scale_filler();
::caffe::FillerParameter* mutable_scale_filler();
void set_allocated_scale_filler(::caffe::FillerParameter* scale_filler);
private:
const ::caffe::FillerParameter& _internal_scale_filler() const;
::caffe::FillerParameter* _internal_mutable_scale_filler();
public:
void unsafe_arena_set_allocated_scale_filler(
::caffe::FillerParameter* scale_filler);
::caffe::FillerParameter* unsafe_arena_release_scale_filler();
// optional bool across_spatial = 1 [default = true];
bool has_across_spatial() const;
private:
bool _internal_has_across_spatial() const;
public:
void clear_across_spatial();
bool across_spatial() const;
void set_across_spatial(bool value);
private:
bool _internal_across_spatial() const;
void _internal_set_across_spatial(bool value);
public:
// optional bool channel_shared = 3 [default = true];
bool has_channel_shared() const;
private:
bool _internal_has_channel_shared() const;
public:
void clear_channel_shared();
bool channel_shared() const;
void set_channel_shared(bool value);
private:
bool _internal_channel_shared() const;
void _internal_set_channel_shared(bool value);
public:
// optional float eps = 4 [default = 1e-10];
bool has_eps() const;
private:
bool _internal_has_eps() const;
public:
void clear_eps();
float eps() const;
void set_eps(float value);
private:
float _internal_eps() const;
void _internal_set_eps(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.NormalizeParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* scale_filler_;
bool across_spatial_;
bool channel_shared_;
float eps_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ParameterParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ParameterParameter) */ {
public:
inline ParameterParameter() : ParameterParameter(nullptr) {}
~ParameterParameter() override;
explicit constexpr ParameterParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ParameterParameter(const ParameterParameter& from);
ParameterParameter(ParameterParameter&& from) noexcept
: ParameterParameter() {
*this = ::std::move(from);
}
inline ParameterParameter& operator=(const ParameterParameter& from) {
CopyFrom(from);
return *this;
}
inline ParameterParameter& operator=(ParameterParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ParameterParameter& default_instance() {
return *internal_default_instance();
}
static inline const ParameterParameter* internal_default_instance() {
return reinterpret_cast<const ParameterParameter*>(
&_ParameterParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
74;
friend void swap(ParameterParameter& a, ParameterParameter& b) {
a.Swap(&b);
}
inline void Swap(ParameterParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ParameterParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ParameterParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ParameterParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ParameterParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ParameterParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ParameterParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ParameterParameter";
}
protected:
explicit ParameterParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShapeFieldNumber = 1,
};
// optional .caffe.BlobShape shape = 1;
bool has_shape() const;
private:
bool _internal_has_shape() const;
public:
void clear_shape();
const ::caffe::BlobShape& shape() const;
PROTOBUF_NODISCARD ::caffe::BlobShape* release_shape();
::caffe::BlobShape* mutable_shape();
void set_allocated_shape(::caffe::BlobShape* shape);
private:
const ::caffe::BlobShape& _internal_shape() const;
::caffe::BlobShape* _internal_mutable_shape();
public:
void unsafe_arena_set_allocated_shape(
::caffe::BlobShape* shape);
::caffe::BlobShape* unsafe_arena_release_shape();
// @@protoc_insertion_point(class_scope:caffe.ParameterParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::BlobShape* shape_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class PermuteParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.PermuteParameter) */ {
public:
inline PermuteParameter() : PermuteParameter(nullptr) {}
~PermuteParameter() override;
explicit constexpr PermuteParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
PermuteParameter(const PermuteParameter& from);
PermuteParameter(PermuteParameter&& from) noexcept
: PermuteParameter() {
*this = ::std::move(from);
}
inline PermuteParameter& operator=(const PermuteParameter& from) {
CopyFrom(from);
return *this;
}
inline PermuteParameter& operator=(PermuteParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const PermuteParameter& default_instance() {
return *internal_default_instance();
}
static inline const PermuteParameter* internal_default_instance() {
return reinterpret_cast<const PermuteParameter*>(
&_PermuteParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
75;
friend void swap(PermuteParameter& a, PermuteParameter& b) {
a.Swap(&b);
}
inline void Swap(PermuteParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(PermuteParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
PermuteParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<PermuteParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const PermuteParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const PermuteParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(PermuteParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.PermuteParameter";
}
protected:
explicit PermuteParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kOrderFieldNumber = 1,
};
// repeated uint32 order = 1;
int order_size() const;
private:
int _internal_order_size() const;
public:
void clear_order();
private:
uint32_t _internal_order(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_order() const;
void _internal_add_order(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_order();
public:
uint32_t order(int index) const;
void set_order(int index, uint32_t value);
void add_order(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
order() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_order();
// @@protoc_insertion_point(class_scope:caffe.PermuteParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > order_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class PoolingParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.PoolingParameter) */ {
public:
inline PoolingParameter() : PoolingParameter(nullptr) {}
~PoolingParameter() override;
explicit constexpr PoolingParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
PoolingParameter(const PoolingParameter& from);
PoolingParameter(PoolingParameter&& from) noexcept
: PoolingParameter() {
*this = ::std::move(from);
}
inline PoolingParameter& operator=(const PoolingParameter& from) {
CopyFrom(from);
return *this;
}
inline PoolingParameter& operator=(PoolingParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const PoolingParameter& default_instance() {
return *internal_default_instance();
}
static inline const PoolingParameter* internal_default_instance() {
return reinterpret_cast<const PoolingParameter*>(
&_PoolingParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
76;
friend void swap(PoolingParameter& a, PoolingParameter& b) {
a.Swap(&b);
}
inline void Swap(PoolingParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(PoolingParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
PoolingParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<PoolingParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const PoolingParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const PoolingParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(PoolingParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.PoolingParameter";
}
protected:
explicit PoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef PoolingParameter_PoolMethod PoolMethod;
static constexpr PoolMethod MAX =
PoolingParameter_PoolMethod_MAX;
static constexpr PoolMethod AVE =
PoolingParameter_PoolMethod_AVE;
static constexpr PoolMethod STOCHASTIC =
PoolingParameter_PoolMethod_STOCHASTIC;
static inline bool PoolMethod_IsValid(int value) {
return PoolingParameter_PoolMethod_IsValid(value);
}
static constexpr PoolMethod PoolMethod_MIN =
PoolingParameter_PoolMethod_PoolMethod_MIN;
static constexpr PoolMethod PoolMethod_MAX =
PoolingParameter_PoolMethod_PoolMethod_MAX;
static constexpr int PoolMethod_ARRAYSIZE =
PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
PoolMethod_descriptor() {
return PoolingParameter_PoolMethod_descriptor();
}
template<typename T>
static inline const std::string& PoolMethod_Name(T enum_t_value) {
static_assert(::std::is_same<T, PoolMethod>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PoolMethod_Name.");
return PoolingParameter_PoolMethod_Name(enum_t_value);
}
static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
PoolMethod* value) {
return PoolingParameter_PoolMethod_Parse(name, value);
}
typedef PoolingParameter_Engine Engine;
static constexpr Engine DEFAULT =
PoolingParameter_Engine_DEFAULT;
static constexpr Engine CAFFE =
PoolingParameter_Engine_CAFFE;
static constexpr Engine CUDNN =
PoolingParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return PoolingParameter_Engine_IsValid(value);
}
static constexpr Engine Engine_MIN =
PoolingParameter_Engine_Engine_MIN;
static constexpr Engine Engine_MAX =
PoolingParameter_Engine_Engine_MAX;
static constexpr int Engine_ARRAYSIZE =
PoolingParameter_Engine_Engine_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Engine_descriptor() {
return PoolingParameter_Engine_descriptor();
}
template<typename T>
static inline const std::string& Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Engine_Name.");
return PoolingParameter_Engine_Name(enum_t_value);
}
static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Engine* value) {
return PoolingParameter_Engine_Parse(name, value);
}
typedef PoolingParameter_RoundMode RoundMode;
static constexpr RoundMode CEIL =
PoolingParameter_RoundMode_CEIL;
static constexpr RoundMode FLOOR =
PoolingParameter_RoundMode_FLOOR;
static inline bool RoundMode_IsValid(int value) {
return PoolingParameter_RoundMode_IsValid(value);
}
static constexpr RoundMode RoundMode_MIN =
PoolingParameter_RoundMode_RoundMode_MIN;
static constexpr RoundMode RoundMode_MAX =
PoolingParameter_RoundMode_RoundMode_MAX;
static constexpr int RoundMode_ARRAYSIZE =
PoolingParameter_RoundMode_RoundMode_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
RoundMode_descriptor() {
return PoolingParameter_RoundMode_descriptor();
}
template<typename T>
static inline const std::string& RoundMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, RoundMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function RoundMode_Name.");
return PoolingParameter_RoundMode_Name(enum_t_value);
}
static inline bool RoundMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
RoundMode* value) {
return PoolingParameter_RoundMode_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kPoolFieldNumber = 1,
kKernelSizeFieldNumber = 2,
kPadFieldNumber = 4,
kKernelHFieldNumber = 5,
kKernelWFieldNumber = 6,
kStrideHFieldNumber = 7,
kStrideWFieldNumber = 8,
kPadHFieldNumber = 9,
kPadWFieldNumber = 10,
kEngineFieldNumber = 11,
kGlobalPoolingFieldNumber = 12,
kRoundModeFieldNumber = 14,
kStrideFieldNumber = 3,
kAvgIncludePadFieldNumber = 13,
};
// optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
bool has_pool() const;
private:
bool _internal_has_pool() const;
public:
void clear_pool();
::caffe::PoolingParameter_PoolMethod pool() const;
void set_pool(::caffe::PoolingParameter_PoolMethod value);
private:
::caffe::PoolingParameter_PoolMethod _internal_pool() const;
void _internal_set_pool(::caffe::PoolingParameter_PoolMethod value);
public:
// optional uint32 kernel_size = 2;
bool has_kernel_size() const;
private:
bool _internal_has_kernel_size() const;
public:
void clear_kernel_size();
uint32_t kernel_size() const;
void set_kernel_size(uint32_t value);
private:
uint32_t _internal_kernel_size() const;
void _internal_set_kernel_size(uint32_t value);
public:
// optional uint32 pad = 4 [default = 0];
bool has_pad() const;
private:
bool _internal_has_pad() const;
public:
void clear_pad();
uint32_t pad() const;
void set_pad(uint32_t value);
private:
uint32_t _internal_pad() const;
void _internal_set_pad(uint32_t value);
public:
// optional uint32 kernel_h = 5;
bool has_kernel_h() const;
private:
bool _internal_has_kernel_h() const;
public:
void clear_kernel_h();
uint32_t kernel_h() const;
void set_kernel_h(uint32_t value);
private:
uint32_t _internal_kernel_h() const;
void _internal_set_kernel_h(uint32_t value);
public:
// optional uint32 kernel_w = 6;
bool has_kernel_w() const;
private:
bool _internal_has_kernel_w() const;
public:
void clear_kernel_w();
uint32_t kernel_w() const;
void set_kernel_w(uint32_t value);
private:
uint32_t _internal_kernel_w() const;
void _internal_set_kernel_w(uint32_t value);
public:
// optional uint32 stride_h = 7;
bool has_stride_h() const;
private:
bool _internal_has_stride_h() const;
public:
void clear_stride_h();
uint32_t stride_h() const;
void set_stride_h(uint32_t value);
private:
uint32_t _internal_stride_h() const;
void _internal_set_stride_h(uint32_t value);
public:
// optional uint32 stride_w = 8;
bool has_stride_w() const;
private:
bool _internal_has_stride_w() const;
public:
void clear_stride_w();
uint32_t stride_w() const;
void set_stride_w(uint32_t value);
private:
uint32_t _internal_stride_w() const;
void _internal_set_stride_w(uint32_t value);
public:
// optional uint32 pad_h = 9 [default = 0];
bool has_pad_h() const;
private:
bool _internal_has_pad_h() const;
public:
void clear_pad_h();
uint32_t pad_h() const;
void set_pad_h(uint32_t value);
private:
uint32_t _internal_pad_h() const;
void _internal_set_pad_h(uint32_t value);
public:
// optional uint32 pad_w = 10 [default = 0];
bool has_pad_w() const;
private:
bool _internal_has_pad_w() const;
public:
void clear_pad_w();
uint32_t pad_w() const;
void set_pad_w(uint32_t value);
private:
uint32_t _internal_pad_w() const;
void _internal_set_pad_w(uint32_t value);
public:
// optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
bool has_engine() const;
private:
bool _internal_has_engine() const;
public:
void clear_engine();
::caffe::PoolingParameter_Engine engine() const;
void set_engine(::caffe::PoolingParameter_Engine value);
private:
::caffe::PoolingParameter_Engine _internal_engine() const;
void _internal_set_engine(::caffe::PoolingParameter_Engine value);
public:
// optional bool global_pooling = 12 [default = false];
bool has_global_pooling() const;
private:
bool _internal_has_global_pooling() const;
public:
void clear_global_pooling();
bool global_pooling() const;
void set_global_pooling(bool value);
private:
bool _internal_global_pooling() const;
void _internal_set_global_pooling(bool value);
public:
// optional .caffe.PoolingParameter.RoundMode round_mode = 14 [default = CEIL];
bool has_round_mode() const;
private:
bool _internal_has_round_mode() const;
public:
void clear_round_mode();
::caffe::PoolingParameter_RoundMode round_mode() const;
void set_round_mode(::caffe::PoolingParameter_RoundMode value);
private:
::caffe::PoolingParameter_RoundMode _internal_round_mode() const;
void _internal_set_round_mode(::caffe::PoolingParameter_RoundMode value);
public:
// optional uint32 stride = 3 [default = 1];
bool has_stride() const;
private:
bool _internal_has_stride() const;
public:
void clear_stride();
uint32_t stride() const;
void set_stride(uint32_t value);
private:
uint32_t _internal_stride() const;
void _internal_set_stride(uint32_t value);
public:
// optional bool avg_include_pad = 13 [default = true];
bool has_avg_include_pad() const;
private:
bool _internal_has_avg_include_pad() const;
public:
void clear_avg_include_pad();
bool avg_include_pad() const;
void set_avg_include_pad(bool value);
private:
bool _internal_avg_include_pad() const;
void _internal_set_avg_include_pad(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.PoolingParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int pool_;
uint32_t kernel_size_;
uint32_t pad_;
uint32_t kernel_h_;
uint32_t kernel_w_;
uint32_t stride_h_;
uint32_t stride_w_;
uint32_t pad_h_;
uint32_t pad_w_;
int engine_;
bool global_pooling_;
int round_mode_;
uint32_t stride_;
bool avg_include_pad_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class Pooling3DParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.Pooling3DParameter) */ {
public:
inline Pooling3DParameter() : Pooling3DParameter(nullptr) {}
~Pooling3DParameter() override;
explicit constexpr Pooling3DParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Pooling3DParameter(const Pooling3DParameter& from);
Pooling3DParameter(Pooling3DParameter&& from) noexcept
: Pooling3DParameter() {
*this = ::std::move(from);
}
inline Pooling3DParameter& operator=(const Pooling3DParameter& from) {
CopyFrom(from);
return *this;
}
inline Pooling3DParameter& operator=(Pooling3DParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Pooling3DParameter& default_instance() {
return *internal_default_instance();
}
static inline const Pooling3DParameter* internal_default_instance() {
return reinterpret_cast<const Pooling3DParameter*>(
&_Pooling3DParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
77;
friend void swap(Pooling3DParameter& a, Pooling3DParameter& b) {
a.Swap(&b);
}
inline void Swap(Pooling3DParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Pooling3DParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Pooling3DParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Pooling3DParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Pooling3DParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Pooling3DParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Pooling3DParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.Pooling3DParameter";
}
protected:
explicit Pooling3DParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef Pooling3DParameter_PoolMethod PoolMethod;
static constexpr PoolMethod MAX =
Pooling3DParameter_PoolMethod_MAX;
static constexpr PoolMethod AVE =
Pooling3DParameter_PoolMethod_AVE;
static constexpr PoolMethod STOCHASTIC =
Pooling3DParameter_PoolMethod_STOCHASTIC;
static inline bool PoolMethod_IsValid(int value) {
return Pooling3DParameter_PoolMethod_IsValid(value);
}
static constexpr PoolMethod PoolMethod_MIN =
Pooling3DParameter_PoolMethod_PoolMethod_MIN;
static constexpr PoolMethod PoolMethod_MAX =
Pooling3DParameter_PoolMethod_PoolMethod_MAX;
static constexpr int PoolMethod_ARRAYSIZE =
Pooling3DParameter_PoolMethod_PoolMethod_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
PoolMethod_descriptor() {
return Pooling3DParameter_PoolMethod_descriptor();
}
template<typename T>
static inline const std::string& PoolMethod_Name(T enum_t_value) {
static_assert(::std::is_same<T, PoolMethod>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PoolMethod_Name.");
return Pooling3DParameter_PoolMethod_Name(enum_t_value);
}
static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
PoolMethod* value) {
return Pooling3DParameter_PoolMethod_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kPoolFieldNumber = 1,
kKernelSizeFieldNumber = 2,
kKernelDepthFieldNumber = 3,
kPadFieldNumber = 6,
kTemporalPadFieldNumber = 7,
kStrideFieldNumber = 4,
kTemporalStrideFieldNumber = 5,
};
// optional .caffe.Pooling3DParameter.PoolMethod pool = 1 [default = MAX];
bool has_pool() const;
private:
bool _internal_has_pool() const;
public:
void clear_pool();
::caffe::Pooling3DParameter_PoolMethod pool() const;
void set_pool(::caffe::Pooling3DParameter_PoolMethod value);
private:
::caffe::Pooling3DParameter_PoolMethod _internal_pool() const;
void _internal_set_pool(::caffe::Pooling3DParameter_PoolMethod value);
public:
// optional uint32 kernel_size = 2;
bool has_kernel_size() const;
private:
bool _internal_has_kernel_size() const;
public:
void clear_kernel_size();
uint32_t kernel_size() const;
void set_kernel_size(uint32_t value);
private:
uint32_t _internal_kernel_size() const;
void _internal_set_kernel_size(uint32_t value);
public:
// optional uint32 kernel_depth = 3;
bool has_kernel_depth() const;
private:
bool _internal_has_kernel_depth() const;
public:
void clear_kernel_depth();
uint32_t kernel_depth() const;
void set_kernel_depth(uint32_t value);
private:
uint32_t _internal_kernel_depth() const;
void _internal_set_kernel_depth(uint32_t value);
public:
// optional uint32 pad = 6 [default = 0];
bool has_pad() const;
private:
bool _internal_has_pad() const;
public:
void clear_pad();
uint32_t pad() const;
void set_pad(uint32_t value);
private:
uint32_t _internal_pad() const;
void _internal_set_pad(uint32_t value);
public:
// optional uint32 temporal_pad = 7 [default = 0];
bool has_temporal_pad() const;
private:
bool _internal_has_temporal_pad() const;
public:
void clear_temporal_pad();
uint32_t temporal_pad() const;
void set_temporal_pad(uint32_t value);
private:
uint32_t _internal_temporal_pad() const;
void _internal_set_temporal_pad(uint32_t value);
public:
// optional uint32 stride = 4 [default = 1];
bool has_stride() const;
private:
bool _internal_has_stride() const;
public:
void clear_stride();
uint32_t stride() const;
void set_stride(uint32_t value);
private:
uint32_t _internal_stride() const;
void _internal_set_stride(uint32_t value);
public:
// optional uint32 temporal_stride = 5 [default = 1];
bool has_temporal_stride() const;
private:
bool _internal_has_temporal_stride() const;
public:
void clear_temporal_stride();
uint32_t temporal_stride() const;
void set_temporal_stride(uint32_t value);
private:
uint32_t _internal_temporal_stride() const;
void _internal_set_temporal_stride(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.Pooling3DParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int pool_;
uint32_t kernel_size_;
uint32_t kernel_depth_;
uint32_t pad_;
uint32_t temporal_pad_;
uint32_t stride_;
uint32_t temporal_stride_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class PowerParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.PowerParameter) */ {
public:
inline PowerParameter() : PowerParameter(nullptr) {}
~PowerParameter() override;
explicit constexpr PowerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
PowerParameter(const PowerParameter& from);
PowerParameter(PowerParameter&& from) noexcept
: PowerParameter() {
*this = ::std::move(from);
}
inline PowerParameter& operator=(const PowerParameter& from) {
CopyFrom(from);
return *this;
}
inline PowerParameter& operator=(PowerParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const PowerParameter& default_instance() {
return *internal_default_instance();
}
static inline const PowerParameter* internal_default_instance() {
return reinterpret_cast<const PowerParameter*>(
&_PowerParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
78;
friend void swap(PowerParameter& a, PowerParameter& b) {
a.Swap(&b);
}
inline void Swap(PowerParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(PowerParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
PowerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<PowerParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const PowerParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const PowerParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(PowerParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.PowerParameter";
}
protected:
explicit PowerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShiftFieldNumber = 3,
kPowerFieldNumber = 1,
kScaleFieldNumber = 2,
};
// optional float shift = 3 [default = 0];
bool has_shift() const;
private:
bool _internal_has_shift() const;
public:
void clear_shift();
float shift() const;
void set_shift(float value);
private:
float _internal_shift() const;
void _internal_set_shift(float value);
public:
// optional float power = 1 [default = 1];
bool has_power() const;
private:
bool _internal_has_power() const;
public:
void clear_power();
float power() const;
void set_power(float value);
private:
float _internal_power() const;
void _internal_set_power(float value);
public:
// optional float scale = 2 [default = 1];
bool has_scale() const;
private:
bool _internal_has_scale() const;
public:
void clear_scale();
float scale() const;
void set_scale(float value);
private:
float _internal_scale() const;
void _internal_set_scale(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.PowerParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float shift_;
float power_;
float scale_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class PriorBoxParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.PriorBoxParameter) */ {
public:
inline PriorBoxParameter() : PriorBoxParameter(nullptr) {}
~PriorBoxParameter() override;
explicit constexpr PriorBoxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
PriorBoxParameter(const PriorBoxParameter& from);
PriorBoxParameter(PriorBoxParameter&& from) noexcept
: PriorBoxParameter() {
*this = ::std::move(from);
}
inline PriorBoxParameter& operator=(const PriorBoxParameter& from) {
CopyFrom(from);
return *this;
}
inline PriorBoxParameter& operator=(PriorBoxParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const PriorBoxParameter& default_instance() {
return *internal_default_instance();
}
static inline const PriorBoxParameter* internal_default_instance() {
return reinterpret_cast<const PriorBoxParameter*>(
&_PriorBoxParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
79;
friend void swap(PriorBoxParameter& a, PriorBoxParameter& b) {
a.Swap(&b);
}
inline void Swap(PriorBoxParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(PriorBoxParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
PriorBoxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<PriorBoxParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const PriorBoxParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const PriorBoxParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(PriorBoxParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.PriorBoxParameter";
}
protected:
explicit PriorBoxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef PriorBoxParameter_CodeType CodeType;
static constexpr CodeType CORNER =
PriorBoxParameter_CodeType_CORNER;
static constexpr CodeType CENTER_SIZE =
PriorBoxParameter_CodeType_CENTER_SIZE;
static constexpr CodeType CORNER_SIZE =
PriorBoxParameter_CodeType_CORNER_SIZE;
static inline bool CodeType_IsValid(int value) {
return PriorBoxParameter_CodeType_IsValid(value);
}
static constexpr CodeType CodeType_MIN =
PriorBoxParameter_CodeType_CodeType_MIN;
static constexpr CodeType CodeType_MAX =
PriorBoxParameter_CodeType_CodeType_MAX;
static constexpr int CodeType_ARRAYSIZE =
PriorBoxParameter_CodeType_CodeType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
CodeType_descriptor() {
return PriorBoxParameter_CodeType_descriptor();
}
template<typename T>
static inline const std::string& CodeType_Name(T enum_t_value) {
static_assert(::std::is_same<T, CodeType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function CodeType_Name.");
return PriorBoxParameter_CodeType_Name(enum_t_value);
}
static inline bool CodeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
CodeType* value) {
return PriorBoxParameter_CodeType_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kMinSizeFieldNumber = 1,
kMaxSizeFieldNumber = 2,
kAspectRatioFieldNumber = 3,
kVarianceFieldNumber = 6,
kClipFieldNumber = 5,
kImgSizeFieldNumber = 7,
kImgHFieldNumber = 8,
kImgWFieldNumber = 9,
kStepFieldNumber = 10,
kStepHFieldNumber = 11,
kStepWFieldNumber = 12,
kFlipFieldNumber = 4,
kOffsetFieldNumber = 13,
};
// repeated float min_size = 1;
int min_size_size() const;
private:
int _internal_min_size_size() const;
public:
void clear_min_size();
private:
float _internal_min_size(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_min_size() const;
void _internal_add_min_size(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_min_size();
public:
float min_size(int index) const;
void set_min_size(int index, float value);
void add_min_size(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
min_size() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_min_size();
// repeated float max_size = 2;
int max_size_size() const;
private:
int _internal_max_size_size() const;
public:
void clear_max_size();
private:
float _internal_max_size(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_max_size() const;
void _internal_add_max_size(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_max_size();
public:
float max_size(int index) const;
void set_max_size(int index, float value);
void add_max_size(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
max_size() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_max_size();
// repeated float aspect_ratio = 3;
int aspect_ratio_size() const;
private:
int _internal_aspect_ratio_size() const;
public:
void clear_aspect_ratio();
private:
float _internal_aspect_ratio(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_aspect_ratio() const;
void _internal_add_aspect_ratio(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_aspect_ratio();
public:
float aspect_ratio(int index) const;
void set_aspect_ratio(int index, float value);
void add_aspect_ratio(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
aspect_ratio() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_aspect_ratio();
// repeated float variance = 6;
int variance_size() const;
private:
int _internal_variance_size() const;
public:
void clear_variance();
private:
float _internal_variance(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_variance() const;
void _internal_add_variance(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_variance();
public:
float variance(int index) const;
void set_variance(int index, float value);
void add_variance(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
variance() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_variance();
// optional bool clip = 5 [default = false];
bool has_clip() const;
private:
bool _internal_has_clip() const;
public:
void clear_clip();
bool clip() const;
void set_clip(bool value);
private:
bool _internal_clip() const;
void _internal_set_clip(bool value);
public:
// optional uint32 img_size = 7;
bool has_img_size() const;
private:
bool _internal_has_img_size() const;
public:
void clear_img_size();
uint32_t img_size() const;
void set_img_size(uint32_t value);
private:
uint32_t _internal_img_size() const;
void _internal_set_img_size(uint32_t value);
public:
// optional uint32 img_h = 8;
bool has_img_h() const;
private:
bool _internal_has_img_h() const;
public:
void clear_img_h();
uint32_t img_h() const;
void set_img_h(uint32_t value);
private:
uint32_t _internal_img_h() const;
void _internal_set_img_h(uint32_t value);
public:
// optional uint32 img_w = 9;
bool has_img_w() const;
private:
bool _internal_has_img_w() const;
public:
void clear_img_w();
uint32_t img_w() const;
void set_img_w(uint32_t value);
private:
uint32_t _internal_img_w() const;
void _internal_set_img_w(uint32_t value);
public:
// optional float step = 10;
bool has_step() const;
private:
bool _internal_has_step() const;
public:
void clear_step();
float step() const;
void set_step(float value);
private:
float _internal_step() const;
void _internal_set_step(float value);
public:
// optional float step_h = 11;
bool has_step_h() const;
private:
bool _internal_has_step_h() const;
public:
void clear_step_h();
float step_h() const;
void set_step_h(float value);
private:
float _internal_step_h() const;
void _internal_set_step_h(float value);
public:
// optional float step_w = 12;
bool has_step_w() const;
private:
bool _internal_has_step_w() const;
public:
void clear_step_w();
float step_w() const;
void set_step_w(float value);
private:
float _internal_step_w() const;
void _internal_set_step_w(float value);
public:
// optional bool flip = 4 [default = true];
bool has_flip() const;
private:
bool _internal_has_flip() const;
public:
void clear_flip();
bool flip() const;
void set_flip(bool value);
private:
bool _internal_flip() const;
void _internal_set_flip(bool value);
public:
// optional float offset = 13 [default = 0.5];
bool has_offset() const;
private:
bool _internal_has_offset() const;
public:
void clear_offset();
float offset() const;
void set_offset(float value);
private:
float _internal_offset() const;
void _internal_set_offset(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.PriorBoxParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > min_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > max_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > aspect_ratio_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > variance_;
bool clip_;
uint32_t img_size_;
uint32_t img_h_;
uint32_t img_w_;
float step_;
float step_h_;
float step_w_;
bool flip_;
float offset_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class PythonParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.PythonParameter) */ {
public:
inline PythonParameter() : PythonParameter(nullptr) {}
~PythonParameter() override;
explicit constexpr PythonParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
PythonParameter(const PythonParameter& from);
PythonParameter(PythonParameter&& from) noexcept
: PythonParameter() {
*this = ::std::move(from);
}
inline PythonParameter& operator=(const PythonParameter& from) {
CopyFrom(from);
return *this;
}
inline PythonParameter& operator=(PythonParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const PythonParameter& default_instance() {
return *internal_default_instance();
}
static inline const PythonParameter* internal_default_instance() {
return reinterpret_cast<const PythonParameter*>(
&_PythonParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
80;
friend void swap(PythonParameter& a, PythonParameter& b) {
a.Swap(&b);
}
inline void Swap(PythonParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(PythonParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
PythonParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<PythonParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const PythonParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const PythonParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(PythonParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.PythonParameter";
}
protected:
explicit PythonParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kModuleFieldNumber = 1,
kLayerFieldNumber = 2,
kParamStrFieldNumber = 3,
kShareInParallelFieldNumber = 4,
};
// optional string module = 1;
bool has_module() const;
private:
bool _internal_has_module() const;
public:
void clear_module();
const std::string& module() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_module(ArgT0&& arg0, ArgT... args);
std::string* mutable_module();
PROTOBUF_NODISCARD std::string* release_module();
void set_allocated_module(std::string* module);
private:
const std::string& _internal_module() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_module(const std::string& value);
std::string* _internal_mutable_module();
public:
// optional string layer = 2;
bool has_layer() const;
private:
bool _internal_has_layer() const;
public:
void clear_layer();
const std::string& layer() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_layer(ArgT0&& arg0, ArgT... args);
std::string* mutable_layer();
PROTOBUF_NODISCARD std::string* release_layer();
void set_allocated_layer(std::string* layer);
private:
const std::string& _internal_layer() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_layer(const std::string& value);
std::string* _internal_mutable_layer();
public:
// optional string param_str = 3 [default = ""];
bool has_param_str() const;
private:
bool _internal_has_param_str() const;
public:
void clear_param_str();
const std::string& param_str() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_param_str(ArgT0&& arg0, ArgT... args);
std::string* mutable_param_str();
PROTOBUF_NODISCARD std::string* release_param_str();
void set_allocated_param_str(std::string* param_str);
private:
const std::string& _internal_param_str() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_param_str(const std::string& value);
std::string* _internal_mutable_param_str();
public:
// optional bool share_in_parallel = 4 [default = false];
bool has_share_in_parallel() const;
private:
bool _internal_has_share_in_parallel() const;
public:
void clear_share_in_parallel();
bool share_in_parallel() const;
void set_share_in_parallel(bool value);
private:
bool _internal_share_in_parallel() const;
void _internal_set_share_in_parallel(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.PythonParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr module_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr layer_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param_str_;
bool share_in_parallel_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class RecurrentParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.RecurrentParameter) */ {
public:
inline RecurrentParameter() : RecurrentParameter(nullptr) {}
~RecurrentParameter() override;
explicit constexpr RecurrentParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
RecurrentParameter(const RecurrentParameter& from);
RecurrentParameter(RecurrentParameter&& from) noexcept
: RecurrentParameter() {
*this = ::std::move(from);
}
inline RecurrentParameter& operator=(const RecurrentParameter& from) {
CopyFrom(from);
return *this;
}
inline RecurrentParameter& operator=(RecurrentParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const RecurrentParameter& default_instance() {
return *internal_default_instance();
}
static inline const RecurrentParameter* internal_default_instance() {
return reinterpret_cast<const RecurrentParameter*>(
&_RecurrentParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
81;
friend void swap(RecurrentParameter& a, RecurrentParameter& b) {
a.Swap(&b);
}
inline void Swap(RecurrentParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(RecurrentParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
RecurrentParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<RecurrentParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const RecurrentParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const RecurrentParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(RecurrentParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.RecurrentParameter";
}
protected:
explicit RecurrentParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kWeightFillerFieldNumber = 2,
kBiasFillerFieldNumber = 3,
kNumOutputFieldNumber = 1,
kDebugInfoFieldNumber = 4,
kExposeHiddenFieldNumber = 5,
};
// optional .caffe.FillerParameter weight_filler = 2;
bool has_weight_filler() const;
private:
bool _internal_has_weight_filler() const;
public:
void clear_weight_filler();
const ::caffe::FillerParameter& weight_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_weight_filler();
::caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);
private:
const ::caffe::FillerParameter& _internal_weight_filler() const;
::caffe::FillerParameter* _internal_mutable_weight_filler();
public:
void unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler);
::caffe::FillerParameter* unsafe_arena_release_weight_filler();
// optional .caffe.FillerParameter bias_filler = 3;
bool has_bias_filler() const;
private:
bool _internal_has_bias_filler() const;
public:
void clear_bias_filler();
const ::caffe::FillerParameter& bias_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_bias_filler();
::caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);
private:
const ::caffe::FillerParameter& _internal_bias_filler() const;
::caffe::FillerParameter* _internal_mutable_bias_filler();
public:
void unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler);
::caffe::FillerParameter* unsafe_arena_release_bias_filler();
// optional uint32 num_output = 1 [default = 0];
bool has_num_output() const;
private:
bool _internal_has_num_output() const;
public:
void clear_num_output();
uint32_t num_output() const;
void set_num_output(uint32_t value);
private:
uint32_t _internal_num_output() const;
void _internal_set_num_output(uint32_t value);
public:
// optional bool debug_info = 4 [default = false];
bool has_debug_info() const;
private:
bool _internal_has_debug_info() const;
public:
void clear_debug_info();
bool debug_info() const;
void set_debug_info(bool value);
private:
bool _internal_debug_info() const;
void _internal_set_debug_info(bool value);
public:
// optional bool expose_hidden = 5 [default = false];
bool has_expose_hidden() const;
private:
bool _internal_has_expose_hidden() const;
public:
void clear_expose_hidden();
bool expose_hidden() const;
void set_expose_hidden(bool value);
private:
bool _internal_expose_hidden() const;
void _internal_set_expose_hidden(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.RecurrentParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* weight_filler_;
::caffe::FillerParameter* bias_filler_;
uint32_t num_output_;
bool debug_info_;
bool expose_hidden_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ReductionParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ReductionParameter) */ {
public:
inline ReductionParameter() : ReductionParameter(nullptr) {}
~ReductionParameter() override;
explicit constexpr ReductionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ReductionParameter(const ReductionParameter& from);
ReductionParameter(ReductionParameter&& from) noexcept
: ReductionParameter() {
*this = ::std::move(from);
}
inline ReductionParameter& operator=(const ReductionParameter& from) {
CopyFrom(from);
return *this;
}
inline ReductionParameter& operator=(ReductionParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ReductionParameter& default_instance() {
return *internal_default_instance();
}
static inline const ReductionParameter* internal_default_instance() {
return reinterpret_cast<const ReductionParameter*>(
&_ReductionParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
82;
friend void swap(ReductionParameter& a, ReductionParameter& b) {
a.Swap(&b);
}
inline void Swap(ReductionParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ReductionParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ReductionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ReductionParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ReductionParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ReductionParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ReductionParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ReductionParameter";
}
protected:
explicit ReductionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef ReductionParameter_ReductionOp ReductionOp;
static constexpr ReductionOp SUM =
ReductionParameter_ReductionOp_SUM;
static constexpr ReductionOp ASUM =
ReductionParameter_ReductionOp_ASUM;
static constexpr ReductionOp SUMSQ =
ReductionParameter_ReductionOp_SUMSQ;
static constexpr ReductionOp MEAN =
ReductionParameter_ReductionOp_MEAN;
static inline bool ReductionOp_IsValid(int value) {
return ReductionParameter_ReductionOp_IsValid(value);
}
static constexpr ReductionOp ReductionOp_MIN =
ReductionParameter_ReductionOp_ReductionOp_MIN;
static constexpr ReductionOp ReductionOp_MAX =
ReductionParameter_ReductionOp_ReductionOp_MAX;
static constexpr int ReductionOp_ARRAYSIZE =
ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
ReductionOp_descriptor() {
return ReductionParameter_ReductionOp_descriptor();
}
template<typename T>
static inline const std::string& ReductionOp_Name(T enum_t_value) {
static_assert(::std::is_same<T, ReductionOp>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ReductionOp_Name.");
return ReductionParameter_ReductionOp_Name(enum_t_value);
}
static inline bool ReductionOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
ReductionOp* value) {
return ReductionParameter_ReductionOp_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kAxisFieldNumber = 2,
kOperationFieldNumber = 1,
kCoeffFieldNumber = 3,
};
// optional int32 axis = 2 [default = 0];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// optional .caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
bool has_operation() const;
private:
bool _internal_has_operation() const;
public:
void clear_operation();
::caffe::ReductionParameter_ReductionOp operation() const;
void set_operation(::caffe::ReductionParameter_ReductionOp value);
private:
::caffe::ReductionParameter_ReductionOp _internal_operation() const;
void _internal_set_operation(::caffe::ReductionParameter_ReductionOp value);
public:
// optional float coeff = 3 [default = 1];
bool has_coeff() const;
private:
bool _internal_has_coeff() const;
public:
void clear_coeff();
float coeff() const;
void set_coeff(float value);
private:
float _internal_coeff() const;
void _internal_set_coeff(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ReductionParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int32_t axis_;
int operation_;
float coeff_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ReLUParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ReLUParameter) */ {
public:
inline ReLUParameter() : ReLUParameter(nullptr) {}
~ReLUParameter() override;
explicit constexpr ReLUParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ReLUParameter(const ReLUParameter& from);
ReLUParameter(ReLUParameter&& from) noexcept
: ReLUParameter() {
*this = ::std::move(from);
}
inline ReLUParameter& operator=(const ReLUParameter& from) {
CopyFrom(from);
return *this;
}
inline ReLUParameter& operator=(ReLUParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ReLUParameter& default_instance() {
return *internal_default_instance();
}
static inline const ReLUParameter* internal_default_instance() {
return reinterpret_cast<const ReLUParameter*>(
&_ReLUParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
83;
friend void swap(ReLUParameter& a, ReLUParameter& b) {
a.Swap(&b);
}
inline void Swap(ReLUParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ReLUParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ReLUParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ReLUParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ReLUParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ReLUParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ReLUParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ReLUParameter";
}
protected:
explicit ReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef ReLUParameter_Engine Engine;
static constexpr Engine DEFAULT =
ReLUParameter_Engine_DEFAULT;
static constexpr Engine CAFFE =
ReLUParameter_Engine_CAFFE;
static constexpr Engine CUDNN =
ReLUParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return ReLUParameter_Engine_IsValid(value);
}
static constexpr Engine Engine_MIN =
ReLUParameter_Engine_Engine_MIN;
static constexpr Engine Engine_MAX =
ReLUParameter_Engine_Engine_MAX;
static constexpr int Engine_ARRAYSIZE =
ReLUParameter_Engine_Engine_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Engine_descriptor() {
return ReLUParameter_Engine_descriptor();
}
template<typename T>
static inline const std::string& Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Engine_Name.");
return ReLUParameter_Engine_Name(enum_t_value);
}
static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Engine* value) {
return ReLUParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kNegativeSlopeFieldNumber = 1,
kEngineFieldNumber = 2,
};
// optional float negative_slope = 1 [default = 0];
bool has_negative_slope() const;
private:
bool _internal_has_negative_slope() const;
public:
void clear_negative_slope();
float negative_slope() const;
void set_negative_slope(float value);
private:
float _internal_negative_slope() const;
void _internal_set_negative_slope(float value);
public:
// optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
bool has_engine() const;
private:
bool _internal_has_engine() const;
public:
void clear_engine();
::caffe::ReLUParameter_Engine engine() const;
void set_engine(::caffe::ReLUParameter_Engine value);
private:
::caffe::ReLUParameter_Engine _internal_engine() const;
void _internal_set_engine(::caffe::ReLUParameter_Engine value);
public:
// @@protoc_insertion_point(class_scope:caffe.ReLUParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float negative_slope_;
int engine_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ReshapeParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ReshapeParameter) */ {
public:
inline ReshapeParameter() : ReshapeParameter(nullptr) {}
~ReshapeParameter() override;
explicit constexpr ReshapeParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ReshapeParameter(const ReshapeParameter& from);
ReshapeParameter(ReshapeParameter&& from) noexcept
: ReshapeParameter() {
*this = ::std::move(from);
}
inline ReshapeParameter& operator=(const ReshapeParameter& from) {
CopyFrom(from);
return *this;
}
inline ReshapeParameter& operator=(ReshapeParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ReshapeParameter& default_instance() {
return *internal_default_instance();
}
static inline const ReshapeParameter* internal_default_instance() {
return reinterpret_cast<const ReshapeParameter*>(
&_ReshapeParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
84;
friend void swap(ReshapeParameter& a, ReshapeParameter& b) {
a.Swap(&b);
}
inline void Swap(ReshapeParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ReshapeParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ReshapeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ReshapeParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ReshapeParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ReshapeParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ReshapeParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ReshapeParameter";
}
protected:
explicit ReshapeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShapeFieldNumber = 1,
kAxisFieldNumber = 2,
kNumAxesFieldNumber = 3,
};
// optional .caffe.BlobShape shape = 1;
bool has_shape() const;
private:
bool _internal_has_shape() const;
public:
void clear_shape();
const ::caffe::BlobShape& shape() const;
PROTOBUF_NODISCARD ::caffe::BlobShape* release_shape();
::caffe::BlobShape* mutable_shape();
void set_allocated_shape(::caffe::BlobShape* shape);
private:
const ::caffe::BlobShape& _internal_shape() const;
::caffe::BlobShape* _internal_mutable_shape();
public:
void unsafe_arena_set_allocated_shape(
::caffe::BlobShape* shape);
::caffe::BlobShape* unsafe_arena_release_shape();
// optional int32 axis = 2 [default = 0];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// optional int32 num_axes = 3 [default = -1];
bool has_num_axes() const;
private:
bool _internal_has_num_axes() const;
public:
void clear_num_axes();
int32_t num_axes() const;
void set_num_axes(int32_t value);
private:
int32_t _internal_num_axes() const;
void _internal_set_num_axes(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.ReshapeParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::BlobShape* shape_;
int32_t axis_;
int32_t num_axes_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ScaleParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ScaleParameter) */ {
public:
inline ScaleParameter() : ScaleParameter(nullptr) {}
~ScaleParameter() override;
explicit constexpr ScaleParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ScaleParameter(const ScaleParameter& from);
ScaleParameter(ScaleParameter&& from) noexcept
: ScaleParameter() {
*this = ::std::move(from);
}
inline ScaleParameter& operator=(const ScaleParameter& from) {
CopyFrom(from);
return *this;
}
inline ScaleParameter& operator=(ScaleParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ScaleParameter& default_instance() {
return *internal_default_instance();
}
static inline const ScaleParameter* internal_default_instance() {
return reinterpret_cast<const ScaleParameter*>(
&_ScaleParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
85;
friend void swap(ScaleParameter& a, ScaleParameter& b) {
a.Swap(&b);
}
inline void Swap(ScaleParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ScaleParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ScaleParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ScaleParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ScaleParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ScaleParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ScaleParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ScaleParameter";
}
protected:
explicit ScaleParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kFillerFieldNumber = 3,
kBiasFillerFieldNumber = 5,
kBiasTermFieldNumber = 4,
kAxisFieldNumber = 1,
kNumAxesFieldNumber = 2,
};
// optional .caffe.FillerParameter filler = 3;
bool has_filler() const;
private:
bool _internal_has_filler() const;
public:
void clear_filler();
const ::caffe::FillerParameter& filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_filler();
::caffe::FillerParameter* mutable_filler();
void set_allocated_filler(::caffe::FillerParameter* filler);
private:
const ::caffe::FillerParameter& _internal_filler() const;
::caffe::FillerParameter* _internal_mutable_filler();
public:
void unsafe_arena_set_allocated_filler(
::caffe::FillerParameter* filler);
::caffe::FillerParameter* unsafe_arena_release_filler();
// optional .caffe.FillerParameter bias_filler = 5;
bool has_bias_filler() const;
private:
bool _internal_has_bias_filler() const;
public:
void clear_bias_filler();
const ::caffe::FillerParameter& bias_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_bias_filler();
::caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);
private:
const ::caffe::FillerParameter& _internal_bias_filler() const;
::caffe::FillerParameter* _internal_mutable_bias_filler();
public:
void unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler);
::caffe::FillerParameter* unsafe_arena_release_bias_filler();
// optional bool bias_term = 4 [default = false];
bool has_bias_term() const;
private:
bool _internal_has_bias_term() const;
public:
void clear_bias_term();
bool bias_term() const;
void set_bias_term(bool value);
private:
bool _internal_bias_term() const;
void _internal_set_bias_term(bool value);
public:
// optional int32 axis = 1 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// optional int32 num_axes = 2 [default = 1];
bool has_num_axes() const;
private:
bool _internal_has_num_axes() const;
public:
void clear_num_axes();
int32_t num_axes() const;
void set_num_axes(int32_t value);
private:
int32_t _internal_num_axes() const;
void _internal_set_num_axes(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.ScaleParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* filler_;
::caffe::FillerParameter* bias_filler_;
bool bias_term_;
int32_t axis_;
int32_t num_axes_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class SigmoidParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.SigmoidParameter) */ {
public:
inline SigmoidParameter() : SigmoidParameter(nullptr) {}
~SigmoidParameter() override;
explicit constexpr SigmoidParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SigmoidParameter(const SigmoidParameter& from);
SigmoidParameter(SigmoidParameter&& from) noexcept
: SigmoidParameter() {
*this = ::std::move(from);
}
inline SigmoidParameter& operator=(const SigmoidParameter& from) {
CopyFrom(from);
return *this;
}
inline SigmoidParameter& operator=(SigmoidParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SigmoidParameter& default_instance() {
return *internal_default_instance();
}
static inline const SigmoidParameter* internal_default_instance() {
return reinterpret_cast<const SigmoidParameter*>(
&_SigmoidParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
86;
friend void swap(SigmoidParameter& a, SigmoidParameter& b) {
a.Swap(&b);
}
inline void Swap(SigmoidParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SigmoidParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SigmoidParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SigmoidParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SigmoidParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const SigmoidParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SigmoidParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.SigmoidParameter";
}
protected:
explicit SigmoidParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef SigmoidParameter_Engine Engine;
static constexpr Engine DEFAULT =
SigmoidParameter_Engine_DEFAULT;
static constexpr Engine CAFFE =
SigmoidParameter_Engine_CAFFE;
static constexpr Engine CUDNN =
SigmoidParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return SigmoidParameter_Engine_IsValid(value);
}
static constexpr Engine Engine_MIN =
SigmoidParameter_Engine_Engine_MIN;
static constexpr Engine Engine_MAX =
SigmoidParameter_Engine_Engine_MAX;
static constexpr int Engine_ARRAYSIZE =
SigmoidParameter_Engine_Engine_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Engine_descriptor() {
return SigmoidParameter_Engine_descriptor();
}
template<typename T>
static inline const std::string& Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Engine_Name.");
return SigmoidParameter_Engine_Name(enum_t_value);
}
static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Engine* value) {
return SigmoidParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kEngineFieldNumber = 1,
};
// optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
bool has_engine() const;
private:
bool _internal_has_engine() const;
public:
void clear_engine();
::caffe::SigmoidParameter_Engine engine() const;
void set_engine(::caffe::SigmoidParameter_Engine value);
private:
::caffe::SigmoidParameter_Engine _internal_engine() const;
void _internal_set_engine(::caffe::SigmoidParameter_Engine value);
public:
// @@protoc_insertion_point(class_scope:caffe.SigmoidParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int engine_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class SliceParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.SliceParameter) */ {
public:
inline SliceParameter() : SliceParameter(nullptr) {}
~SliceParameter() override;
explicit constexpr SliceParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SliceParameter(const SliceParameter& from);
SliceParameter(SliceParameter&& from) noexcept
: SliceParameter() {
*this = ::std::move(from);
}
inline SliceParameter& operator=(const SliceParameter& from) {
CopyFrom(from);
return *this;
}
inline SliceParameter& operator=(SliceParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SliceParameter& default_instance() {
return *internal_default_instance();
}
static inline const SliceParameter* internal_default_instance() {
return reinterpret_cast<const SliceParameter*>(
&_SliceParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
87;
friend void swap(SliceParameter& a, SliceParameter& b) {
a.Swap(&b);
}
inline void Swap(SliceParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SliceParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SliceParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SliceParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SliceParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const SliceParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SliceParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.SliceParameter";
}
protected:
explicit SliceParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSlicePointFieldNumber = 2,
kSliceDimFieldNumber = 1,
kAxisFieldNumber = 3,
};
// repeated uint32 slice_point = 2;
int slice_point_size() const;
private:
int _internal_slice_point_size() const;
public:
void clear_slice_point();
private:
uint32_t _internal_slice_point(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
_internal_slice_point() const;
void _internal_add_slice_point(uint32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
_internal_mutable_slice_point();
public:
uint32_t slice_point(int index) const;
void set_slice_point(int index, uint32_t value);
void add_slice_point(uint32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
slice_point() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
mutable_slice_point();
// optional uint32 slice_dim = 1 [default = 1];
bool has_slice_dim() const;
private:
bool _internal_has_slice_dim() const;
public:
void clear_slice_dim();
uint32_t slice_dim() const;
void set_slice_dim(uint32_t value);
private:
uint32_t _internal_slice_dim() const;
void _internal_set_slice_dim(uint32_t value);
public:
// optional int32 axis = 3 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.SliceParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > slice_point_;
uint32_t slice_dim_;
int32_t axis_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class SoftmaxParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.SoftmaxParameter) */ {
public:
inline SoftmaxParameter() : SoftmaxParameter(nullptr) {}
~SoftmaxParameter() override;
explicit constexpr SoftmaxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SoftmaxParameter(const SoftmaxParameter& from);
SoftmaxParameter(SoftmaxParameter&& from) noexcept
: SoftmaxParameter() {
*this = ::std::move(from);
}
inline SoftmaxParameter& operator=(const SoftmaxParameter& from) {
CopyFrom(from);
return *this;
}
inline SoftmaxParameter& operator=(SoftmaxParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SoftmaxParameter& default_instance() {
return *internal_default_instance();
}
static inline const SoftmaxParameter* internal_default_instance() {
return reinterpret_cast<const SoftmaxParameter*>(
&_SoftmaxParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
88;
friend void swap(SoftmaxParameter& a, SoftmaxParameter& b) {
a.Swap(&b);
}
inline void Swap(SoftmaxParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SoftmaxParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SoftmaxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SoftmaxParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SoftmaxParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const SoftmaxParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SoftmaxParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.SoftmaxParameter";
}
protected:
explicit SoftmaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef SoftmaxParameter_Engine Engine;
static constexpr Engine DEFAULT =
SoftmaxParameter_Engine_DEFAULT;
static constexpr Engine CAFFE =
SoftmaxParameter_Engine_CAFFE;
static constexpr Engine CUDNN =
SoftmaxParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return SoftmaxParameter_Engine_IsValid(value);
}
static constexpr Engine Engine_MIN =
SoftmaxParameter_Engine_Engine_MIN;
static constexpr Engine Engine_MAX =
SoftmaxParameter_Engine_Engine_MAX;
static constexpr int Engine_ARRAYSIZE =
SoftmaxParameter_Engine_Engine_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Engine_descriptor() {
return SoftmaxParameter_Engine_descriptor();
}
template<typename T>
static inline const std::string& Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Engine_Name.");
return SoftmaxParameter_Engine_Name(enum_t_value);
}
static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Engine* value) {
return SoftmaxParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kEngineFieldNumber = 1,
kAxisFieldNumber = 2,
};
// optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
bool has_engine() const;
private:
bool _internal_has_engine() const;
public:
void clear_engine();
::caffe::SoftmaxParameter_Engine engine() const;
void set_engine(::caffe::SoftmaxParameter_Engine value);
private:
::caffe::SoftmaxParameter_Engine _internal_engine() const;
void _internal_set_engine(::caffe::SoftmaxParameter_Engine value);
public:
// optional int32 axis = 2 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.SoftmaxParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int engine_;
int32_t axis_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class TanHParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.TanHParameter) */ {
public:
inline TanHParameter() : TanHParameter(nullptr) {}
~TanHParameter() override;
explicit constexpr TanHParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TanHParameter(const TanHParameter& from);
TanHParameter(TanHParameter&& from) noexcept
: TanHParameter() {
*this = ::std::move(from);
}
inline TanHParameter& operator=(const TanHParameter& from) {
CopyFrom(from);
return *this;
}
inline TanHParameter& operator=(TanHParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const TanHParameter& default_instance() {
return *internal_default_instance();
}
static inline const TanHParameter* internal_default_instance() {
return reinterpret_cast<const TanHParameter*>(
&_TanHParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
89;
friend void swap(TanHParameter& a, TanHParameter& b) {
a.Swap(&b);
}
inline void Swap(TanHParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(TanHParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TanHParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TanHParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const TanHParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const TanHParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(TanHParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.TanHParameter";
}
protected:
explicit TanHParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef TanHParameter_Engine Engine;
static constexpr Engine DEFAULT =
TanHParameter_Engine_DEFAULT;
static constexpr Engine CAFFE =
TanHParameter_Engine_CAFFE;
static constexpr Engine CUDNN =
TanHParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return TanHParameter_Engine_IsValid(value);
}
static constexpr Engine Engine_MIN =
TanHParameter_Engine_Engine_MIN;
static constexpr Engine Engine_MAX =
TanHParameter_Engine_Engine_MAX;
static constexpr int Engine_ARRAYSIZE =
TanHParameter_Engine_Engine_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Engine_descriptor() {
return TanHParameter_Engine_descriptor();
}
template<typename T>
static inline const std::string& Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Engine_Name.");
return TanHParameter_Engine_Name(enum_t_value);
}
static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Engine* value) {
return TanHParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kEngineFieldNumber = 1,
};
// optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
bool has_engine() const;
private:
bool _internal_has_engine() const;
public:
void clear_engine();
::caffe::TanHParameter_Engine engine() const;
void set_engine(::caffe::TanHParameter_Engine value);
private:
::caffe::TanHParameter_Engine _internal_engine() const;
void _internal_set_engine(::caffe::TanHParameter_Engine value);
public:
// @@protoc_insertion_point(class_scope:caffe.TanHParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int engine_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class TileParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.TileParameter) */ {
public:
inline TileParameter() : TileParameter(nullptr) {}
~TileParameter() override;
explicit constexpr TileParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TileParameter(const TileParameter& from);
TileParameter(TileParameter&& from) noexcept
: TileParameter() {
*this = ::std::move(from);
}
inline TileParameter& operator=(const TileParameter& from) {
CopyFrom(from);
return *this;
}
inline TileParameter& operator=(TileParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const TileParameter& default_instance() {
return *internal_default_instance();
}
static inline const TileParameter* internal_default_instance() {
return reinterpret_cast<const TileParameter*>(
&_TileParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
90;
friend void swap(TileParameter& a, TileParameter& b) {
a.Swap(&b);
}
inline void Swap(TileParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(TileParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TileParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TileParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const TileParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const TileParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(TileParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.TileParameter";
}
protected:
explicit TileParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kTilesFieldNumber = 2,
kAxisFieldNumber = 1,
};
// optional int32 tiles = 2;
bool has_tiles() const;
private:
bool _internal_has_tiles() const;
public:
void clear_tiles();
int32_t tiles() const;
void set_tiles(int32_t value);
private:
int32_t _internal_tiles() const;
void _internal_set_tiles(int32_t value);
public:
// optional int32 axis = 1 [default = 1];
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int32_t axis() const;
void set_axis(int32_t value);
private:
int32_t _internal_axis() const;
void _internal_set_axis(int32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.TileParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int32_t tiles_;
int32_t axis_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ThresholdParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ThresholdParameter) */ {
public:
inline ThresholdParameter() : ThresholdParameter(nullptr) {}
~ThresholdParameter() override;
explicit constexpr ThresholdParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ThresholdParameter(const ThresholdParameter& from);
ThresholdParameter(ThresholdParameter&& from) noexcept
: ThresholdParameter() {
*this = ::std::move(from);
}
inline ThresholdParameter& operator=(const ThresholdParameter& from) {
CopyFrom(from);
return *this;
}
inline ThresholdParameter& operator=(ThresholdParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ThresholdParameter& default_instance() {
return *internal_default_instance();
}
static inline const ThresholdParameter* internal_default_instance() {
return reinterpret_cast<const ThresholdParameter*>(
&_ThresholdParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
91;
friend void swap(ThresholdParameter& a, ThresholdParameter& b) {
a.Swap(&b);
}
inline void Swap(ThresholdParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ThresholdParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ThresholdParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ThresholdParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ThresholdParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ThresholdParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ThresholdParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ThresholdParameter";
}
protected:
explicit ThresholdParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kThresholdFieldNumber = 1,
};
// optional float threshold = 1 [default = 0];
bool has_threshold() const;
private:
bool _internal_has_threshold() const;
public:
void clear_threshold();
float threshold() const;
void set_threshold(float value);
private:
float _internal_threshold() const;
void _internal_set_threshold(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.ThresholdParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float threshold_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class WindowDataParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.WindowDataParameter) */ {
public:
inline WindowDataParameter() : WindowDataParameter(nullptr) {}
~WindowDataParameter() override;
explicit constexpr WindowDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
WindowDataParameter(const WindowDataParameter& from);
WindowDataParameter(WindowDataParameter&& from) noexcept
: WindowDataParameter() {
*this = ::std::move(from);
}
inline WindowDataParameter& operator=(const WindowDataParameter& from) {
CopyFrom(from);
return *this;
}
inline WindowDataParameter& operator=(WindowDataParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const WindowDataParameter& default_instance() {
return *internal_default_instance();
}
static inline const WindowDataParameter* internal_default_instance() {
return reinterpret_cast<const WindowDataParameter*>(
&_WindowDataParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
92;
friend void swap(WindowDataParameter& a, WindowDataParameter& b) {
a.Swap(&b);
}
inline void Swap(WindowDataParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(WindowDataParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
WindowDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<WindowDataParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const WindowDataParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const WindowDataParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(WindowDataParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.WindowDataParameter";
}
protected:
explicit WindowDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSourceFieldNumber = 1,
kMeanFileFieldNumber = 3,
kCropModeFieldNumber = 11,
kRootFolderFieldNumber = 13,
kBatchSizeFieldNumber = 4,
kCropSizeFieldNumber = 5,
kMirrorFieldNumber = 6,
kCacheImagesFieldNumber = 12,
kContextPadFieldNumber = 10,
kScaleFieldNumber = 2,
kFgThresholdFieldNumber = 7,
kBgThresholdFieldNumber = 8,
kFgFractionFieldNumber = 9,
};
// optional string source = 1;
bool has_source() const;
private:
bool _internal_has_source() const;
public:
void clear_source();
const std::string& source() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_source(ArgT0&& arg0, ArgT... args);
std::string* mutable_source();
PROTOBUF_NODISCARD std::string* release_source();
void set_allocated_source(std::string* source);
private:
const std::string& _internal_source() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
std::string* _internal_mutable_source();
public:
// optional string mean_file = 3;
bool has_mean_file() const;
private:
bool _internal_has_mean_file() const;
public:
void clear_mean_file();
const std::string& mean_file() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_mean_file(ArgT0&& arg0, ArgT... args);
std::string* mutable_mean_file();
PROTOBUF_NODISCARD std::string* release_mean_file();
void set_allocated_mean_file(std::string* mean_file);
private:
const std::string& _internal_mean_file() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value);
std::string* _internal_mutable_mean_file();
public:
// optional string crop_mode = 11 [default = "warp"];
bool has_crop_mode() const;
private:
bool _internal_has_crop_mode() const;
public:
void clear_crop_mode();
const std::string& crop_mode() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_crop_mode(ArgT0&& arg0, ArgT... args);
std::string* mutable_crop_mode();
PROTOBUF_NODISCARD std::string* release_crop_mode();
void set_allocated_crop_mode(std::string* crop_mode);
private:
const std::string& _internal_crop_mode() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_crop_mode(const std::string& value);
std::string* _internal_mutable_crop_mode();
public:
// optional string root_folder = 13 [default = ""];
bool has_root_folder() const;
private:
bool _internal_has_root_folder() const;
public:
void clear_root_folder();
const std::string& root_folder() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_root_folder(ArgT0&& arg0, ArgT... args);
std::string* mutable_root_folder();
PROTOBUF_NODISCARD std::string* release_root_folder();
void set_allocated_root_folder(std::string* root_folder);
private:
const std::string& _internal_root_folder() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_root_folder(const std::string& value);
std::string* _internal_mutable_root_folder();
public:
// optional uint32 batch_size = 4;
bool has_batch_size() const;
private:
bool _internal_has_batch_size() const;
public:
void clear_batch_size();
uint32_t batch_size() const;
void set_batch_size(uint32_t value);
private:
uint32_t _internal_batch_size() const;
void _internal_set_batch_size(uint32_t value);
public:
// optional uint32 crop_size = 5 [default = 0];
bool has_crop_size() const;
private:
bool _internal_has_crop_size() const;
public:
void clear_crop_size();
uint32_t crop_size() const;
void set_crop_size(uint32_t value);
private:
uint32_t _internal_crop_size() const;
void _internal_set_crop_size(uint32_t value);
public:
// optional bool mirror = 6 [default = false];
bool has_mirror() const;
private:
bool _internal_has_mirror() const;
public:
void clear_mirror();
bool mirror() const;
void set_mirror(bool value);
private:
bool _internal_mirror() const;
void _internal_set_mirror(bool value);
public:
// optional bool cache_images = 12 [default = false];
bool has_cache_images() const;
private:
bool _internal_has_cache_images() const;
public:
void clear_cache_images();
bool cache_images() const;
void set_cache_images(bool value);
private:
bool _internal_cache_images() const;
void _internal_set_cache_images(bool value);
public:
// optional uint32 context_pad = 10 [default = 0];
bool has_context_pad() const;
private:
bool _internal_has_context_pad() const;
public:
void clear_context_pad();
uint32_t context_pad() const;
void set_context_pad(uint32_t value);
private:
uint32_t _internal_context_pad() const;
void _internal_set_context_pad(uint32_t value);
public:
// optional float scale = 2 [default = 1];
bool has_scale() const;
private:
bool _internal_has_scale() const;
public:
void clear_scale();
float scale() const;
void set_scale(float value);
private:
float _internal_scale() const;
void _internal_set_scale(float value);
public:
// optional float fg_threshold = 7 [default = 0.5];
bool has_fg_threshold() const;
private:
bool _internal_has_fg_threshold() const;
public:
void clear_fg_threshold();
float fg_threshold() const;
void set_fg_threshold(float value);
private:
float _internal_fg_threshold() const;
void _internal_set_fg_threshold(float value);
public:
// optional float bg_threshold = 8 [default = 0.5];
bool has_bg_threshold() const;
private:
bool _internal_has_bg_threshold() const;
public:
void clear_bg_threshold();
float bg_threshold() const;
void set_bg_threshold(float value);
private:
float _internal_bg_threshold() const;
void _internal_set_bg_threshold(float value);
public:
// optional float fg_fraction = 9 [default = 0.25];
bool has_fg_fraction() const;
private:
bool _internal_has_fg_fraction() const;
public:
void clear_fg_fraction();
float fg_fraction() const;
void set_fg_fraction(float value);
private:
float _internal_fg_fraction() const;
void _internal_set_fg_fraction(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.WindowDataParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_;
static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_crop_mode_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr crop_mode_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_folder_;
uint32_t batch_size_;
uint32_t crop_size_;
bool mirror_;
bool cache_images_;
uint32_t context_pad_;
float scale_;
float fg_threshold_;
float bg_threshold_;
float fg_fraction_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class SPPParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.SPPParameter) */ {
public:
inline SPPParameter() : SPPParameter(nullptr) {}
~SPPParameter() override;
explicit constexpr SPPParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SPPParameter(const SPPParameter& from);
SPPParameter(SPPParameter&& from) noexcept
: SPPParameter() {
*this = ::std::move(from);
}
inline SPPParameter& operator=(const SPPParameter& from) {
CopyFrom(from);
return *this;
}
inline SPPParameter& operator=(SPPParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SPPParameter& default_instance() {
return *internal_default_instance();
}
static inline const SPPParameter* internal_default_instance() {
return reinterpret_cast<const SPPParameter*>(
&_SPPParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
93;
friend void swap(SPPParameter& a, SPPParameter& b) {
a.Swap(&b);
}
inline void Swap(SPPParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SPPParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SPPParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SPPParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SPPParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const SPPParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SPPParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.SPPParameter";
}
protected:
explicit SPPParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef SPPParameter_PoolMethod PoolMethod;
static constexpr PoolMethod MAX =
SPPParameter_PoolMethod_MAX;
static constexpr PoolMethod AVE =
SPPParameter_PoolMethod_AVE;
static constexpr PoolMethod STOCHASTIC =
SPPParameter_PoolMethod_STOCHASTIC;
static inline bool PoolMethod_IsValid(int value) {
return SPPParameter_PoolMethod_IsValid(value);
}
static constexpr PoolMethod PoolMethod_MIN =
SPPParameter_PoolMethod_PoolMethod_MIN;
static constexpr PoolMethod PoolMethod_MAX =
SPPParameter_PoolMethod_PoolMethod_MAX;
static constexpr int PoolMethod_ARRAYSIZE =
SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
PoolMethod_descriptor() {
return SPPParameter_PoolMethod_descriptor();
}
template<typename T>
static inline const std::string& PoolMethod_Name(T enum_t_value) {
static_assert(::std::is_same<T, PoolMethod>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PoolMethod_Name.");
return SPPParameter_PoolMethod_Name(enum_t_value);
}
static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
PoolMethod* value) {
return SPPParameter_PoolMethod_Parse(name, value);
}
typedef SPPParameter_Engine Engine;
static constexpr Engine DEFAULT =
SPPParameter_Engine_DEFAULT;
static constexpr Engine CAFFE =
SPPParameter_Engine_CAFFE;
static constexpr Engine CUDNN =
SPPParameter_Engine_CUDNN;
static inline bool Engine_IsValid(int value) {
return SPPParameter_Engine_IsValid(value);
}
static constexpr Engine Engine_MIN =
SPPParameter_Engine_Engine_MIN;
static constexpr Engine Engine_MAX =
SPPParameter_Engine_Engine_MAX;
static constexpr int Engine_ARRAYSIZE =
SPPParameter_Engine_Engine_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Engine_descriptor() {
return SPPParameter_Engine_descriptor();
}
template<typename T>
static inline const std::string& Engine_Name(T enum_t_value) {
static_assert(::std::is_same<T, Engine>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Engine_Name.");
return SPPParameter_Engine_Name(enum_t_value);
}
static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Engine* value) {
return SPPParameter_Engine_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kPyramidHeightFieldNumber = 1,
kPoolFieldNumber = 2,
kEngineFieldNumber = 6,
};
// optional uint32 pyramid_height = 1;
bool has_pyramid_height() const;
private:
bool _internal_has_pyramid_height() const;
public:
void clear_pyramid_height();
uint32_t pyramid_height() const;
void set_pyramid_height(uint32_t value);
private:
uint32_t _internal_pyramid_height() const;
void _internal_set_pyramid_height(uint32_t value);
public:
// optional .caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
bool has_pool() const;
private:
bool _internal_has_pool() const;
public:
void clear_pool();
::caffe::SPPParameter_PoolMethod pool() const;
void set_pool(::caffe::SPPParameter_PoolMethod value);
private:
::caffe::SPPParameter_PoolMethod _internal_pool() const;
void _internal_set_pool(::caffe::SPPParameter_PoolMethod value);
public:
// optional .caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
bool has_engine() const;
private:
bool _internal_has_engine() const;
public:
void clear_engine();
::caffe::SPPParameter_Engine engine() const;
void set_engine(::caffe::SPPParameter_Engine value);
private:
::caffe::SPPParameter_Engine _internal_engine() const;
void _internal_set_engine(::caffe::SPPParameter_Engine value);
public:
// @@protoc_insertion_point(class_scope:caffe.SPPParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t pyramid_height_;
int pool_;
int engine_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class V1LayerParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.V1LayerParameter) */ {
public:
inline V1LayerParameter() : V1LayerParameter(nullptr) {}
~V1LayerParameter() override;
explicit constexpr V1LayerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
V1LayerParameter(const V1LayerParameter& from);
V1LayerParameter(V1LayerParameter&& from) noexcept
: V1LayerParameter() {
*this = ::std::move(from);
}
inline V1LayerParameter& operator=(const V1LayerParameter& from) {
CopyFrom(from);
return *this;
}
inline V1LayerParameter& operator=(V1LayerParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const V1LayerParameter& default_instance() {
return *internal_default_instance();
}
static inline const V1LayerParameter* internal_default_instance() {
return reinterpret_cast<const V1LayerParameter*>(
&_V1LayerParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
94;
friend void swap(V1LayerParameter& a, V1LayerParameter& b) {
a.Swap(&b);
}
inline void Swap(V1LayerParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(V1LayerParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
V1LayerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<V1LayerParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const V1LayerParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const V1LayerParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(V1LayerParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.V1LayerParameter";
}
protected:
explicit V1LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef V1LayerParameter_LayerType LayerType;
static constexpr LayerType NONE =
V1LayerParameter_LayerType_NONE;
static constexpr LayerType ABSVAL =
V1LayerParameter_LayerType_ABSVAL;
static constexpr LayerType ACCURACY =
V1LayerParameter_LayerType_ACCURACY;
static constexpr LayerType ARGMAX =
V1LayerParameter_LayerType_ARGMAX;
static constexpr LayerType BNLL =
V1LayerParameter_LayerType_BNLL;
static constexpr LayerType CONCAT =
V1LayerParameter_LayerType_CONCAT;
static constexpr LayerType CONTRASTIVE_LOSS =
V1LayerParameter_LayerType_CONTRASTIVE_LOSS;
static constexpr LayerType CONVOLUTION =
V1LayerParameter_LayerType_CONVOLUTION;
static constexpr LayerType DATA =
V1LayerParameter_LayerType_DATA;
static constexpr LayerType DECONVOLUTION =
V1LayerParameter_LayerType_DECONVOLUTION;
static constexpr LayerType DROPOUT =
V1LayerParameter_LayerType_DROPOUT;
static constexpr LayerType DUMMY_DATA =
V1LayerParameter_LayerType_DUMMY_DATA;
static constexpr LayerType EUCLIDEAN_LOSS =
V1LayerParameter_LayerType_EUCLIDEAN_LOSS;
static constexpr LayerType ELTWISE =
V1LayerParameter_LayerType_ELTWISE;
static constexpr LayerType EXP =
V1LayerParameter_LayerType_EXP;
static constexpr LayerType FLATTEN =
V1LayerParameter_LayerType_FLATTEN;
static constexpr LayerType HDF5_DATA =
V1LayerParameter_LayerType_HDF5_DATA;
static constexpr LayerType HDF5_OUTPUT =
V1LayerParameter_LayerType_HDF5_OUTPUT;
static constexpr LayerType HINGE_LOSS =
V1LayerParameter_LayerType_HINGE_LOSS;
static constexpr LayerType IM2COL =
V1LayerParameter_LayerType_IM2COL;
static constexpr LayerType IMAGE_DATA =
V1LayerParameter_LayerType_IMAGE_DATA;
static constexpr LayerType INFOGAIN_LOSS =
V1LayerParameter_LayerType_INFOGAIN_LOSS;
static constexpr LayerType INNER_PRODUCT =
V1LayerParameter_LayerType_INNER_PRODUCT;
static constexpr LayerType LRN =
V1LayerParameter_LayerType_LRN;
static constexpr LayerType MEMORY_DATA =
V1LayerParameter_LayerType_MEMORY_DATA;
static constexpr LayerType MULTINOMIAL_LOGISTIC_LOSS =
V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS;
static constexpr LayerType MVN =
V1LayerParameter_LayerType_MVN;
static constexpr LayerType POOLING =
V1LayerParameter_LayerType_POOLING;
static constexpr LayerType POWER =
V1LayerParameter_LayerType_POWER;
static constexpr LayerType RELU =
V1LayerParameter_LayerType_RELU;
static constexpr LayerType SIGMOID =
V1LayerParameter_LayerType_SIGMOID;
static constexpr LayerType SIGMOID_CROSS_ENTROPY_LOSS =
V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS;
static constexpr LayerType SILENCE =
V1LayerParameter_LayerType_SILENCE;
static constexpr LayerType SOFTMAX =
V1LayerParameter_LayerType_SOFTMAX;
static constexpr LayerType SOFTMAX_LOSS =
V1LayerParameter_LayerType_SOFTMAX_LOSS;
static constexpr LayerType SPLIT =
V1LayerParameter_LayerType_SPLIT;
static constexpr LayerType SLICE =
V1LayerParameter_LayerType_SLICE;
static constexpr LayerType TANH =
V1LayerParameter_LayerType_TANH;
static constexpr LayerType WINDOW_DATA =
V1LayerParameter_LayerType_WINDOW_DATA;
static constexpr LayerType THRESHOLD =
V1LayerParameter_LayerType_THRESHOLD;
static inline bool LayerType_IsValid(int value) {
return V1LayerParameter_LayerType_IsValid(value);
}
static constexpr LayerType LayerType_MIN =
V1LayerParameter_LayerType_LayerType_MIN;
static constexpr LayerType LayerType_MAX =
V1LayerParameter_LayerType_LayerType_MAX;
static constexpr int LayerType_ARRAYSIZE =
V1LayerParameter_LayerType_LayerType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
LayerType_descriptor() {
return V1LayerParameter_LayerType_descriptor();
}
template<typename T>
static inline const std::string& LayerType_Name(T enum_t_value) {
static_assert(::std::is_same<T, LayerType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function LayerType_Name.");
return V1LayerParameter_LayerType_Name(enum_t_value);
}
static inline bool LayerType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
LayerType* value) {
return V1LayerParameter_LayerType_Parse(name, value);
}
typedef V1LayerParameter_DimCheckMode DimCheckMode;
static constexpr DimCheckMode STRICT =
V1LayerParameter_DimCheckMode_STRICT;
static constexpr DimCheckMode PERMISSIVE =
V1LayerParameter_DimCheckMode_PERMISSIVE;
static inline bool DimCheckMode_IsValid(int value) {
return V1LayerParameter_DimCheckMode_IsValid(value);
}
static constexpr DimCheckMode DimCheckMode_MIN =
V1LayerParameter_DimCheckMode_DimCheckMode_MIN;
static constexpr DimCheckMode DimCheckMode_MAX =
V1LayerParameter_DimCheckMode_DimCheckMode_MAX;
static constexpr int DimCheckMode_ARRAYSIZE =
V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
DimCheckMode_descriptor() {
return V1LayerParameter_DimCheckMode_descriptor();
}
template<typename T>
static inline const std::string& DimCheckMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, DimCheckMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DimCheckMode_Name.");
return V1LayerParameter_DimCheckMode_Name(enum_t_value);
}
static inline bool DimCheckMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
DimCheckMode* value) {
return V1LayerParameter_DimCheckMode_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kBottomFieldNumber = 2,
kTopFieldNumber = 3,
kBlobsFieldNumber = 6,
kBlobsLrFieldNumber = 7,
kWeightDecayFieldNumber = 8,
kIncludeFieldNumber = 32,
kExcludeFieldNumber = 33,
kLossWeightFieldNumber = 35,
kParamFieldNumber = 1001,
kBlobShareModeFieldNumber = 1002,
kNameFieldNumber = 4,
kLayerFieldNumber = 1,
kConcatParamFieldNumber = 9,
kConvolutionParamFieldNumber = 10,
kDataParamFieldNumber = 11,
kDropoutParamFieldNumber = 12,
kHdf5DataParamFieldNumber = 13,
kHdf5OutputParamFieldNumber = 14,
kImageDataParamFieldNumber = 15,
kInfogainLossParamFieldNumber = 16,
kInnerProductParamFieldNumber = 17,
kLrnParamFieldNumber = 18,
kPoolingParamFieldNumber = 19,
kWindowDataParamFieldNumber = 20,
kPowerParamFieldNumber = 21,
kMemoryDataParamFieldNumber = 22,
kArgmaxParamFieldNumber = 23,
kEltwiseParamFieldNumber = 24,
kThresholdParamFieldNumber = 25,
kDummyDataParamFieldNumber = 26,
kAccuracyParamFieldNumber = 27,
kHingeLossParamFieldNumber = 29,
kReluParamFieldNumber = 30,
kSliceParamFieldNumber = 31,
kMvnParamFieldNumber = 34,
kTransformParamFieldNumber = 36,
kTanhParamFieldNumber = 37,
kSigmoidParamFieldNumber = 38,
kSoftmaxParamFieldNumber = 39,
kContrastiveLossParamFieldNumber = 40,
kExpParamFieldNumber = 41,
kLossParamFieldNumber = 42,
kTypeFieldNumber = 5,
};
// repeated string bottom = 2;
int bottom_size() const;
private:
int _internal_bottom_size() const;
public:
void clear_bottom();
const std::string& bottom(int index) const;
std::string* mutable_bottom(int index);
void set_bottom(int index, const std::string& value);
void set_bottom(int index, std::string&& value);
void set_bottom(int index, const char* value);
void set_bottom(int index, const char* value, size_t size);
std::string* add_bottom();
void add_bottom(const std::string& value);
void add_bottom(std::string&& value);
void add_bottom(const char* value);
void add_bottom(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& bottom() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_bottom();
private:
const std::string& _internal_bottom(int index) const;
std::string* _internal_add_bottom();
public:
// repeated string top = 3;
int top_size() const;
private:
int _internal_top_size() const;
public:
void clear_top();
const std::string& top(int index) const;
std::string* mutable_top(int index);
void set_top(int index, const std::string& value);
void set_top(int index, std::string&& value);
void set_top(int index, const char* value);
void set_top(int index, const char* value, size_t size);
std::string* add_top();
void add_top(const std::string& value);
void add_top(std::string&& value);
void add_top(const char* value);
void add_top(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& top() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_top();
private:
const std::string& _internal_top(int index) const;
std::string* _internal_add_top();
public:
// repeated .caffe.BlobProto blobs = 6;
int blobs_size() const;
private:
int _internal_blobs_size() const;
public:
void clear_blobs();
::caffe::BlobProto* mutable_blobs(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
mutable_blobs();
private:
const ::caffe::BlobProto& _internal_blobs(int index) const;
::caffe::BlobProto* _internal_add_blobs();
public:
const ::caffe::BlobProto& blobs(int index) const;
::caffe::BlobProto* add_blobs();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
blobs() const;
// repeated float blobs_lr = 7;
int blobs_lr_size() const;
private:
int _internal_blobs_lr_size() const;
public:
void clear_blobs_lr();
private:
float _internal_blobs_lr(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_blobs_lr() const;
void _internal_add_blobs_lr(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_blobs_lr();
public:
float blobs_lr(int index) const;
void set_blobs_lr(int index, float value);
void add_blobs_lr(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
blobs_lr() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_blobs_lr();
// repeated float weight_decay = 8;
int weight_decay_size() const;
private:
int _internal_weight_decay_size() const;
public:
void clear_weight_decay();
private:
float _internal_weight_decay(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_weight_decay() const;
void _internal_add_weight_decay(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_weight_decay();
public:
float weight_decay(int index) const;
void set_weight_decay(int index, float value);
void add_weight_decay(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
weight_decay() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_weight_decay();
// repeated .caffe.NetStateRule include = 32;
int include_size() const;
private:
int _internal_include_size() const;
public:
void clear_include();
::caffe::NetStateRule* mutable_include(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >*
mutable_include();
private:
const ::caffe::NetStateRule& _internal_include(int index) const;
::caffe::NetStateRule* _internal_add_include();
public:
const ::caffe::NetStateRule& include(int index) const;
::caffe::NetStateRule* add_include();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >&
include() const;
// repeated .caffe.NetStateRule exclude = 33;
int exclude_size() const;
private:
int _internal_exclude_size() const;
public:
void clear_exclude();
::caffe::NetStateRule* mutable_exclude(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >*
mutable_exclude();
private:
const ::caffe::NetStateRule& _internal_exclude(int index) const;
::caffe::NetStateRule* _internal_add_exclude();
public:
const ::caffe::NetStateRule& exclude(int index) const;
::caffe::NetStateRule* add_exclude();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >&
exclude() const;
// repeated float loss_weight = 35;
int loss_weight_size() const;
private:
int _internal_loss_weight_size() const;
public:
void clear_loss_weight();
private:
float _internal_loss_weight(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_loss_weight() const;
void _internal_add_loss_weight(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_loss_weight();
public:
float loss_weight(int index) const;
void set_loss_weight(int index, float value);
void add_loss_weight(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
loss_weight() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_loss_weight();
// repeated string param = 1001;
int param_size() const;
private:
int _internal_param_size() const;
public:
void clear_param();
const std::string& param(int index) const;
std::string* mutable_param(int index);
void set_param(int index, const std::string& value);
void set_param(int index, std::string&& value);
void set_param(int index, const char* value);
void set_param(int index, const char* value, size_t size);
std::string* add_param();
void add_param(const std::string& value);
void add_param(std::string&& value);
void add_param(const char* value);
void add_param(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& param() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_param();
private:
const std::string& _internal_param(int index) const;
std::string* _internal_add_param();
public:
// repeated .caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
int blob_share_mode_size() const;
private:
int _internal_blob_share_mode_size() const;
public:
void clear_blob_share_mode();
private:
::caffe::V1LayerParameter_DimCheckMode _internal_blob_share_mode(int index) const;
void _internal_add_blob_share_mode(::caffe::V1LayerParameter_DimCheckMode value);
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_blob_share_mode();
public:
::caffe::V1LayerParameter_DimCheckMode blob_share_mode(int index) const;
void set_blob_share_mode(int index, ::caffe::V1LayerParameter_DimCheckMode value);
void add_blob_share_mode(::caffe::V1LayerParameter_DimCheckMode value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& blob_share_mode() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_blob_share_mode();
// optional string name = 4;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional .caffe.V0LayerParameter layer = 1;
bool has_layer() const;
private:
bool _internal_has_layer() const;
public:
void clear_layer();
const ::caffe::V0LayerParameter& layer() const;
PROTOBUF_NODISCARD ::caffe::V0LayerParameter* release_layer();
::caffe::V0LayerParameter* mutable_layer();
void set_allocated_layer(::caffe::V0LayerParameter* layer);
private:
const ::caffe::V0LayerParameter& _internal_layer() const;
::caffe::V0LayerParameter* _internal_mutable_layer();
public:
void unsafe_arena_set_allocated_layer(
::caffe::V0LayerParameter* layer);
::caffe::V0LayerParameter* unsafe_arena_release_layer();
// optional .caffe.ConcatParameter concat_param = 9;
bool has_concat_param() const;
private:
bool _internal_has_concat_param() const;
public:
void clear_concat_param();
const ::caffe::ConcatParameter& concat_param() const;
PROTOBUF_NODISCARD ::caffe::ConcatParameter* release_concat_param();
::caffe::ConcatParameter* mutable_concat_param();
void set_allocated_concat_param(::caffe::ConcatParameter* concat_param);
private:
const ::caffe::ConcatParameter& _internal_concat_param() const;
::caffe::ConcatParameter* _internal_mutable_concat_param();
public:
void unsafe_arena_set_allocated_concat_param(
::caffe::ConcatParameter* concat_param);
::caffe::ConcatParameter* unsafe_arena_release_concat_param();
// optional .caffe.ConvolutionParameter convolution_param = 10;
bool has_convolution_param() const;
private:
bool _internal_has_convolution_param() const;
public:
void clear_convolution_param();
const ::caffe::ConvolutionParameter& convolution_param() const;
PROTOBUF_NODISCARD ::caffe::ConvolutionParameter* release_convolution_param();
::caffe::ConvolutionParameter* mutable_convolution_param();
void set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param);
private:
const ::caffe::ConvolutionParameter& _internal_convolution_param() const;
::caffe::ConvolutionParameter* _internal_mutable_convolution_param();
public:
void unsafe_arena_set_allocated_convolution_param(
::caffe::ConvolutionParameter* convolution_param);
::caffe::ConvolutionParameter* unsafe_arena_release_convolution_param();
// optional .caffe.DataParameter data_param = 11;
bool has_data_param() const;
private:
bool _internal_has_data_param() const;
public:
void clear_data_param();
const ::caffe::DataParameter& data_param() const;
PROTOBUF_NODISCARD ::caffe::DataParameter* release_data_param();
::caffe::DataParameter* mutable_data_param();
void set_allocated_data_param(::caffe::DataParameter* data_param);
private:
const ::caffe::DataParameter& _internal_data_param() const;
::caffe::DataParameter* _internal_mutable_data_param();
public:
void unsafe_arena_set_allocated_data_param(
::caffe::DataParameter* data_param);
::caffe::DataParameter* unsafe_arena_release_data_param();
// optional .caffe.DropoutParameter dropout_param = 12;
bool has_dropout_param() const;
private:
bool _internal_has_dropout_param() const;
public:
void clear_dropout_param();
const ::caffe::DropoutParameter& dropout_param() const;
PROTOBUF_NODISCARD ::caffe::DropoutParameter* release_dropout_param();
::caffe::DropoutParameter* mutable_dropout_param();
void set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param);
private:
const ::caffe::DropoutParameter& _internal_dropout_param() const;
::caffe::DropoutParameter* _internal_mutable_dropout_param();
public:
void unsafe_arena_set_allocated_dropout_param(
::caffe::DropoutParameter* dropout_param);
::caffe::DropoutParameter* unsafe_arena_release_dropout_param();
// optional .caffe.HDF5DataParameter hdf5_data_param = 13;
bool has_hdf5_data_param() const;
private:
bool _internal_has_hdf5_data_param() const;
public:
void clear_hdf5_data_param();
const ::caffe::HDF5DataParameter& hdf5_data_param() const;
PROTOBUF_NODISCARD ::caffe::HDF5DataParameter* release_hdf5_data_param();
::caffe::HDF5DataParameter* mutable_hdf5_data_param();
void set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param);
private:
const ::caffe::HDF5DataParameter& _internal_hdf5_data_param() const;
::caffe::HDF5DataParameter* _internal_mutable_hdf5_data_param();
public:
void unsafe_arena_set_allocated_hdf5_data_param(
::caffe::HDF5DataParameter* hdf5_data_param);
::caffe::HDF5DataParameter* unsafe_arena_release_hdf5_data_param();
// optional .caffe.HDF5OutputParameter hdf5_output_param = 14;
bool has_hdf5_output_param() const;
private:
bool _internal_has_hdf5_output_param() const;
public:
void clear_hdf5_output_param();
const ::caffe::HDF5OutputParameter& hdf5_output_param() const;
PROTOBUF_NODISCARD ::caffe::HDF5OutputParameter* release_hdf5_output_param();
::caffe::HDF5OutputParameter* mutable_hdf5_output_param();
void set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param);
private:
const ::caffe::HDF5OutputParameter& _internal_hdf5_output_param() const;
::caffe::HDF5OutputParameter* _internal_mutable_hdf5_output_param();
public:
void unsafe_arena_set_allocated_hdf5_output_param(
::caffe::HDF5OutputParameter* hdf5_output_param);
::caffe::HDF5OutputParameter* unsafe_arena_release_hdf5_output_param();
// optional .caffe.ImageDataParameter image_data_param = 15;
bool has_image_data_param() const;
private:
bool _internal_has_image_data_param() const;
public:
void clear_image_data_param();
const ::caffe::ImageDataParameter& image_data_param() const;
PROTOBUF_NODISCARD ::caffe::ImageDataParameter* release_image_data_param();
::caffe::ImageDataParameter* mutable_image_data_param();
void set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param);
private:
const ::caffe::ImageDataParameter& _internal_image_data_param() const;
::caffe::ImageDataParameter* _internal_mutable_image_data_param();
public:
void unsafe_arena_set_allocated_image_data_param(
::caffe::ImageDataParameter* image_data_param);
::caffe::ImageDataParameter* unsafe_arena_release_image_data_param();
// optional .caffe.InfogainLossParameter infogain_loss_param = 16;
bool has_infogain_loss_param() const;
private:
bool _internal_has_infogain_loss_param() const;
public:
void clear_infogain_loss_param();
const ::caffe::InfogainLossParameter& infogain_loss_param() const;
PROTOBUF_NODISCARD ::caffe::InfogainLossParameter* release_infogain_loss_param();
::caffe::InfogainLossParameter* mutable_infogain_loss_param();
void set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param);
private:
const ::caffe::InfogainLossParameter& _internal_infogain_loss_param() const;
::caffe::InfogainLossParameter* _internal_mutable_infogain_loss_param();
public:
void unsafe_arena_set_allocated_infogain_loss_param(
::caffe::InfogainLossParameter* infogain_loss_param);
::caffe::InfogainLossParameter* unsafe_arena_release_infogain_loss_param();
// optional .caffe.InnerProductParameter inner_product_param = 17;
bool has_inner_product_param() const;
private:
bool _internal_has_inner_product_param() const;
public:
void clear_inner_product_param();
const ::caffe::InnerProductParameter& inner_product_param() const;
PROTOBUF_NODISCARD ::caffe::InnerProductParameter* release_inner_product_param();
::caffe::InnerProductParameter* mutable_inner_product_param();
void set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param);
private:
const ::caffe::InnerProductParameter& _internal_inner_product_param() const;
::caffe::InnerProductParameter* _internal_mutable_inner_product_param();
public:
void unsafe_arena_set_allocated_inner_product_param(
::caffe::InnerProductParameter* inner_product_param);
::caffe::InnerProductParameter* unsafe_arena_release_inner_product_param();
// optional .caffe.LRNParameter lrn_param = 18;
bool has_lrn_param() const;
private:
bool _internal_has_lrn_param() const;
public:
void clear_lrn_param();
const ::caffe::LRNParameter& lrn_param() const;
PROTOBUF_NODISCARD ::caffe::LRNParameter* release_lrn_param();
::caffe::LRNParameter* mutable_lrn_param();
void set_allocated_lrn_param(::caffe::LRNParameter* lrn_param);
private:
const ::caffe::LRNParameter& _internal_lrn_param() const;
::caffe::LRNParameter* _internal_mutable_lrn_param();
public:
void unsafe_arena_set_allocated_lrn_param(
::caffe::LRNParameter* lrn_param);
::caffe::LRNParameter* unsafe_arena_release_lrn_param();
// optional .caffe.PoolingParameter pooling_param = 19;
bool has_pooling_param() const;
private:
bool _internal_has_pooling_param() const;
public:
void clear_pooling_param();
const ::caffe::PoolingParameter& pooling_param() const;
PROTOBUF_NODISCARD ::caffe::PoolingParameter* release_pooling_param();
::caffe::PoolingParameter* mutable_pooling_param();
void set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param);
private:
const ::caffe::PoolingParameter& _internal_pooling_param() const;
::caffe::PoolingParameter* _internal_mutable_pooling_param();
public:
void unsafe_arena_set_allocated_pooling_param(
::caffe::PoolingParameter* pooling_param);
::caffe::PoolingParameter* unsafe_arena_release_pooling_param();
// optional .caffe.WindowDataParameter window_data_param = 20;
bool has_window_data_param() const;
private:
bool _internal_has_window_data_param() const;
public:
void clear_window_data_param();
const ::caffe::WindowDataParameter& window_data_param() const;
PROTOBUF_NODISCARD ::caffe::WindowDataParameter* release_window_data_param();
::caffe::WindowDataParameter* mutable_window_data_param();
void set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param);
private:
const ::caffe::WindowDataParameter& _internal_window_data_param() const;
::caffe::WindowDataParameter* _internal_mutable_window_data_param();
public:
void unsafe_arena_set_allocated_window_data_param(
::caffe::WindowDataParameter* window_data_param);
::caffe::WindowDataParameter* unsafe_arena_release_window_data_param();
// optional .caffe.PowerParameter power_param = 21;
bool has_power_param() const;
private:
bool _internal_has_power_param() const;
public:
void clear_power_param();
const ::caffe::PowerParameter& power_param() const;
PROTOBUF_NODISCARD ::caffe::PowerParameter* release_power_param();
::caffe::PowerParameter* mutable_power_param();
void set_allocated_power_param(::caffe::PowerParameter* power_param);
private:
const ::caffe::PowerParameter& _internal_power_param() const;
::caffe::PowerParameter* _internal_mutable_power_param();
public:
void unsafe_arena_set_allocated_power_param(
::caffe::PowerParameter* power_param);
::caffe::PowerParameter* unsafe_arena_release_power_param();
// optional .caffe.MemoryDataParameter memory_data_param = 22;
bool has_memory_data_param() const;
private:
bool _internal_has_memory_data_param() const;
public:
void clear_memory_data_param();
const ::caffe::MemoryDataParameter& memory_data_param() const;
PROTOBUF_NODISCARD ::caffe::MemoryDataParameter* release_memory_data_param();
::caffe::MemoryDataParameter* mutable_memory_data_param();
void set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param);
private:
const ::caffe::MemoryDataParameter& _internal_memory_data_param() const;
::caffe::MemoryDataParameter* _internal_mutable_memory_data_param();
public:
void unsafe_arena_set_allocated_memory_data_param(
::caffe::MemoryDataParameter* memory_data_param);
::caffe::MemoryDataParameter* unsafe_arena_release_memory_data_param();
// optional .caffe.ArgMaxParameter argmax_param = 23;
bool has_argmax_param() const;
private:
bool _internal_has_argmax_param() const;
public:
void clear_argmax_param();
const ::caffe::ArgMaxParameter& argmax_param() const;
PROTOBUF_NODISCARD ::caffe::ArgMaxParameter* release_argmax_param();
::caffe::ArgMaxParameter* mutable_argmax_param();
void set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param);
private:
const ::caffe::ArgMaxParameter& _internal_argmax_param() const;
::caffe::ArgMaxParameter* _internal_mutable_argmax_param();
public:
void unsafe_arena_set_allocated_argmax_param(
::caffe::ArgMaxParameter* argmax_param);
::caffe::ArgMaxParameter* unsafe_arena_release_argmax_param();
// optional .caffe.EltwiseParameter eltwise_param = 24;
bool has_eltwise_param() const;
private:
bool _internal_has_eltwise_param() const;
public:
void clear_eltwise_param();
const ::caffe::EltwiseParameter& eltwise_param() const;
PROTOBUF_NODISCARD ::caffe::EltwiseParameter* release_eltwise_param();
::caffe::EltwiseParameter* mutable_eltwise_param();
void set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param);
private:
const ::caffe::EltwiseParameter& _internal_eltwise_param() const;
::caffe::EltwiseParameter* _internal_mutable_eltwise_param();
public:
void unsafe_arena_set_allocated_eltwise_param(
::caffe::EltwiseParameter* eltwise_param);
::caffe::EltwiseParameter* unsafe_arena_release_eltwise_param();
// optional .caffe.ThresholdParameter threshold_param = 25;
bool has_threshold_param() const;
private:
bool _internal_has_threshold_param() const;
public:
void clear_threshold_param();
const ::caffe::ThresholdParameter& threshold_param() const;
PROTOBUF_NODISCARD ::caffe::ThresholdParameter* release_threshold_param();
::caffe::ThresholdParameter* mutable_threshold_param();
void set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param);
private:
const ::caffe::ThresholdParameter& _internal_threshold_param() const;
::caffe::ThresholdParameter* _internal_mutable_threshold_param();
public:
void unsafe_arena_set_allocated_threshold_param(
::caffe::ThresholdParameter* threshold_param);
::caffe::ThresholdParameter* unsafe_arena_release_threshold_param();
// optional .caffe.DummyDataParameter dummy_data_param = 26;
bool has_dummy_data_param() const;
private:
bool _internal_has_dummy_data_param() const;
public:
void clear_dummy_data_param();
const ::caffe::DummyDataParameter& dummy_data_param() const;
PROTOBUF_NODISCARD ::caffe::DummyDataParameter* release_dummy_data_param();
::caffe::DummyDataParameter* mutable_dummy_data_param();
void set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param);
private:
const ::caffe::DummyDataParameter& _internal_dummy_data_param() const;
::caffe::DummyDataParameter* _internal_mutable_dummy_data_param();
public:
void unsafe_arena_set_allocated_dummy_data_param(
::caffe::DummyDataParameter* dummy_data_param);
::caffe::DummyDataParameter* unsafe_arena_release_dummy_data_param();
// optional .caffe.AccuracyParameter accuracy_param = 27;
bool has_accuracy_param() const;
private:
bool _internal_has_accuracy_param() const;
public:
void clear_accuracy_param();
const ::caffe::AccuracyParameter& accuracy_param() const;
PROTOBUF_NODISCARD ::caffe::AccuracyParameter* release_accuracy_param();
::caffe::AccuracyParameter* mutable_accuracy_param();
void set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param);
private:
const ::caffe::AccuracyParameter& _internal_accuracy_param() const;
::caffe::AccuracyParameter* _internal_mutable_accuracy_param();
public:
void unsafe_arena_set_allocated_accuracy_param(
::caffe::AccuracyParameter* accuracy_param);
::caffe::AccuracyParameter* unsafe_arena_release_accuracy_param();
// optional .caffe.HingeLossParameter hinge_loss_param = 29;
bool has_hinge_loss_param() const;
private:
bool _internal_has_hinge_loss_param() const;
public:
void clear_hinge_loss_param();
const ::caffe::HingeLossParameter& hinge_loss_param() const;
PROTOBUF_NODISCARD ::caffe::HingeLossParameter* release_hinge_loss_param();
::caffe::HingeLossParameter* mutable_hinge_loss_param();
void set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param);
private:
const ::caffe::HingeLossParameter& _internal_hinge_loss_param() const;
::caffe::HingeLossParameter* _internal_mutable_hinge_loss_param();
public:
void unsafe_arena_set_allocated_hinge_loss_param(
::caffe::HingeLossParameter* hinge_loss_param);
::caffe::HingeLossParameter* unsafe_arena_release_hinge_loss_param();
// optional .caffe.ReLUParameter relu_param = 30;
bool has_relu_param() const;
private:
bool _internal_has_relu_param() const;
public:
void clear_relu_param();
const ::caffe::ReLUParameter& relu_param() const;
PROTOBUF_NODISCARD ::caffe::ReLUParameter* release_relu_param();
::caffe::ReLUParameter* mutable_relu_param();
void set_allocated_relu_param(::caffe::ReLUParameter* relu_param);
private:
const ::caffe::ReLUParameter& _internal_relu_param() const;
::caffe::ReLUParameter* _internal_mutable_relu_param();
public:
void unsafe_arena_set_allocated_relu_param(
::caffe::ReLUParameter* relu_param);
::caffe::ReLUParameter* unsafe_arena_release_relu_param();
// optional .caffe.SliceParameter slice_param = 31;
bool has_slice_param() const;
private:
bool _internal_has_slice_param() const;
public:
void clear_slice_param();
const ::caffe::SliceParameter& slice_param() const;
PROTOBUF_NODISCARD ::caffe::SliceParameter* release_slice_param();
::caffe::SliceParameter* mutable_slice_param();
void set_allocated_slice_param(::caffe::SliceParameter* slice_param);
private:
const ::caffe::SliceParameter& _internal_slice_param() const;
::caffe::SliceParameter* _internal_mutable_slice_param();
public:
void unsafe_arena_set_allocated_slice_param(
::caffe::SliceParameter* slice_param);
::caffe::SliceParameter* unsafe_arena_release_slice_param();
// optional .caffe.MVNParameter mvn_param = 34;
bool has_mvn_param() const;
private:
bool _internal_has_mvn_param() const;
public:
void clear_mvn_param();
const ::caffe::MVNParameter& mvn_param() const;
PROTOBUF_NODISCARD ::caffe::MVNParameter* release_mvn_param();
::caffe::MVNParameter* mutable_mvn_param();
void set_allocated_mvn_param(::caffe::MVNParameter* mvn_param);
private:
const ::caffe::MVNParameter& _internal_mvn_param() const;
::caffe::MVNParameter* _internal_mutable_mvn_param();
public:
void unsafe_arena_set_allocated_mvn_param(
::caffe::MVNParameter* mvn_param);
::caffe::MVNParameter* unsafe_arena_release_mvn_param();
// optional .caffe.TransformationParameter transform_param = 36;
bool has_transform_param() const;
private:
bool _internal_has_transform_param() const;
public:
void clear_transform_param();
const ::caffe::TransformationParameter& transform_param() const;
PROTOBUF_NODISCARD ::caffe::TransformationParameter* release_transform_param();
::caffe::TransformationParameter* mutable_transform_param();
void set_allocated_transform_param(::caffe::TransformationParameter* transform_param);
private:
const ::caffe::TransformationParameter& _internal_transform_param() const;
::caffe::TransformationParameter* _internal_mutable_transform_param();
public:
void unsafe_arena_set_allocated_transform_param(
::caffe::TransformationParameter* transform_param);
::caffe::TransformationParameter* unsafe_arena_release_transform_param();
// optional .caffe.TanHParameter tanh_param = 37;
bool has_tanh_param() const;
private:
bool _internal_has_tanh_param() const;
public:
void clear_tanh_param();
const ::caffe::TanHParameter& tanh_param() const;
PROTOBUF_NODISCARD ::caffe::TanHParameter* release_tanh_param();
::caffe::TanHParameter* mutable_tanh_param();
void set_allocated_tanh_param(::caffe::TanHParameter* tanh_param);
private:
const ::caffe::TanHParameter& _internal_tanh_param() const;
::caffe::TanHParameter* _internal_mutable_tanh_param();
public:
void unsafe_arena_set_allocated_tanh_param(
::caffe::TanHParameter* tanh_param);
::caffe::TanHParameter* unsafe_arena_release_tanh_param();
// optional .caffe.SigmoidParameter sigmoid_param = 38;
bool has_sigmoid_param() const;
private:
bool _internal_has_sigmoid_param() const;
public:
void clear_sigmoid_param();
const ::caffe::SigmoidParameter& sigmoid_param() const;
PROTOBUF_NODISCARD ::caffe::SigmoidParameter* release_sigmoid_param();
::caffe::SigmoidParameter* mutable_sigmoid_param();
void set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param);
private:
const ::caffe::SigmoidParameter& _internal_sigmoid_param() const;
::caffe::SigmoidParameter* _internal_mutable_sigmoid_param();
public:
void unsafe_arena_set_allocated_sigmoid_param(
::caffe::SigmoidParameter* sigmoid_param);
::caffe::SigmoidParameter* unsafe_arena_release_sigmoid_param();
// optional .caffe.SoftmaxParameter softmax_param = 39;
bool has_softmax_param() const;
private:
bool _internal_has_softmax_param() const;
public:
void clear_softmax_param();
const ::caffe::SoftmaxParameter& softmax_param() const;
PROTOBUF_NODISCARD ::caffe::SoftmaxParameter* release_softmax_param();
::caffe::SoftmaxParameter* mutable_softmax_param();
void set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param);
private:
const ::caffe::SoftmaxParameter& _internal_softmax_param() const;
::caffe::SoftmaxParameter* _internal_mutable_softmax_param();
public:
void unsafe_arena_set_allocated_softmax_param(
::caffe::SoftmaxParameter* softmax_param);
::caffe::SoftmaxParameter* unsafe_arena_release_softmax_param();
// optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40;
bool has_contrastive_loss_param() const;
private:
bool _internal_has_contrastive_loss_param() const;
public:
void clear_contrastive_loss_param();
const ::caffe::ContrastiveLossParameter& contrastive_loss_param() const;
PROTOBUF_NODISCARD ::caffe::ContrastiveLossParameter* release_contrastive_loss_param();
::caffe::ContrastiveLossParameter* mutable_contrastive_loss_param();
void set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param);
private:
const ::caffe::ContrastiveLossParameter& _internal_contrastive_loss_param() const;
::caffe::ContrastiveLossParameter* _internal_mutable_contrastive_loss_param();
public:
void unsafe_arena_set_allocated_contrastive_loss_param(
::caffe::ContrastiveLossParameter* contrastive_loss_param);
::caffe::ContrastiveLossParameter* unsafe_arena_release_contrastive_loss_param();
// optional .caffe.ExpParameter exp_param = 41;
bool has_exp_param() const;
private:
bool _internal_has_exp_param() const;
public:
void clear_exp_param();
const ::caffe::ExpParameter& exp_param() const;
PROTOBUF_NODISCARD ::caffe::ExpParameter* release_exp_param();
::caffe::ExpParameter* mutable_exp_param();
void set_allocated_exp_param(::caffe::ExpParameter* exp_param);
private:
const ::caffe::ExpParameter& _internal_exp_param() const;
::caffe::ExpParameter* _internal_mutable_exp_param();
public:
void unsafe_arena_set_allocated_exp_param(
::caffe::ExpParameter* exp_param);
::caffe::ExpParameter* unsafe_arena_release_exp_param();
// optional .caffe.LossParameter loss_param = 42;
bool has_loss_param() const;
private:
bool _internal_has_loss_param() const;
public:
void clear_loss_param();
const ::caffe::LossParameter& loss_param() const;
PROTOBUF_NODISCARD ::caffe::LossParameter* release_loss_param();
::caffe::LossParameter* mutable_loss_param();
void set_allocated_loss_param(::caffe::LossParameter* loss_param);
private:
const ::caffe::LossParameter& _internal_loss_param() const;
::caffe::LossParameter* _internal_mutable_loss_param();
public:
void unsafe_arena_set_allocated_loss_param(
::caffe::LossParameter* loss_param);
::caffe::LossParameter* unsafe_arena_release_loss_param();
// optional .caffe.V1LayerParameter.LayerType type = 5;
bool has_type() const;
private:
bool _internal_has_type() const;
public:
void clear_type();
::caffe::V1LayerParameter_LayerType type() const;
void set_type(::caffe::V1LayerParameter_LayerType value);
private:
::caffe::V1LayerParameter_LayerType _internal_type() const;
void _internal_set_type(::caffe::V1LayerParameter_LayerType value);
public:
// @@protoc_insertion_point(class_scope:caffe.V1LayerParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> bottom_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> top_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto > blobs_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > blobs_lr_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > weight_decay_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule > include_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule > exclude_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > loss_weight_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> param_;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int> blob_share_mode_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::caffe::V0LayerParameter* layer_;
::caffe::ConcatParameter* concat_param_;
::caffe::ConvolutionParameter* convolution_param_;
::caffe::DataParameter* data_param_;
::caffe::DropoutParameter* dropout_param_;
::caffe::HDF5DataParameter* hdf5_data_param_;
::caffe::HDF5OutputParameter* hdf5_output_param_;
::caffe::ImageDataParameter* image_data_param_;
::caffe::InfogainLossParameter* infogain_loss_param_;
::caffe::InnerProductParameter* inner_product_param_;
::caffe::LRNParameter* lrn_param_;
::caffe::PoolingParameter* pooling_param_;
::caffe::WindowDataParameter* window_data_param_;
::caffe::PowerParameter* power_param_;
::caffe::MemoryDataParameter* memory_data_param_;
::caffe::ArgMaxParameter* argmax_param_;
::caffe::EltwiseParameter* eltwise_param_;
::caffe::ThresholdParameter* threshold_param_;
::caffe::DummyDataParameter* dummy_data_param_;
::caffe::AccuracyParameter* accuracy_param_;
::caffe::HingeLossParameter* hinge_loss_param_;
::caffe::ReLUParameter* relu_param_;
::caffe::SliceParameter* slice_param_;
::caffe::MVNParameter* mvn_param_;
::caffe::TransformationParameter* transform_param_;
::caffe::TanHParameter* tanh_param_;
::caffe::SigmoidParameter* sigmoid_param_;
::caffe::SoftmaxParameter* softmax_param_;
::caffe::ContrastiveLossParameter* contrastive_loss_param_;
::caffe::ExpParameter* exp_param_;
::caffe::LossParameter* loss_param_;
int type_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class V0LayerParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.V0LayerParameter) */ {
public:
inline V0LayerParameter() : V0LayerParameter(nullptr) {}
~V0LayerParameter() override;
explicit constexpr V0LayerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
V0LayerParameter(const V0LayerParameter& from);
V0LayerParameter(V0LayerParameter&& from) noexcept
: V0LayerParameter() {
*this = ::std::move(from);
}
inline V0LayerParameter& operator=(const V0LayerParameter& from) {
CopyFrom(from);
return *this;
}
inline V0LayerParameter& operator=(V0LayerParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const V0LayerParameter& default_instance() {
return *internal_default_instance();
}
static inline const V0LayerParameter* internal_default_instance() {
return reinterpret_cast<const V0LayerParameter*>(
&_V0LayerParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
95;
friend void swap(V0LayerParameter& a, V0LayerParameter& b) {
a.Swap(&b);
}
inline void Swap(V0LayerParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(V0LayerParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
V0LayerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<V0LayerParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const V0LayerParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const V0LayerParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(V0LayerParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.V0LayerParameter";
}
protected:
explicit V0LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef V0LayerParameter_PoolMethod PoolMethod;
static constexpr PoolMethod MAX =
V0LayerParameter_PoolMethod_MAX;
static constexpr PoolMethod AVE =
V0LayerParameter_PoolMethod_AVE;
static constexpr PoolMethod STOCHASTIC =
V0LayerParameter_PoolMethod_STOCHASTIC;
static inline bool PoolMethod_IsValid(int value) {
return V0LayerParameter_PoolMethod_IsValid(value);
}
static constexpr PoolMethod PoolMethod_MIN =
V0LayerParameter_PoolMethod_PoolMethod_MIN;
static constexpr PoolMethod PoolMethod_MAX =
V0LayerParameter_PoolMethod_PoolMethod_MAX;
static constexpr int PoolMethod_ARRAYSIZE =
V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
PoolMethod_descriptor() {
return V0LayerParameter_PoolMethod_descriptor();
}
template<typename T>
static inline const std::string& PoolMethod_Name(T enum_t_value) {
static_assert(::std::is_same<T, PoolMethod>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PoolMethod_Name.");
return V0LayerParameter_PoolMethod_Name(enum_t_value);
}
static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
PoolMethod* value) {
return V0LayerParameter_PoolMethod_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kBlobsFieldNumber = 50,
kBlobsLrFieldNumber = 51,
kWeightDecayFieldNumber = 52,
kNameFieldNumber = 1,
kTypeFieldNumber = 2,
kSourceFieldNumber = 16,
kMeanfileFieldNumber = 18,
kDetCropModeFieldNumber = 59,
kWeightFillerFieldNumber = 5,
kBiasFillerFieldNumber = 6,
kHdf5OutputParamFieldNumber = 1001,
kNumOutputFieldNumber = 3,
kPadFieldNumber = 7,
kKernelsizeFieldNumber = 8,
kPoolFieldNumber = 11,
kBatchsizeFieldNumber = 19,
kCropsizeFieldNumber = 20,
kNewWidthFieldNumber = 63,
kMirrorFieldNumber = 21,
kShuffleImagesFieldNumber = 64,
kRandSkipFieldNumber = 53,
kDetContextPadFieldNumber = 58,
kNewNumFieldNumber = 60,
kNewChannelsFieldNumber = 61,
kNewHeightFieldNumber = 62,
kConcatDimFieldNumber = 65,
kBiastermFieldNumber = 4,
kGroupFieldNumber = 9,
kStrideFieldNumber = 10,
kDropoutRatioFieldNumber = 12,
kLocalSizeFieldNumber = 13,
kAlphaFieldNumber = 14,
kBetaFieldNumber = 15,
kScaleFieldNumber = 17,
kKFieldNumber = 22,
kDetFgThresholdFieldNumber = 54,
kDetBgThresholdFieldNumber = 55,
kDetFgFractionFieldNumber = 56,
};
// repeated .caffe.BlobProto blobs = 50;
int blobs_size() const;
private:
int _internal_blobs_size() const;
public:
void clear_blobs();
::caffe::BlobProto* mutable_blobs(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
mutable_blobs();
private:
const ::caffe::BlobProto& _internal_blobs(int index) const;
::caffe::BlobProto* _internal_add_blobs();
public:
const ::caffe::BlobProto& blobs(int index) const;
::caffe::BlobProto* add_blobs();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
blobs() const;
// repeated float blobs_lr = 51;
int blobs_lr_size() const;
private:
int _internal_blobs_lr_size() const;
public:
void clear_blobs_lr();
private:
float _internal_blobs_lr(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_blobs_lr() const;
void _internal_add_blobs_lr(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_blobs_lr();
public:
float blobs_lr(int index) const;
void set_blobs_lr(int index, float value);
void add_blobs_lr(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
blobs_lr() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_blobs_lr();
// repeated float weight_decay = 52;
int weight_decay_size() const;
private:
int _internal_weight_decay_size() const;
public:
void clear_weight_decay();
private:
float _internal_weight_decay(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_weight_decay() const;
void _internal_add_weight_decay(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_weight_decay();
public:
float weight_decay(int index) const;
void set_weight_decay(int index, float value);
void add_weight_decay(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
weight_decay() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_weight_decay();
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string type = 2;
bool has_type() const;
private:
bool _internal_has_type() const;
public:
void clear_type();
const std::string& type() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_type(ArgT0&& arg0, ArgT... args);
std::string* mutable_type();
PROTOBUF_NODISCARD std::string* release_type();
void set_allocated_type(std::string* type);
private:
const std::string& _internal_type() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
std::string* _internal_mutable_type();
public:
// optional string source = 16;
bool has_source() const;
private:
bool _internal_has_source() const;
public:
void clear_source();
const std::string& source() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_source(ArgT0&& arg0, ArgT... args);
std::string* mutable_source();
PROTOBUF_NODISCARD std::string* release_source();
void set_allocated_source(std::string* source);
private:
const std::string& _internal_source() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
std::string* _internal_mutable_source();
public:
// optional string meanfile = 18;
bool has_meanfile() const;
private:
bool _internal_has_meanfile() const;
public:
void clear_meanfile();
const std::string& meanfile() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_meanfile(ArgT0&& arg0, ArgT... args);
std::string* mutable_meanfile();
PROTOBUF_NODISCARD std::string* release_meanfile();
void set_allocated_meanfile(std::string* meanfile);
private:
const std::string& _internal_meanfile() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_meanfile(const std::string& value);
std::string* _internal_mutable_meanfile();
public:
// optional string det_crop_mode = 59 [default = "warp"];
bool has_det_crop_mode() const;
private:
bool _internal_has_det_crop_mode() const;
public:
void clear_det_crop_mode();
const std::string& det_crop_mode() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_det_crop_mode(ArgT0&& arg0, ArgT... args);
std::string* mutable_det_crop_mode();
PROTOBUF_NODISCARD std::string* release_det_crop_mode();
void set_allocated_det_crop_mode(std::string* det_crop_mode);
private:
const std::string& _internal_det_crop_mode() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_det_crop_mode(const std::string& value);
std::string* _internal_mutable_det_crop_mode();
public:
// optional .caffe.FillerParameter weight_filler = 5;
bool has_weight_filler() const;
private:
bool _internal_has_weight_filler() const;
public:
void clear_weight_filler();
const ::caffe::FillerParameter& weight_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_weight_filler();
::caffe::FillerParameter* mutable_weight_filler();
void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);
private:
const ::caffe::FillerParameter& _internal_weight_filler() const;
::caffe::FillerParameter* _internal_mutable_weight_filler();
public:
void unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler);
::caffe::FillerParameter* unsafe_arena_release_weight_filler();
// optional .caffe.FillerParameter bias_filler = 6;
bool has_bias_filler() const;
private:
bool _internal_has_bias_filler() const;
public:
void clear_bias_filler();
const ::caffe::FillerParameter& bias_filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_bias_filler();
::caffe::FillerParameter* mutable_bias_filler();
void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);
private:
const ::caffe::FillerParameter& _internal_bias_filler() const;
::caffe::FillerParameter* _internal_mutable_bias_filler();
public:
void unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler);
::caffe::FillerParameter* unsafe_arena_release_bias_filler();
// optional .caffe.HDF5OutputParameter hdf5_output_param = 1001;
bool has_hdf5_output_param() const;
private:
bool _internal_has_hdf5_output_param() const;
public:
void clear_hdf5_output_param();
const ::caffe::HDF5OutputParameter& hdf5_output_param() const;
PROTOBUF_NODISCARD ::caffe::HDF5OutputParameter* release_hdf5_output_param();
::caffe::HDF5OutputParameter* mutable_hdf5_output_param();
void set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param);
private:
const ::caffe::HDF5OutputParameter& _internal_hdf5_output_param() const;
::caffe::HDF5OutputParameter* _internal_mutable_hdf5_output_param();
public:
void unsafe_arena_set_allocated_hdf5_output_param(
::caffe::HDF5OutputParameter* hdf5_output_param);
::caffe::HDF5OutputParameter* unsafe_arena_release_hdf5_output_param();
// optional uint32 num_output = 3;
bool has_num_output() const;
private:
bool _internal_has_num_output() const;
public:
void clear_num_output();
uint32_t num_output() const;
void set_num_output(uint32_t value);
private:
uint32_t _internal_num_output() const;
void _internal_set_num_output(uint32_t value);
public:
// optional uint32 pad = 7 [default = 0];
bool has_pad() const;
private:
bool _internal_has_pad() const;
public:
void clear_pad();
uint32_t pad() const;
void set_pad(uint32_t value);
private:
uint32_t _internal_pad() const;
void _internal_set_pad(uint32_t value);
public:
// optional uint32 kernelsize = 8;
bool has_kernelsize() const;
private:
bool _internal_has_kernelsize() const;
public:
void clear_kernelsize();
uint32_t kernelsize() const;
void set_kernelsize(uint32_t value);
private:
uint32_t _internal_kernelsize() const;
void _internal_set_kernelsize(uint32_t value);
public:
// optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
bool has_pool() const;
private:
bool _internal_has_pool() const;
public:
void clear_pool();
::caffe::V0LayerParameter_PoolMethod pool() const;
void set_pool(::caffe::V0LayerParameter_PoolMethod value);
private:
::caffe::V0LayerParameter_PoolMethod _internal_pool() const;
void _internal_set_pool(::caffe::V0LayerParameter_PoolMethod value);
public:
// optional uint32 batchsize = 19;
bool has_batchsize() const;
private:
bool _internal_has_batchsize() const;
public:
void clear_batchsize();
uint32_t batchsize() const;
void set_batchsize(uint32_t value);
private:
uint32_t _internal_batchsize() const;
void _internal_set_batchsize(uint32_t value);
public:
// optional uint32 cropsize = 20 [default = 0];
bool has_cropsize() const;
private:
bool _internal_has_cropsize() const;
public:
void clear_cropsize();
uint32_t cropsize() const;
void set_cropsize(uint32_t value);
private:
uint32_t _internal_cropsize() const;
void _internal_set_cropsize(uint32_t value);
public:
// optional int32 new_width = 63 [default = 0];
bool has_new_width() const;
private:
bool _internal_has_new_width() const;
public:
void clear_new_width();
int32_t new_width() const;
void set_new_width(int32_t value);
private:
int32_t _internal_new_width() const;
void _internal_set_new_width(int32_t value);
public:
// optional bool mirror = 21 [default = false];
bool has_mirror() const;
private:
bool _internal_has_mirror() const;
public:
void clear_mirror();
bool mirror() const;
void set_mirror(bool value);
private:
bool _internal_mirror() const;
void _internal_set_mirror(bool value);
public:
// optional bool shuffle_images = 64 [default = false];
bool has_shuffle_images() const;
private:
bool _internal_has_shuffle_images() const;
public:
void clear_shuffle_images();
bool shuffle_images() const;
void set_shuffle_images(bool value);
private:
bool _internal_shuffle_images() const;
void _internal_set_shuffle_images(bool value);
public:
// optional uint32 rand_skip = 53 [default = 0];
bool has_rand_skip() const;
private:
bool _internal_has_rand_skip() const;
public:
void clear_rand_skip();
uint32_t rand_skip() const;
void set_rand_skip(uint32_t value);
private:
uint32_t _internal_rand_skip() const;
void _internal_set_rand_skip(uint32_t value);
public:
// optional uint32 det_context_pad = 58 [default = 0];
bool has_det_context_pad() const;
private:
bool _internal_has_det_context_pad() const;
public:
void clear_det_context_pad();
uint32_t det_context_pad() const;
void set_det_context_pad(uint32_t value);
private:
uint32_t _internal_det_context_pad() const;
void _internal_set_det_context_pad(uint32_t value);
public:
// optional int32 new_num = 60 [default = 0];
bool has_new_num() const;
private:
bool _internal_has_new_num() const;
public:
void clear_new_num();
int32_t new_num() const;
void set_new_num(int32_t value);
private:
int32_t _internal_new_num() const;
void _internal_set_new_num(int32_t value);
public:
// optional int32 new_channels = 61 [default = 0];
bool has_new_channels() const;
private:
bool _internal_has_new_channels() const;
public:
void clear_new_channels();
int32_t new_channels() const;
void set_new_channels(int32_t value);
private:
int32_t _internal_new_channels() const;
void _internal_set_new_channels(int32_t value);
public:
// optional int32 new_height = 62 [default = 0];
bool has_new_height() const;
private:
bool _internal_has_new_height() const;
public:
void clear_new_height();
int32_t new_height() const;
void set_new_height(int32_t value);
private:
int32_t _internal_new_height() const;
void _internal_set_new_height(int32_t value);
public:
// optional uint32 concat_dim = 65 [default = 1];
bool has_concat_dim() const;
private:
bool _internal_has_concat_dim() const;
public:
void clear_concat_dim();
uint32_t concat_dim() const;
void set_concat_dim(uint32_t value);
private:
uint32_t _internal_concat_dim() const;
void _internal_set_concat_dim(uint32_t value);
public:
// optional bool biasterm = 4 [default = true];
bool has_biasterm() const;
private:
bool _internal_has_biasterm() const;
public:
void clear_biasterm();
bool biasterm() const;
void set_biasterm(bool value);
private:
bool _internal_biasterm() const;
void _internal_set_biasterm(bool value);
public:
// optional uint32 group = 9 [default = 1];
bool has_group() const;
private:
bool _internal_has_group() const;
public:
void clear_group();
uint32_t group() const;
void set_group(uint32_t value);
private:
uint32_t _internal_group() const;
void _internal_set_group(uint32_t value);
public:
// optional uint32 stride = 10 [default = 1];
bool has_stride() const;
private:
bool _internal_has_stride() const;
public:
void clear_stride();
uint32_t stride() const;
void set_stride(uint32_t value);
private:
uint32_t _internal_stride() const;
void _internal_set_stride(uint32_t value);
public:
// optional float dropout_ratio = 12 [default = 0.5];
bool has_dropout_ratio() const;
private:
bool _internal_has_dropout_ratio() const;
public:
void clear_dropout_ratio();
float dropout_ratio() const;
void set_dropout_ratio(float value);
private:
float _internal_dropout_ratio() const;
void _internal_set_dropout_ratio(float value);
public:
// optional uint32 local_size = 13 [default = 5];
bool has_local_size() const;
private:
bool _internal_has_local_size() const;
public:
void clear_local_size();
uint32_t local_size() const;
void set_local_size(uint32_t value);
private:
uint32_t _internal_local_size() const;
void _internal_set_local_size(uint32_t value);
public:
// optional float alpha = 14 [default = 1];
bool has_alpha() const;
private:
bool _internal_has_alpha() const;
public:
void clear_alpha();
float alpha() const;
void set_alpha(float value);
private:
float _internal_alpha() const;
void _internal_set_alpha(float value);
public:
// optional float beta = 15 [default = 0.75];
bool has_beta() const;
private:
bool _internal_has_beta() const;
public:
void clear_beta();
float beta() const;
void set_beta(float value);
private:
float _internal_beta() const;
void _internal_set_beta(float value);
public:
// optional float scale = 17 [default = 1];
bool has_scale() const;
private:
bool _internal_has_scale() const;
public:
void clear_scale();
float scale() const;
void set_scale(float value);
private:
float _internal_scale() const;
void _internal_set_scale(float value);
public:
// optional float k = 22 [default = 1];
bool has_k() const;
private:
bool _internal_has_k() const;
public:
void clear_k();
float k() const;
void set_k(float value);
private:
float _internal_k() const;
void _internal_set_k(float value);
public:
// optional float det_fg_threshold = 54 [default = 0.5];
bool has_det_fg_threshold() const;
private:
bool _internal_has_det_fg_threshold() const;
public:
void clear_det_fg_threshold();
float det_fg_threshold() const;
void set_det_fg_threshold(float value);
private:
float _internal_det_fg_threshold() const;
void _internal_set_det_fg_threshold(float value);
public:
// optional float det_bg_threshold = 55 [default = 0.5];
bool has_det_bg_threshold() const;
private:
bool _internal_has_det_bg_threshold() const;
public:
void clear_det_bg_threshold();
float det_bg_threshold() const;
void set_det_bg_threshold(float value);
private:
float _internal_det_bg_threshold() const;
void _internal_set_det_bg_threshold(float value);
public:
// optional float det_fg_fraction = 56 [default = 0.25];
bool has_det_fg_fraction() const;
private:
bool _internal_has_det_fg_fraction() const;
public:
void clear_det_fg_fraction();
float det_fg_fraction() const;
void set_det_fg_fraction(float value);
private:
float _internal_det_fg_fraction() const;
void _internal_set_det_fg_fraction(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.V0LayerParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto > blobs_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > blobs_lr_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > weight_decay_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr meanfile_;
static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_det_crop_mode_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr det_crop_mode_;
::caffe::FillerParameter* weight_filler_;
::caffe::FillerParameter* bias_filler_;
::caffe::HDF5OutputParameter* hdf5_output_param_;
uint32_t num_output_;
uint32_t pad_;
uint32_t kernelsize_;
int pool_;
uint32_t batchsize_;
uint32_t cropsize_;
int32_t new_width_;
bool mirror_;
bool shuffle_images_;
uint32_t rand_skip_;
uint32_t det_context_pad_;
int32_t new_num_;
int32_t new_channels_;
int32_t new_height_;
uint32_t concat_dim_;
bool biasterm_;
uint32_t group_;
uint32_t stride_;
float dropout_ratio_;
uint32_t local_size_;
float alpha_;
float beta_;
float scale_;
float k_;
float det_fg_threshold_;
float det_bg_threshold_;
float det_fg_fraction_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class PReLUParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.PReLUParameter) */ {
public:
inline PReLUParameter() : PReLUParameter(nullptr) {}
~PReLUParameter() override;
explicit constexpr PReLUParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
PReLUParameter(const PReLUParameter& from);
PReLUParameter(PReLUParameter&& from) noexcept
: PReLUParameter() {
*this = ::std::move(from);
}
inline PReLUParameter& operator=(const PReLUParameter& from) {
CopyFrom(from);
return *this;
}
inline PReLUParameter& operator=(PReLUParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const PReLUParameter& default_instance() {
return *internal_default_instance();
}
static inline const PReLUParameter* internal_default_instance() {
return reinterpret_cast<const PReLUParameter*>(
&_PReLUParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
96;
friend void swap(PReLUParameter& a, PReLUParameter& b) {
a.Swap(&b);
}
inline void Swap(PReLUParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(PReLUParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
PReLUParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<PReLUParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const PReLUParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const PReLUParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(PReLUParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.PReLUParameter";
}
protected:
explicit PReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kFillerFieldNumber = 1,
kChannelSharedFieldNumber = 2,
};
// optional .caffe.FillerParameter filler = 1;
bool has_filler() const;
private:
bool _internal_has_filler() const;
public:
void clear_filler();
const ::caffe::FillerParameter& filler() const;
PROTOBUF_NODISCARD ::caffe::FillerParameter* release_filler();
::caffe::FillerParameter* mutable_filler();
void set_allocated_filler(::caffe::FillerParameter* filler);
private:
const ::caffe::FillerParameter& _internal_filler() const;
::caffe::FillerParameter* _internal_mutable_filler();
public:
void unsafe_arena_set_allocated_filler(
::caffe::FillerParameter* filler);
::caffe::FillerParameter* unsafe_arena_release_filler();
// optional bool channel_shared = 2 [default = false];
bool has_channel_shared() const;
private:
bool _internal_has_channel_shared() const;
public:
void clear_channel_shared();
bool channel_shared() const;
void set_channel_shared(bool value);
private:
bool _internal_channel_shared() const;
void _internal_set_channel_shared(bool value);
public:
// @@protoc_insertion_point(class_scope:caffe.PReLUParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::caffe::FillerParameter* filler_;
bool channel_shared_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class ShuffleChannelParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.ShuffleChannelParameter) */ {
public:
inline ShuffleChannelParameter() : ShuffleChannelParameter(nullptr) {}
~ShuffleChannelParameter() override;
explicit constexpr ShuffleChannelParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ShuffleChannelParameter(const ShuffleChannelParameter& from);
ShuffleChannelParameter(ShuffleChannelParameter&& from) noexcept
: ShuffleChannelParameter() {
*this = ::std::move(from);
}
inline ShuffleChannelParameter& operator=(const ShuffleChannelParameter& from) {
CopyFrom(from);
return *this;
}
inline ShuffleChannelParameter& operator=(ShuffleChannelParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const ShuffleChannelParameter& default_instance() {
return *internal_default_instance();
}
static inline const ShuffleChannelParameter* internal_default_instance() {
return reinterpret_cast<const ShuffleChannelParameter*>(
&_ShuffleChannelParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
97;
friend void swap(ShuffleChannelParameter& a, ShuffleChannelParameter& b) {
a.Swap(&b);
}
inline void Swap(ShuffleChannelParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ShuffleChannelParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ShuffleChannelParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ShuffleChannelParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const ShuffleChannelParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const ShuffleChannelParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ShuffleChannelParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.ShuffleChannelParameter";
}
protected:
explicit ShuffleChannelParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kGroupFieldNumber = 1,
};
// optional uint32 group = 1 [default = 1];
bool has_group() const;
private:
bool _internal_has_group() const;
public:
void clear_group();
uint32_t group() const;
void set_group(uint32_t value);
private:
uint32_t _internal_group() const;
void _internal_set_group(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:caffe.ShuffleChannelParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t group_;
friend struct ::TableStruct_caffe_2eproto;
};
// -------------------------------------------------------------------
class UpsampleParameter final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe.UpsampleParameter) */ {
public:
inline UpsampleParameter() : UpsampleParameter(nullptr) {}
~UpsampleParameter() override;
explicit constexpr UpsampleParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
UpsampleParameter(const UpsampleParameter& from);
UpsampleParameter(UpsampleParameter&& from) noexcept
: UpsampleParameter() {
*this = ::std::move(from);
}
inline UpsampleParameter& operator=(const UpsampleParameter& from) {
CopyFrom(from);
return *this;
}
inline UpsampleParameter& operator=(UpsampleParameter&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const UpsampleParameter& default_instance() {
return *internal_default_instance();
}
static inline const UpsampleParameter* internal_default_instance() {
return reinterpret_cast<const UpsampleParameter*>(
&_UpsampleParameter_default_instance_);
}
static constexpr int kIndexInFileMessages =
98;
friend void swap(UpsampleParameter& a, UpsampleParameter& b) {
a.Swap(&b);
}
inline void Swap(UpsampleParameter* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(UpsampleParameter* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
UpsampleParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<UpsampleParameter>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const UpsampleParameter& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const UpsampleParameter& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(UpsampleParameter* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "caffe.UpsampleParameter";
}
protected:
explicit UpsampleParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kScaleFieldNumber = 1,
};
// optional float scale = 1;
bool has_scale() const;
private:
bool _internal_has_scale() const;
public:
void clear_scale();
float scale() const;
void set_scale(float value);
private:
float _internal_scale() const;
void _internal_set_scale(float value);
public:
// @@protoc_insertion_point(class_scope:caffe.UpsampleParameter)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
float scale_;
friend struct ::TableStruct_caffe_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// BlobShape
// repeated int64 dim = 1 [packed = true];
inline int BlobShape::_internal_dim_size() const {
return dim_.size();
}
inline int BlobShape::dim_size() const {
return _internal_dim_size();
}
inline void BlobShape::clear_dim() {
dim_.Clear();
}
inline int64_t BlobShape::_internal_dim(int index) const {
return dim_.Get(index);
}
inline int64_t BlobShape::dim(int index) const {
// @@protoc_insertion_point(field_get:caffe.BlobShape.dim)
return _internal_dim(index);
}
inline void BlobShape::set_dim(int index, int64_t value) {
dim_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.BlobShape.dim)
}
inline void BlobShape::_internal_add_dim(int64_t value) {
dim_.Add(value);
}
inline void BlobShape::add_dim(int64_t value) {
_internal_add_dim(value);
// @@protoc_insertion_point(field_add:caffe.BlobShape.dim)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
BlobShape::_internal_dim() const {
return dim_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
BlobShape::dim() const {
// @@protoc_insertion_point(field_list:caffe.BlobShape.dim)
return _internal_dim();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
BlobShape::_internal_mutable_dim() {
return &dim_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
BlobShape::mutable_dim() {
// @@protoc_insertion_point(field_mutable_list:caffe.BlobShape.dim)
return _internal_mutable_dim();
}
// -------------------------------------------------------------------
// BlobProto
// optional .caffe.BlobShape shape = 7;
inline bool BlobProto::_internal_has_shape() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || shape_ != nullptr);
return value;
}
inline bool BlobProto::has_shape() const {
return _internal_has_shape();
}
inline void BlobProto::clear_shape() {
if (shape_ != nullptr) shape_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::BlobShape& BlobProto::_internal_shape() const {
const ::caffe::BlobShape* p = shape_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::BlobShape&>(
::caffe::_BlobShape_default_instance_);
}
inline const ::caffe::BlobShape& BlobProto::shape() const {
// @@protoc_insertion_point(field_get:caffe.BlobProto.shape)
return _internal_shape();
}
inline void BlobProto::unsafe_arena_set_allocated_shape(
::caffe::BlobShape* shape) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
}
shape_ = shape;
if (shape) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.BlobProto.shape)
}
inline ::caffe::BlobShape* BlobProto::release_shape() {
_has_bits_[0] &= ~0x00000001u;
::caffe::BlobShape* temp = shape_;
shape_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::BlobShape* BlobProto::unsafe_arena_release_shape() {
// @@protoc_insertion_point(field_release:caffe.BlobProto.shape)
_has_bits_[0] &= ~0x00000001u;
::caffe::BlobShape* temp = shape_;
shape_ = nullptr;
return temp;
}
inline ::caffe::BlobShape* BlobProto::_internal_mutable_shape() {
_has_bits_[0] |= 0x00000001u;
if (shape_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::BlobShape>(GetArenaForAllocation());
shape_ = p;
}
return shape_;
}
inline ::caffe::BlobShape* BlobProto::mutable_shape() {
::caffe::BlobShape* _msg = _internal_mutable_shape();
// @@protoc_insertion_point(field_mutable:caffe.BlobProto.shape)
return _msg;
}
inline void BlobProto::set_allocated_shape(::caffe::BlobShape* shape) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete shape_;
}
if (shape) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::BlobShape>::GetOwningArena(shape);
if (message_arena != submessage_arena) {
shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, shape, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
shape_ = shape;
// @@protoc_insertion_point(field_set_allocated:caffe.BlobProto.shape)
}
// repeated float data = 5 [packed = true];
inline int BlobProto::_internal_data_size() const {
return data_.size();
}
inline int BlobProto::data_size() const {
return _internal_data_size();
}
inline void BlobProto::clear_data() {
data_.Clear();
}
inline float BlobProto::_internal_data(int index) const {
return data_.Get(index);
}
inline float BlobProto::data(int index) const {
// @@protoc_insertion_point(field_get:caffe.BlobProto.data)
return _internal_data(index);
}
inline void BlobProto::set_data(int index, float value) {
data_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.BlobProto.data)
}
inline void BlobProto::_internal_add_data(float value) {
data_.Add(value);
}
inline void BlobProto::add_data(float value) {
_internal_add_data(value);
// @@protoc_insertion_point(field_add:caffe.BlobProto.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BlobProto::_internal_data() const {
return data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BlobProto::data() const {
// @@protoc_insertion_point(field_list:caffe.BlobProto.data)
return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BlobProto::_internal_mutable_data() {
return &data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BlobProto::mutable_data() {
// @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.data)
return _internal_mutable_data();
}
// repeated float diff = 6 [packed = true];
inline int BlobProto::_internal_diff_size() const {
return diff_.size();
}
inline int BlobProto::diff_size() const {
return _internal_diff_size();
}
inline void BlobProto::clear_diff() {
diff_.Clear();
}
inline float BlobProto::_internal_diff(int index) const {
return diff_.Get(index);
}
inline float BlobProto::diff(int index) const {
// @@protoc_insertion_point(field_get:caffe.BlobProto.diff)
return _internal_diff(index);
}
inline void BlobProto::set_diff(int index, float value) {
diff_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.BlobProto.diff)
}
inline void BlobProto::_internal_add_diff(float value) {
diff_.Add(value);
}
inline void BlobProto::add_diff(float value) {
_internal_add_diff(value);
// @@protoc_insertion_point(field_add:caffe.BlobProto.diff)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BlobProto::_internal_diff() const {
return diff_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BlobProto::diff() const {
// @@protoc_insertion_point(field_list:caffe.BlobProto.diff)
return _internal_diff();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BlobProto::_internal_mutable_diff() {
return &diff_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BlobProto::mutable_diff() {
// @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.diff)
return _internal_mutable_diff();
}
// repeated double double_data = 8 [packed = true];
inline int BlobProto::_internal_double_data_size() const {
return double_data_.size();
}
inline int BlobProto::double_data_size() const {
return _internal_double_data_size();
}
inline void BlobProto::clear_double_data() {
double_data_.Clear();
}
inline double BlobProto::_internal_double_data(int index) const {
return double_data_.Get(index);
}
inline double BlobProto::double_data(int index) const {
// @@protoc_insertion_point(field_get:caffe.BlobProto.double_data)
return _internal_double_data(index);
}
inline void BlobProto::set_double_data(int index, double value) {
double_data_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.BlobProto.double_data)
}
inline void BlobProto::_internal_add_double_data(double value) {
double_data_.Add(value);
}
inline void BlobProto::add_double_data(double value) {
_internal_add_double_data(value);
// @@protoc_insertion_point(field_add:caffe.BlobProto.double_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BlobProto::_internal_double_data() const {
return double_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BlobProto::double_data() const {
// @@protoc_insertion_point(field_list:caffe.BlobProto.double_data)
return _internal_double_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BlobProto::_internal_mutable_double_data() {
return &double_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BlobProto::mutable_double_data() {
// @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.double_data)
return _internal_mutable_double_data();
}
// repeated double double_diff = 9 [packed = true];
inline int BlobProto::_internal_double_diff_size() const {
return double_diff_.size();
}
inline int BlobProto::double_diff_size() const {
return _internal_double_diff_size();
}
inline void BlobProto::clear_double_diff() {
double_diff_.Clear();
}
inline double BlobProto::_internal_double_diff(int index) const {
return double_diff_.Get(index);
}
inline double BlobProto::double_diff(int index) const {
// @@protoc_insertion_point(field_get:caffe.BlobProto.double_diff)
return _internal_double_diff(index);
}
inline void BlobProto::set_double_diff(int index, double value) {
double_diff_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.BlobProto.double_diff)
}
inline void BlobProto::_internal_add_double_diff(double value) {
double_diff_.Add(value);
}
inline void BlobProto::add_double_diff(double value) {
_internal_add_double_diff(value);
// @@protoc_insertion_point(field_add:caffe.BlobProto.double_diff)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BlobProto::_internal_double_diff() const {
return double_diff_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BlobProto::double_diff() const {
// @@protoc_insertion_point(field_list:caffe.BlobProto.double_diff)
return _internal_double_diff();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BlobProto::_internal_mutable_double_diff() {
return &double_diff_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BlobProto::mutable_double_diff() {
// @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.double_diff)
return _internal_mutable_double_diff();
}
// optional int32 num = 1 [default = 0];
inline bool BlobProto::_internal_has_num() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool BlobProto::has_num() const {
return _internal_has_num();
}
inline void BlobProto::clear_num() {
num_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t BlobProto::_internal_num() const {
return num_;
}
inline int32_t BlobProto::num() const {
// @@protoc_insertion_point(field_get:caffe.BlobProto.num)
return _internal_num();
}
inline void BlobProto::_internal_set_num(int32_t value) {
_has_bits_[0] |= 0x00000002u;
num_ = value;
}
inline void BlobProto::set_num(int32_t value) {
_internal_set_num(value);
// @@protoc_insertion_point(field_set:caffe.BlobProto.num)
}
// optional int32 channels = 2 [default = 0];
inline bool BlobProto::_internal_has_channels() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool BlobProto::has_channels() const {
return _internal_has_channels();
}
inline void BlobProto::clear_channels() {
channels_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t BlobProto::_internal_channels() const {
return channels_;
}
inline int32_t BlobProto::channels() const {
// @@protoc_insertion_point(field_get:caffe.BlobProto.channels)
return _internal_channels();
}
inline void BlobProto::_internal_set_channels(int32_t value) {
_has_bits_[0] |= 0x00000004u;
channels_ = value;
}
inline void BlobProto::set_channels(int32_t value) {
_internal_set_channels(value);
// @@protoc_insertion_point(field_set:caffe.BlobProto.channels)
}
// optional int32 height = 3 [default = 0];
inline bool BlobProto::_internal_has_height() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool BlobProto::has_height() const {
return _internal_has_height();
}
inline void BlobProto::clear_height() {
height_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline int32_t BlobProto::_internal_height() const {
return height_;
}
inline int32_t BlobProto::height() const {
// @@protoc_insertion_point(field_get:caffe.BlobProto.height)
return _internal_height();
}
inline void BlobProto::_internal_set_height(int32_t value) {
_has_bits_[0] |= 0x00000008u;
height_ = value;
}
inline void BlobProto::set_height(int32_t value) {
_internal_set_height(value);
// @@protoc_insertion_point(field_set:caffe.BlobProto.height)
}
// optional int32 width = 4 [default = 0];
inline bool BlobProto::_internal_has_width() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool BlobProto::has_width() const {
return _internal_has_width();
}
inline void BlobProto::clear_width() {
width_ = 0;
_has_bits_[0] &= ~0x00000010u;
}
inline int32_t BlobProto::_internal_width() const {
return width_;
}
inline int32_t BlobProto::width() const {
// @@protoc_insertion_point(field_get:caffe.BlobProto.width)
return _internal_width();
}
inline void BlobProto::_internal_set_width(int32_t value) {
_has_bits_[0] |= 0x00000010u;
width_ = value;
}
inline void BlobProto::set_width(int32_t value) {
_internal_set_width(value);
// @@protoc_insertion_point(field_set:caffe.BlobProto.width)
}
// -------------------------------------------------------------------
// BlobProtoVector
// repeated .caffe.BlobProto blobs = 1;
inline int BlobProtoVector::_internal_blobs_size() const {
return blobs_.size();
}
inline int BlobProtoVector::blobs_size() const {
return _internal_blobs_size();
}
inline void BlobProtoVector::clear_blobs() {
blobs_.Clear();
}
inline ::caffe::BlobProto* BlobProtoVector::mutable_blobs(int index) {
// @@protoc_insertion_point(field_mutable:caffe.BlobProtoVector.blobs)
return blobs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
BlobProtoVector::mutable_blobs() {
// @@protoc_insertion_point(field_mutable_list:caffe.BlobProtoVector.blobs)
return &blobs_;
}
inline const ::caffe::BlobProto& BlobProtoVector::_internal_blobs(int index) const {
return blobs_.Get(index);
}
inline const ::caffe::BlobProto& BlobProtoVector::blobs(int index) const {
// @@protoc_insertion_point(field_get:caffe.BlobProtoVector.blobs)
return _internal_blobs(index);
}
inline ::caffe::BlobProto* BlobProtoVector::_internal_add_blobs() {
return blobs_.Add();
}
inline ::caffe::BlobProto* BlobProtoVector::add_blobs() {
::caffe::BlobProto* _add = _internal_add_blobs();
// @@protoc_insertion_point(field_add:caffe.BlobProtoVector.blobs)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
BlobProtoVector::blobs() const {
// @@protoc_insertion_point(field_list:caffe.BlobProtoVector.blobs)
return blobs_;
}
// -------------------------------------------------------------------
// Datum
// optional int32 channels = 1;
inline bool Datum::_internal_has_channels() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool Datum::has_channels() const {
return _internal_has_channels();
}
inline void Datum::clear_channels() {
channels_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t Datum::_internal_channels() const {
return channels_;
}
inline int32_t Datum::channels() const {
// @@protoc_insertion_point(field_get:caffe.Datum.channels)
return _internal_channels();
}
inline void Datum::_internal_set_channels(int32_t value) {
_has_bits_[0] |= 0x00000004u;
channels_ = value;
}
inline void Datum::set_channels(int32_t value) {
_internal_set_channels(value);
// @@protoc_insertion_point(field_set:caffe.Datum.channels)
}
// optional int32 height = 2;
inline bool Datum::_internal_has_height() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool Datum::has_height() const {
return _internal_has_height();
}
inline void Datum::clear_height() {
height_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline int32_t Datum::_internal_height() const {
return height_;
}
inline int32_t Datum::height() const {
// @@protoc_insertion_point(field_get:caffe.Datum.height)
return _internal_height();
}
inline void Datum::_internal_set_height(int32_t value) {
_has_bits_[0] |= 0x00000008u;
height_ = value;
}
inline void Datum::set_height(int32_t value) {
_internal_set_height(value);
// @@protoc_insertion_point(field_set:caffe.Datum.height)
}
// optional int32 width = 3;
inline bool Datum::_internal_has_width() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool Datum::has_width() const {
return _internal_has_width();
}
inline void Datum::clear_width() {
width_ = 0;
_has_bits_[0] &= ~0x00000010u;
}
inline int32_t Datum::_internal_width() const {
return width_;
}
inline int32_t Datum::width() const {
// @@protoc_insertion_point(field_get:caffe.Datum.width)
return _internal_width();
}
inline void Datum::_internal_set_width(int32_t value) {
_has_bits_[0] |= 0x00000010u;
width_ = value;
}
inline void Datum::set_width(int32_t value) {
_internal_set_width(value);
// @@protoc_insertion_point(field_set:caffe.Datum.width)
}
// optional bytes data = 4;
inline bool Datum::_internal_has_data() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool Datum::has_data() const {
return _internal_has_data();
}
inline void Datum::clear_data() {
data_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Datum::data() const {
// @@protoc_insertion_point(field_get:caffe.Datum.data)
return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Datum::set_data(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.Datum.data)
}
inline std::string* Datum::mutable_data() {
std::string* _s = _internal_mutable_data();
// @@protoc_insertion_point(field_mutable:caffe.Datum.data)
return _s;
}
inline const std::string& Datum::_internal_data() const {
return data_.Get();
}
inline void Datum::_internal_set_data(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Datum::_internal_mutable_data() {
_has_bits_[0] |= 0x00000001u;
return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Datum::release_data() {
// @@protoc_insertion_point(field_release:caffe.Datum.data)
if (!_internal_has_data()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void Datum::set_allocated_data(std::string* data) {
if (data != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.Datum.data)
}
// optional int32 label = 5;
inline bool Datum::_internal_has_label() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool Datum::has_label() const {
return _internal_has_label();
}
inline void Datum::clear_label() {
label_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline int32_t Datum::_internal_label() const {
return label_;
}
inline int32_t Datum::label() const {
// @@protoc_insertion_point(field_get:caffe.Datum.label)
return _internal_label();
}
inline void Datum::_internal_set_label(int32_t value) {
_has_bits_[0] |= 0x00000020u;
label_ = value;
}
inline void Datum::set_label(int32_t value) {
_internal_set_label(value);
// @@protoc_insertion_point(field_set:caffe.Datum.label)
}
// repeated float float_data = 6;
inline int Datum::_internal_float_data_size() const {
return float_data_.size();
}
inline int Datum::float_data_size() const {
return _internal_float_data_size();
}
inline void Datum::clear_float_data() {
float_data_.Clear();
}
inline float Datum::_internal_float_data(int index) const {
return float_data_.Get(index);
}
inline float Datum::float_data(int index) const {
// @@protoc_insertion_point(field_get:caffe.Datum.float_data)
return _internal_float_data(index);
}
inline void Datum::set_float_data(int index, float value) {
float_data_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.Datum.float_data)
}
inline void Datum::_internal_add_float_data(float value) {
float_data_.Add(value);
}
inline void Datum::add_float_data(float value) {
_internal_add_float_data(value);
// @@protoc_insertion_point(field_add:caffe.Datum.float_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Datum::_internal_float_data() const {
return float_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Datum::float_data() const {
// @@protoc_insertion_point(field_list:caffe.Datum.float_data)
return _internal_float_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Datum::_internal_mutable_float_data() {
return &float_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Datum::mutable_float_data() {
// @@protoc_insertion_point(field_mutable_list:caffe.Datum.float_data)
return _internal_mutable_float_data();
}
// optional bool encoded = 7 [default = false];
inline bool Datum::_internal_has_encoded() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool Datum::has_encoded() const {
return _internal_has_encoded();
}
inline void Datum::clear_encoded() {
encoded_ = false;
_has_bits_[0] &= ~0x00000040u;
}
inline bool Datum::_internal_encoded() const {
return encoded_;
}
inline bool Datum::encoded() const {
// @@protoc_insertion_point(field_get:caffe.Datum.encoded)
return _internal_encoded();
}
inline void Datum::_internal_set_encoded(bool value) {
_has_bits_[0] |= 0x00000040u;
encoded_ = value;
}
inline void Datum::set_encoded(bool value) {
_internal_set_encoded(value);
// @@protoc_insertion_point(field_set:caffe.Datum.encoded)
}
// repeated int32 labels = 8;
inline int Datum::_internal_labels_size() const {
return labels_.size();
}
inline int Datum::labels_size() const {
return _internal_labels_size();
}
inline void Datum::clear_labels() {
labels_.Clear();
}
inline int32_t Datum::_internal_labels(int index) const {
return labels_.Get(index);
}
inline int32_t Datum::labels(int index) const {
// @@protoc_insertion_point(field_get:caffe.Datum.labels)
return _internal_labels(index);
}
inline void Datum::set_labels(int index, int32_t value) {
labels_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.Datum.labels)
}
inline void Datum::_internal_add_labels(int32_t value) {
labels_.Add(value);
}
inline void Datum::add_labels(int32_t value) {
_internal_add_labels(value);
// @@protoc_insertion_point(field_add:caffe.Datum.labels)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Datum::_internal_labels() const {
return labels_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Datum::labels() const {
// @@protoc_insertion_point(field_list:caffe.Datum.labels)
return _internal_labels();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Datum::_internal_mutable_labels() {
return &labels_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Datum::mutable_labels() {
// @@protoc_insertion_point(field_mutable_list:caffe.Datum.labels)
return _internal_mutable_labels();
}
// optional float float_label = 9;
inline bool Datum::_internal_has_float_label() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool Datum::has_float_label() const {
return _internal_has_float_label();
}
inline void Datum::clear_float_label() {
float_label_ = 0;
_has_bits_[0] &= ~0x00000080u;
}
inline float Datum::_internal_float_label() const {
return float_label_;
}
inline float Datum::float_label() const {
// @@protoc_insertion_point(field_get:caffe.Datum.float_label)
return _internal_float_label();
}
inline void Datum::_internal_set_float_label(float value) {
_has_bits_[0] |= 0x00000080u;
float_label_ = value;
}
inline void Datum::set_float_label(float value) {
_internal_set_float_label(value);
// @@protoc_insertion_point(field_set:caffe.Datum.float_label)
}
// repeated float float_labels = 10;
inline int Datum::_internal_float_labels_size() const {
return float_labels_.size();
}
inline int Datum::float_labels_size() const {
return _internal_float_labels_size();
}
inline void Datum::clear_float_labels() {
float_labels_.Clear();
}
inline float Datum::_internal_float_labels(int index) const {
return float_labels_.Get(index);
}
inline float Datum::float_labels(int index) const {
// @@protoc_insertion_point(field_get:caffe.Datum.float_labels)
return _internal_float_labels(index);
}
inline void Datum::set_float_labels(int index, float value) {
float_labels_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.Datum.float_labels)
}
inline void Datum::_internal_add_float_labels(float value) {
float_labels_.Add(value);
}
inline void Datum::add_float_labels(float value) {
_internal_add_float_labels(value);
// @@protoc_insertion_point(field_add:caffe.Datum.float_labels)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Datum::_internal_float_labels() const {
return float_labels_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Datum::float_labels() const {
// @@protoc_insertion_point(field_list:caffe.Datum.float_labels)
return _internal_float_labels();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Datum::_internal_mutable_float_labels() {
return &float_labels_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Datum::mutable_float_labels() {
// @@protoc_insertion_point(field_mutable_list:caffe.Datum.float_labels)
return _internal_mutable_float_labels();
}
// optional bytes byte_labels = 11;
inline bool Datum::_internal_has_byte_labels() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool Datum::has_byte_labels() const {
return _internal_has_byte_labels();
}
inline void Datum::clear_byte_labels() {
byte_labels_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Datum::byte_labels() const {
// @@protoc_insertion_point(field_get:caffe.Datum.byte_labels)
return _internal_byte_labels();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Datum::set_byte_labels(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
byte_labels_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.Datum.byte_labels)
}
inline std::string* Datum::mutable_byte_labels() {
std::string* _s = _internal_mutable_byte_labels();
// @@protoc_insertion_point(field_mutable:caffe.Datum.byte_labels)
return _s;
}
inline const std::string& Datum::_internal_byte_labels() const {
return byte_labels_.Get();
}
inline void Datum::_internal_set_byte_labels(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
byte_labels_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Datum::_internal_mutable_byte_labels() {
_has_bits_[0] |= 0x00000002u;
return byte_labels_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Datum::release_byte_labels() {
// @@protoc_insertion_point(field_release:caffe.Datum.byte_labels)
if (!_internal_has_byte_labels()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = byte_labels_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (byte_labels_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
byte_labels_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void Datum::set_allocated_byte_labels(std::string* byte_labels) {
if (byte_labels != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
byte_labels_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), byte_labels,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (byte_labels_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
byte_labels_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.Datum.byte_labels)
}
// -------------------------------------------------------------------
// MTCNNBBox
// optional float xmin = 1;
inline bool MTCNNBBox::_internal_has_xmin() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool MTCNNBBox::has_xmin() const {
return _internal_has_xmin();
}
inline void MTCNNBBox::clear_xmin() {
xmin_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float MTCNNBBox::_internal_xmin() const {
return xmin_;
}
inline float MTCNNBBox::xmin() const {
// @@protoc_insertion_point(field_get:caffe.MTCNNBBox.xmin)
return _internal_xmin();
}
inline void MTCNNBBox::_internal_set_xmin(float value) {
_has_bits_[0] |= 0x00000001u;
xmin_ = value;
}
inline void MTCNNBBox::set_xmin(float value) {
_internal_set_xmin(value);
// @@protoc_insertion_point(field_set:caffe.MTCNNBBox.xmin)
}
// optional float ymin = 2;
inline bool MTCNNBBox::_internal_has_ymin() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool MTCNNBBox::has_ymin() const {
return _internal_has_ymin();
}
inline void MTCNNBBox::clear_ymin() {
ymin_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline float MTCNNBBox::_internal_ymin() const {
return ymin_;
}
inline float MTCNNBBox::ymin() const {
// @@protoc_insertion_point(field_get:caffe.MTCNNBBox.ymin)
return _internal_ymin();
}
inline void MTCNNBBox::_internal_set_ymin(float value) {
_has_bits_[0] |= 0x00000002u;
ymin_ = value;
}
inline void MTCNNBBox::set_ymin(float value) {
_internal_set_ymin(value);
// @@protoc_insertion_point(field_set:caffe.MTCNNBBox.ymin)
}
// optional float xmax = 3;
inline bool MTCNNBBox::_internal_has_xmax() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool MTCNNBBox::has_xmax() const {
return _internal_has_xmax();
}
inline void MTCNNBBox::clear_xmax() {
xmax_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline float MTCNNBBox::_internal_xmax() const {
return xmax_;
}
inline float MTCNNBBox::xmax() const {
// @@protoc_insertion_point(field_get:caffe.MTCNNBBox.xmax)
return _internal_xmax();
}
inline void MTCNNBBox::_internal_set_xmax(float value) {
_has_bits_[0] |= 0x00000004u;
xmax_ = value;
}
inline void MTCNNBBox::set_xmax(float value) {
_internal_set_xmax(value);
// @@protoc_insertion_point(field_set:caffe.MTCNNBBox.xmax)
}
// optional float ymax = 4;
inline bool MTCNNBBox::_internal_has_ymax() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool MTCNNBBox::has_ymax() const {
return _internal_has_ymax();
}
inline void MTCNNBBox::clear_ymax() {
ymax_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline float MTCNNBBox::_internal_ymax() const {
return ymax_;
}
inline float MTCNNBBox::ymax() const {
// @@protoc_insertion_point(field_get:caffe.MTCNNBBox.ymax)
return _internal_ymax();
}
inline void MTCNNBBox::_internal_set_ymax(float value) {
_has_bits_[0] |= 0x00000008u;
ymax_ = value;
}
inline void MTCNNBBox::set_ymax(float value) {
_internal_set_ymax(value);
// @@protoc_insertion_point(field_set:caffe.MTCNNBBox.ymax)
}
// -------------------------------------------------------------------
// MTCNNDatum
// optional .caffe.Datum datum = 1;
inline bool MTCNNDatum::_internal_has_datum() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || datum_ != nullptr);
return value;
}
inline bool MTCNNDatum::has_datum() const {
return _internal_has_datum();
}
inline void MTCNNDatum::clear_datum() {
if (datum_ != nullptr) datum_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::Datum& MTCNNDatum::_internal_datum() const {
const ::caffe::Datum* p = datum_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::Datum&>(
::caffe::_Datum_default_instance_);
}
inline const ::caffe::Datum& MTCNNDatum::datum() const {
// @@protoc_insertion_point(field_get:caffe.MTCNNDatum.datum)
return _internal_datum();
}
inline void MTCNNDatum::unsafe_arena_set_allocated_datum(
::caffe::Datum* datum) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(datum_);
}
datum_ = datum;
if (datum) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.MTCNNDatum.datum)
}
inline ::caffe::Datum* MTCNNDatum::release_datum() {
_has_bits_[0] &= ~0x00000001u;
::caffe::Datum* temp = datum_;
datum_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::Datum* MTCNNDatum::unsafe_arena_release_datum() {
// @@protoc_insertion_point(field_release:caffe.MTCNNDatum.datum)
_has_bits_[0] &= ~0x00000001u;
::caffe::Datum* temp = datum_;
datum_ = nullptr;
return temp;
}
inline ::caffe::Datum* MTCNNDatum::_internal_mutable_datum() {
_has_bits_[0] |= 0x00000001u;
if (datum_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::Datum>(GetArenaForAllocation());
datum_ = p;
}
return datum_;
}
inline ::caffe::Datum* MTCNNDatum::mutable_datum() {
::caffe::Datum* _msg = _internal_mutable_datum();
// @@protoc_insertion_point(field_mutable:caffe.MTCNNDatum.datum)
return _msg;
}
inline void MTCNNDatum::set_allocated_datum(::caffe::Datum* datum) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete datum_;
}
if (datum) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::Datum>::GetOwningArena(datum);
if (message_arena != submessage_arena) {
datum = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, datum, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
datum_ = datum;
// @@protoc_insertion_point(field_set_allocated:caffe.MTCNNDatum.datum)
}
// optional .caffe.MTCNNBBox roi = 2;
inline bool MTCNNDatum::_internal_has_roi() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || roi_ != nullptr);
return value;
}
inline bool MTCNNDatum::has_roi() const {
return _internal_has_roi();
}
inline void MTCNNDatum::clear_roi() {
if (roi_ != nullptr) roi_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::MTCNNBBox& MTCNNDatum::_internal_roi() const {
const ::caffe::MTCNNBBox* p = roi_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::MTCNNBBox&>(
::caffe::_MTCNNBBox_default_instance_);
}
inline const ::caffe::MTCNNBBox& MTCNNDatum::roi() const {
// @@protoc_insertion_point(field_get:caffe.MTCNNDatum.roi)
return _internal_roi();
}
inline void MTCNNDatum::unsafe_arena_set_allocated_roi(
::caffe::MTCNNBBox* roi) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(roi_);
}
roi_ = roi;
if (roi) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.MTCNNDatum.roi)
}
inline ::caffe::MTCNNBBox* MTCNNDatum::release_roi() {
_has_bits_[0] &= ~0x00000002u;
::caffe::MTCNNBBox* temp = roi_;
roi_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::MTCNNBBox* MTCNNDatum::unsafe_arena_release_roi() {
// @@protoc_insertion_point(field_release:caffe.MTCNNDatum.roi)
_has_bits_[0] &= ~0x00000002u;
::caffe::MTCNNBBox* temp = roi_;
roi_ = nullptr;
return temp;
}
inline ::caffe::MTCNNBBox* MTCNNDatum::_internal_mutable_roi() {
_has_bits_[0] |= 0x00000002u;
if (roi_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::MTCNNBBox>(GetArenaForAllocation());
roi_ = p;
}
return roi_;
}
inline ::caffe::MTCNNBBox* MTCNNDatum::mutable_roi() {
::caffe::MTCNNBBox* _msg = _internal_mutable_roi();
// @@protoc_insertion_point(field_mutable:caffe.MTCNNDatum.roi)
return _msg;
}
inline void MTCNNDatum::set_allocated_roi(::caffe::MTCNNBBox* roi) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete roi_;
}
if (roi) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::MTCNNBBox>::GetOwningArena(roi);
if (message_arena != submessage_arena) {
roi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, roi, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
roi_ = roi;
// @@protoc_insertion_point(field_set_allocated:caffe.MTCNNDatum.roi)
}
// repeated float pts = 3;
inline int MTCNNDatum::_internal_pts_size() const {
return pts_.size();
}
inline int MTCNNDatum::pts_size() const {
return _internal_pts_size();
}
inline void MTCNNDatum::clear_pts() {
pts_.Clear();
}
inline float MTCNNDatum::_internal_pts(int index) const {
return pts_.Get(index);
}
inline float MTCNNDatum::pts(int index) const {
// @@protoc_insertion_point(field_get:caffe.MTCNNDatum.pts)
return _internal_pts(index);
}
inline void MTCNNDatum::set_pts(int index, float value) {
pts_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.MTCNNDatum.pts)
}
inline void MTCNNDatum::_internal_add_pts(float value) {
pts_.Add(value);
}
inline void MTCNNDatum::add_pts(float value) {
_internal_add_pts(value);
// @@protoc_insertion_point(field_add:caffe.MTCNNDatum.pts)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
MTCNNDatum::_internal_pts() const {
return pts_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
MTCNNDatum::pts() const {
// @@protoc_insertion_point(field_list:caffe.MTCNNDatum.pts)
return _internal_pts();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
MTCNNDatum::_internal_mutable_pts() {
return &pts_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
MTCNNDatum::mutable_pts() {
// @@protoc_insertion_point(field_mutable_list:caffe.MTCNNDatum.pts)
return _internal_mutable_pts();
}
// -------------------------------------------------------------------
// LabelMapItem
// optional string name = 1;
inline bool LabelMapItem::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool LabelMapItem::has_name() const {
return _internal_has_name();
}
inline void LabelMapItem::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LabelMapItem::name() const {
// @@protoc_insertion_point(field_get:caffe.LabelMapItem.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LabelMapItem::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.LabelMapItem.name)
}
inline std::string* LabelMapItem::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:caffe.LabelMapItem.name)
return _s;
}
inline const std::string& LabelMapItem::_internal_name() const {
return name_.Get();
}
inline void LabelMapItem::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LabelMapItem::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LabelMapItem::release_name() {
// @@protoc_insertion_point(field_release:caffe.LabelMapItem.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void LabelMapItem::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.LabelMapItem.name)
}
// optional int32 label = 2;
inline bool LabelMapItem::_internal_has_label() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool LabelMapItem::has_label() const {
return _internal_has_label();
}
inline void LabelMapItem::clear_label() {
label_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t LabelMapItem::_internal_label() const {
return label_;
}
inline int32_t LabelMapItem::label() const {
// @@protoc_insertion_point(field_get:caffe.LabelMapItem.label)
return _internal_label();
}
inline void LabelMapItem::_internal_set_label(int32_t value) {
_has_bits_[0] |= 0x00000004u;
label_ = value;
}
inline void LabelMapItem::set_label(int32_t value) {
_internal_set_label(value);
// @@protoc_insertion_point(field_set:caffe.LabelMapItem.label)
}
// optional string display_name = 3;
inline bool LabelMapItem::_internal_has_display_name() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool LabelMapItem::has_display_name() const {
return _internal_has_display_name();
}
inline void LabelMapItem::clear_display_name() {
display_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LabelMapItem::display_name() const {
// @@protoc_insertion_point(field_get:caffe.LabelMapItem.display_name)
return _internal_display_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LabelMapItem::set_display_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
display_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.LabelMapItem.display_name)
}
inline std::string* LabelMapItem::mutable_display_name() {
std::string* _s = _internal_mutable_display_name();
// @@protoc_insertion_point(field_mutable:caffe.LabelMapItem.display_name)
return _s;
}
inline const std::string& LabelMapItem::_internal_display_name() const {
return display_name_.Get();
}
inline void LabelMapItem::_internal_set_display_name(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
display_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LabelMapItem::_internal_mutable_display_name() {
_has_bits_[0] |= 0x00000002u;
return display_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LabelMapItem::release_display_name() {
// @@protoc_insertion_point(field_release:caffe.LabelMapItem.display_name)
if (!_internal_has_display_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = display_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (display_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
display_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void LabelMapItem::set_allocated_display_name(std::string* display_name) {
if (display_name != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
display_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), display_name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (display_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
display_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.LabelMapItem.display_name)
}
// -------------------------------------------------------------------
// LabelMap
// repeated .caffe.LabelMapItem item = 1;
inline int LabelMap::_internal_item_size() const {
return item_.size();
}
inline int LabelMap::item_size() const {
return _internal_item_size();
}
inline void LabelMap::clear_item() {
item_.Clear();
}
inline ::caffe::LabelMapItem* LabelMap::mutable_item(int index) {
// @@protoc_insertion_point(field_mutable:caffe.LabelMap.item)
return item_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LabelMapItem >*
LabelMap::mutable_item() {
// @@protoc_insertion_point(field_mutable_list:caffe.LabelMap.item)
return &item_;
}
inline const ::caffe::LabelMapItem& LabelMap::_internal_item(int index) const {
return item_.Get(index);
}
inline const ::caffe::LabelMapItem& LabelMap::item(int index) const {
// @@protoc_insertion_point(field_get:caffe.LabelMap.item)
return _internal_item(index);
}
inline ::caffe::LabelMapItem* LabelMap::_internal_add_item() {
return item_.Add();
}
inline ::caffe::LabelMapItem* LabelMap::add_item() {
::caffe::LabelMapItem* _add = _internal_add_item();
// @@protoc_insertion_point(field_add:caffe.LabelMap.item)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LabelMapItem >&
LabelMap::item() const {
// @@protoc_insertion_point(field_list:caffe.LabelMap.item)
return item_;
}
// -------------------------------------------------------------------
// Sampler
// optional float min_scale = 1 [default = 1];
inline bool Sampler::_internal_has_min_scale() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool Sampler::has_min_scale() const {
return _internal_has_min_scale();
}
inline void Sampler::clear_min_scale() {
min_scale_ = 1;
_has_bits_[0] &= ~0x00000001u;
}
inline float Sampler::_internal_min_scale() const {
return min_scale_;
}
inline float Sampler::min_scale() const {
// @@protoc_insertion_point(field_get:caffe.Sampler.min_scale)
return _internal_min_scale();
}
inline void Sampler::_internal_set_min_scale(float value) {
_has_bits_[0] |= 0x00000001u;
min_scale_ = value;
}
inline void Sampler::set_min_scale(float value) {
_internal_set_min_scale(value);
// @@protoc_insertion_point(field_set:caffe.Sampler.min_scale)
}
// optional float max_scale = 2 [default = 1];
inline bool Sampler::_internal_has_max_scale() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool Sampler::has_max_scale() const {
return _internal_has_max_scale();
}
inline void Sampler::clear_max_scale() {
max_scale_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline float Sampler::_internal_max_scale() const {
return max_scale_;
}
inline float Sampler::max_scale() const {
// @@protoc_insertion_point(field_get:caffe.Sampler.max_scale)
return _internal_max_scale();
}
inline void Sampler::_internal_set_max_scale(float value) {
_has_bits_[0] |= 0x00000002u;
max_scale_ = value;
}
inline void Sampler::set_max_scale(float value) {
_internal_set_max_scale(value);
// @@protoc_insertion_point(field_set:caffe.Sampler.max_scale)
}
// optional float min_aspect_ratio = 3 [default = 1];
inline bool Sampler::_internal_has_min_aspect_ratio() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool Sampler::has_min_aspect_ratio() const {
return _internal_has_min_aspect_ratio();
}
inline void Sampler::clear_min_aspect_ratio() {
min_aspect_ratio_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline float Sampler::_internal_min_aspect_ratio() const {
return min_aspect_ratio_;
}
inline float Sampler::min_aspect_ratio() const {
// @@protoc_insertion_point(field_get:caffe.Sampler.min_aspect_ratio)
return _internal_min_aspect_ratio();
}
inline void Sampler::_internal_set_min_aspect_ratio(float value) {
_has_bits_[0] |= 0x00000004u;
min_aspect_ratio_ = value;
}
inline void Sampler::set_min_aspect_ratio(float value) {
_internal_set_min_aspect_ratio(value);
// @@protoc_insertion_point(field_set:caffe.Sampler.min_aspect_ratio)
}
// optional float max_aspect_ratio = 4 [default = 1];
inline bool Sampler::_internal_has_max_aspect_ratio() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool Sampler::has_max_aspect_ratio() const {
return _internal_has_max_aspect_ratio();
}
inline void Sampler::clear_max_aspect_ratio() {
max_aspect_ratio_ = 1;
_has_bits_[0] &= ~0x00000008u;
}
inline float Sampler::_internal_max_aspect_ratio() const {
return max_aspect_ratio_;
}
inline float Sampler::max_aspect_ratio() const {
// @@protoc_insertion_point(field_get:caffe.Sampler.max_aspect_ratio)
return _internal_max_aspect_ratio();
}
inline void Sampler::_internal_set_max_aspect_ratio(float value) {
_has_bits_[0] |= 0x00000008u;
max_aspect_ratio_ = value;
}
inline void Sampler::set_max_aspect_ratio(float value) {
_internal_set_max_aspect_ratio(value);
// @@protoc_insertion_point(field_set:caffe.Sampler.max_aspect_ratio)
}
// -------------------------------------------------------------------
// SampleConstraint
// optional float min_jaccard_overlap = 1;
inline bool SampleConstraint::_internal_has_min_jaccard_overlap() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SampleConstraint::has_min_jaccard_overlap() const {
return _internal_has_min_jaccard_overlap();
}
inline void SampleConstraint::clear_min_jaccard_overlap() {
min_jaccard_overlap_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float SampleConstraint::_internal_min_jaccard_overlap() const {
return min_jaccard_overlap_;
}
inline float SampleConstraint::min_jaccard_overlap() const {
// @@protoc_insertion_point(field_get:caffe.SampleConstraint.min_jaccard_overlap)
return _internal_min_jaccard_overlap();
}
inline void SampleConstraint::_internal_set_min_jaccard_overlap(float value) {
_has_bits_[0] |= 0x00000001u;
min_jaccard_overlap_ = value;
}
inline void SampleConstraint::set_min_jaccard_overlap(float value) {
_internal_set_min_jaccard_overlap(value);
// @@protoc_insertion_point(field_set:caffe.SampleConstraint.min_jaccard_overlap)
}
// optional float max_jaccard_overlap = 2;
inline bool SampleConstraint::_internal_has_max_jaccard_overlap() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool SampleConstraint::has_max_jaccard_overlap() const {
return _internal_has_max_jaccard_overlap();
}
inline void SampleConstraint::clear_max_jaccard_overlap() {
max_jaccard_overlap_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline float SampleConstraint::_internal_max_jaccard_overlap() const {
return max_jaccard_overlap_;
}
inline float SampleConstraint::max_jaccard_overlap() const {
// @@protoc_insertion_point(field_get:caffe.SampleConstraint.max_jaccard_overlap)
return _internal_max_jaccard_overlap();
}
inline void SampleConstraint::_internal_set_max_jaccard_overlap(float value) {
_has_bits_[0] |= 0x00000002u;
max_jaccard_overlap_ = value;
}
inline void SampleConstraint::set_max_jaccard_overlap(float value) {
_internal_set_max_jaccard_overlap(value);
// @@protoc_insertion_point(field_set:caffe.SampleConstraint.max_jaccard_overlap)
}
// optional float min_sample_coverage = 3;
inline bool SampleConstraint::_internal_has_min_sample_coverage() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool SampleConstraint::has_min_sample_coverage() const {
return _internal_has_min_sample_coverage();
}
inline void SampleConstraint::clear_min_sample_coverage() {
min_sample_coverage_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline float SampleConstraint::_internal_min_sample_coverage() const {
return min_sample_coverage_;
}
inline float SampleConstraint::min_sample_coverage() const {
// @@protoc_insertion_point(field_get:caffe.SampleConstraint.min_sample_coverage)
return _internal_min_sample_coverage();
}
inline void SampleConstraint::_internal_set_min_sample_coverage(float value) {
_has_bits_[0] |= 0x00000004u;
min_sample_coverage_ = value;
}
inline void SampleConstraint::set_min_sample_coverage(float value) {
_internal_set_min_sample_coverage(value);
// @@protoc_insertion_point(field_set:caffe.SampleConstraint.min_sample_coverage)
}
// optional float max_sample_coverage = 4;
inline bool SampleConstraint::_internal_has_max_sample_coverage() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool SampleConstraint::has_max_sample_coverage() const {
return _internal_has_max_sample_coverage();
}
inline void SampleConstraint::clear_max_sample_coverage() {
max_sample_coverage_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline float SampleConstraint::_internal_max_sample_coverage() const {
return max_sample_coverage_;
}
inline float SampleConstraint::max_sample_coverage() const {
// @@protoc_insertion_point(field_get:caffe.SampleConstraint.max_sample_coverage)
return _internal_max_sample_coverage();
}
inline void SampleConstraint::_internal_set_max_sample_coverage(float value) {
_has_bits_[0] |= 0x00000008u;
max_sample_coverage_ = value;
}
inline void SampleConstraint::set_max_sample_coverage(float value) {
_internal_set_max_sample_coverage(value);
// @@protoc_insertion_point(field_set:caffe.SampleConstraint.max_sample_coverage)
}
// optional float min_object_coverage = 5;
inline bool SampleConstraint::_internal_has_min_object_coverage() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool SampleConstraint::has_min_object_coverage() const {
return _internal_has_min_object_coverage();
}
inline void SampleConstraint::clear_min_object_coverage() {
min_object_coverage_ = 0;
_has_bits_[0] &= ~0x00000010u;
}
inline float SampleConstraint::_internal_min_object_coverage() const {
return min_object_coverage_;
}
inline float SampleConstraint::min_object_coverage() const {
// @@protoc_insertion_point(field_get:caffe.SampleConstraint.min_object_coverage)
return _internal_min_object_coverage();
}
inline void SampleConstraint::_internal_set_min_object_coverage(float value) {
_has_bits_[0] |= 0x00000010u;
min_object_coverage_ = value;
}
inline void SampleConstraint::set_min_object_coverage(float value) {
_internal_set_min_object_coverage(value);
// @@protoc_insertion_point(field_set:caffe.SampleConstraint.min_object_coverage)
}
// optional float max_object_coverage = 6;
inline bool SampleConstraint::_internal_has_max_object_coverage() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool SampleConstraint::has_max_object_coverage() const {
return _internal_has_max_object_coverage();
}
inline void SampleConstraint::clear_max_object_coverage() {
max_object_coverage_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline float SampleConstraint::_internal_max_object_coverage() const {
return max_object_coverage_;
}
inline float SampleConstraint::max_object_coverage() const {
// @@protoc_insertion_point(field_get:caffe.SampleConstraint.max_object_coverage)
return _internal_max_object_coverage();
}
inline void SampleConstraint::_internal_set_max_object_coverage(float value) {
_has_bits_[0] |= 0x00000020u;
max_object_coverage_ = value;
}
inline void SampleConstraint::set_max_object_coverage(float value) {
_internal_set_max_object_coverage(value);
// @@protoc_insertion_point(field_set:caffe.SampleConstraint.max_object_coverage)
}
// -------------------------------------------------------------------
// BatchSampler
// optional bool use_original_image = 1 [default = true];
inline bool BatchSampler::_internal_has_use_original_image() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool BatchSampler::has_use_original_image() const {
return _internal_has_use_original_image();
}
inline void BatchSampler::clear_use_original_image() {
use_original_image_ = true;
_has_bits_[0] &= ~0x00000008u;
}
inline bool BatchSampler::_internal_use_original_image() const {
return use_original_image_;
}
inline bool BatchSampler::use_original_image() const {
// @@protoc_insertion_point(field_get:caffe.BatchSampler.use_original_image)
return _internal_use_original_image();
}
inline void BatchSampler::_internal_set_use_original_image(bool value) {
_has_bits_[0] |= 0x00000008u;
use_original_image_ = value;
}
inline void BatchSampler::set_use_original_image(bool value) {
_internal_set_use_original_image(value);
// @@protoc_insertion_point(field_set:caffe.BatchSampler.use_original_image)
}
// optional .caffe.Sampler sampler = 2;
inline bool BatchSampler::_internal_has_sampler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || sampler_ != nullptr);
return value;
}
inline bool BatchSampler::has_sampler() const {
return _internal_has_sampler();
}
inline void BatchSampler::clear_sampler() {
if (sampler_ != nullptr) sampler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::Sampler& BatchSampler::_internal_sampler() const {
const ::caffe::Sampler* p = sampler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::Sampler&>(
::caffe::_Sampler_default_instance_);
}
inline const ::caffe::Sampler& BatchSampler::sampler() const {
// @@protoc_insertion_point(field_get:caffe.BatchSampler.sampler)
return _internal_sampler();
}
inline void BatchSampler::unsafe_arena_set_allocated_sampler(
::caffe::Sampler* sampler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sampler_);
}
sampler_ = sampler;
if (sampler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.BatchSampler.sampler)
}
inline ::caffe::Sampler* BatchSampler::release_sampler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::Sampler* temp = sampler_;
sampler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::Sampler* BatchSampler::unsafe_arena_release_sampler() {
// @@protoc_insertion_point(field_release:caffe.BatchSampler.sampler)
_has_bits_[0] &= ~0x00000001u;
::caffe::Sampler* temp = sampler_;
sampler_ = nullptr;
return temp;
}
inline ::caffe::Sampler* BatchSampler::_internal_mutable_sampler() {
_has_bits_[0] |= 0x00000001u;
if (sampler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::Sampler>(GetArenaForAllocation());
sampler_ = p;
}
return sampler_;
}
inline ::caffe::Sampler* BatchSampler::mutable_sampler() {
::caffe::Sampler* _msg = _internal_mutable_sampler();
// @@protoc_insertion_point(field_mutable:caffe.BatchSampler.sampler)
return _msg;
}
inline void BatchSampler::set_allocated_sampler(::caffe::Sampler* sampler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete sampler_;
}
if (sampler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::Sampler>::GetOwningArena(sampler);
if (message_arena != submessage_arena) {
sampler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, sampler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
sampler_ = sampler;
// @@protoc_insertion_point(field_set_allocated:caffe.BatchSampler.sampler)
}
// optional .caffe.SampleConstraint sample_constraint = 3;
inline bool BatchSampler::_internal_has_sample_constraint() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || sample_constraint_ != nullptr);
return value;
}
inline bool BatchSampler::has_sample_constraint() const {
return _internal_has_sample_constraint();
}
inline void BatchSampler::clear_sample_constraint() {
if (sample_constraint_ != nullptr) sample_constraint_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::SampleConstraint& BatchSampler::_internal_sample_constraint() const {
const ::caffe::SampleConstraint* p = sample_constraint_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SampleConstraint&>(
::caffe::_SampleConstraint_default_instance_);
}
inline const ::caffe::SampleConstraint& BatchSampler::sample_constraint() const {
// @@protoc_insertion_point(field_get:caffe.BatchSampler.sample_constraint)
return _internal_sample_constraint();
}
inline void BatchSampler::unsafe_arena_set_allocated_sample_constraint(
::caffe::SampleConstraint* sample_constraint) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sample_constraint_);
}
sample_constraint_ = sample_constraint;
if (sample_constraint) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.BatchSampler.sample_constraint)
}
inline ::caffe::SampleConstraint* BatchSampler::release_sample_constraint() {
_has_bits_[0] &= ~0x00000002u;
::caffe::SampleConstraint* temp = sample_constraint_;
sample_constraint_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SampleConstraint* BatchSampler::unsafe_arena_release_sample_constraint() {
// @@protoc_insertion_point(field_release:caffe.BatchSampler.sample_constraint)
_has_bits_[0] &= ~0x00000002u;
::caffe::SampleConstraint* temp = sample_constraint_;
sample_constraint_ = nullptr;
return temp;
}
inline ::caffe::SampleConstraint* BatchSampler::_internal_mutable_sample_constraint() {
_has_bits_[0] |= 0x00000002u;
if (sample_constraint_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SampleConstraint>(GetArenaForAllocation());
sample_constraint_ = p;
}
return sample_constraint_;
}
inline ::caffe::SampleConstraint* BatchSampler::mutable_sample_constraint() {
::caffe::SampleConstraint* _msg = _internal_mutable_sample_constraint();
// @@protoc_insertion_point(field_mutable:caffe.BatchSampler.sample_constraint)
return _msg;
}
inline void BatchSampler::set_allocated_sample_constraint(::caffe::SampleConstraint* sample_constraint) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete sample_constraint_;
}
if (sample_constraint) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SampleConstraint>::GetOwningArena(sample_constraint);
if (message_arena != submessage_arena) {
sample_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, sample_constraint, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
sample_constraint_ = sample_constraint;
// @@protoc_insertion_point(field_set_allocated:caffe.BatchSampler.sample_constraint)
}
// optional uint32 max_sample = 4;
inline bool BatchSampler::_internal_has_max_sample() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool BatchSampler::has_max_sample() const {
return _internal_has_max_sample();
}
inline void BatchSampler::clear_max_sample() {
max_sample_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t BatchSampler::_internal_max_sample() const {
return max_sample_;
}
inline uint32_t BatchSampler::max_sample() const {
// @@protoc_insertion_point(field_get:caffe.BatchSampler.max_sample)
return _internal_max_sample();
}
inline void BatchSampler::_internal_set_max_sample(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
max_sample_ = value;
}
inline void BatchSampler::set_max_sample(uint32_t value) {
_internal_set_max_sample(value);
// @@protoc_insertion_point(field_set:caffe.BatchSampler.max_sample)
}
// optional uint32 max_trials = 5 [default = 100];
inline bool BatchSampler::_internal_has_max_trials() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool BatchSampler::has_max_trials() const {
return _internal_has_max_trials();
}
inline void BatchSampler::clear_max_trials() {
max_trials_ = 100u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t BatchSampler::_internal_max_trials() const {
return max_trials_;
}
inline uint32_t BatchSampler::max_trials() const {
// @@protoc_insertion_point(field_get:caffe.BatchSampler.max_trials)
return _internal_max_trials();
}
inline void BatchSampler::_internal_set_max_trials(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
max_trials_ = value;
}
inline void BatchSampler::set_max_trials(uint32_t value) {
_internal_set_max_trials(value);
// @@protoc_insertion_point(field_set:caffe.BatchSampler.max_trials)
}
// -------------------------------------------------------------------
// EmitConstraint
// optional .caffe.EmitConstraint.EmitType emit_type = 1 [default = CENTER];
inline bool EmitConstraint::_internal_has_emit_type() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool EmitConstraint::has_emit_type() const {
return _internal_has_emit_type();
}
inline void EmitConstraint::clear_emit_type() {
emit_type_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::EmitConstraint_EmitType EmitConstraint::_internal_emit_type() const {
return static_cast< ::caffe::EmitConstraint_EmitType >(emit_type_);
}
inline ::caffe::EmitConstraint_EmitType EmitConstraint::emit_type() const {
// @@protoc_insertion_point(field_get:caffe.EmitConstraint.emit_type)
return _internal_emit_type();
}
inline void EmitConstraint::_internal_set_emit_type(::caffe::EmitConstraint_EmitType value) {
assert(::caffe::EmitConstraint_EmitType_IsValid(value));
_has_bits_[0] |= 0x00000001u;
emit_type_ = value;
}
inline void EmitConstraint::set_emit_type(::caffe::EmitConstraint_EmitType value) {
_internal_set_emit_type(value);
// @@protoc_insertion_point(field_set:caffe.EmitConstraint.emit_type)
}
// optional float emit_overlap = 2;
inline bool EmitConstraint::_internal_has_emit_overlap() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool EmitConstraint::has_emit_overlap() const {
return _internal_has_emit_overlap();
}
inline void EmitConstraint::clear_emit_overlap() {
emit_overlap_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline float EmitConstraint::_internal_emit_overlap() const {
return emit_overlap_;
}
inline float EmitConstraint::emit_overlap() const {
// @@protoc_insertion_point(field_get:caffe.EmitConstraint.emit_overlap)
return _internal_emit_overlap();
}
inline void EmitConstraint::_internal_set_emit_overlap(float value) {
_has_bits_[0] |= 0x00000002u;
emit_overlap_ = value;
}
inline void EmitConstraint::set_emit_overlap(float value) {
_internal_set_emit_overlap(value);
// @@protoc_insertion_point(field_set:caffe.EmitConstraint.emit_overlap)
}
// -------------------------------------------------------------------
// NormalizedBBox
// optional float xmin = 1;
inline bool NormalizedBBox::_internal_has_xmin() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool NormalizedBBox::has_xmin() const {
return _internal_has_xmin();
}
inline void NormalizedBBox::clear_xmin() {
xmin_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float NormalizedBBox::_internal_xmin() const {
return xmin_;
}
inline float NormalizedBBox::xmin() const {
// @@protoc_insertion_point(field_get:caffe.NormalizedBBox.xmin)
return _internal_xmin();
}
inline void NormalizedBBox::_internal_set_xmin(float value) {
_has_bits_[0] |= 0x00000001u;
xmin_ = value;
}
inline void NormalizedBBox::set_xmin(float value) {
_internal_set_xmin(value);
// @@protoc_insertion_point(field_set:caffe.NormalizedBBox.xmin)
}
// optional float ymin = 2;
inline bool NormalizedBBox::_internal_has_ymin() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool NormalizedBBox::has_ymin() const {
return _internal_has_ymin();
}
inline void NormalizedBBox::clear_ymin() {
ymin_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline float NormalizedBBox::_internal_ymin() const {
return ymin_;
}
inline float NormalizedBBox::ymin() const {
// @@protoc_insertion_point(field_get:caffe.NormalizedBBox.ymin)
return _internal_ymin();
}
inline void NormalizedBBox::_internal_set_ymin(float value) {
_has_bits_[0] |= 0x00000002u;
ymin_ = value;
}
inline void NormalizedBBox::set_ymin(float value) {
_internal_set_ymin(value);
// @@protoc_insertion_point(field_set:caffe.NormalizedBBox.ymin)
}
// optional float xmax = 3;
inline bool NormalizedBBox::_internal_has_xmax() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool NormalizedBBox::has_xmax() const {
return _internal_has_xmax();
}
inline void NormalizedBBox::clear_xmax() {
xmax_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline float NormalizedBBox::_internal_xmax() const {
return xmax_;
}
inline float NormalizedBBox::xmax() const {
// @@protoc_insertion_point(field_get:caffe.NormalizedBBox.xmax)
return _internal_xmax();
}
inline void NormalizedBBox::_internal_set_xmax(float value) {
_has_bits_[0] |= 0x00000004u;
xmax_ = value;
}
inline void NormalizedBBox::set_xmax(float value) {
_internal_set_xmax(value);
// @@protoc_insertion_point(field_set:caffe.NormalizedBBox.xmax)
}
// optional float ymax = 4;
inline bool NormalizedBBox::_internal_has_ymax() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool NormalizedBBox::has_ymax() const {
return _internal_has_ymax();
}
inline void NormalizedBBox::clear_ymax() {
ymax_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline float NormalizedBBox::_internal_ymax() const {
return ymax_;
}
inline float NormalizedBBox::ymax() const {
// @@protoc_insertion_point(field_get:caffe.NormalizedBBox.ymax)
return _internal_ymax();
}
inline void NormalizedBBox::_internal_set_ymax(float value) {
_has_bits_[0] |= 0x00000008u;
ymax_ = value;
}
inline void NormalizedBBox::set_ymax(float value) {
_internal_set_ymax(value);
// @@protoc_insertion_point(field_set:caffe.NormalizedBBox.ymax)
}
// optional int32 label = 5;
inline bool NormalizedBBox::_internal_has_label() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool NormalizedBBox::has_label() const {
return _internal_has_label();
}
inline void NormalizedBBox::clear_label() {
label_ = 0;
_has_bits_[0] &= ~0x00000010u;
}
inline int32_t NormalizedBBox::_internal_label() const {
return label_;
}
inline int32_t NormalizedBBox::label() const {
// @@protoc_insertion_point(field_get:caffe.NormalizedBBox.label)
return _internal_label();
}
inline void NormalizedBBox::_internal_set_label(int32_t value) {
_has_bits_[0] |= 0x00000010u;
label_ = value;
}
inline void NormalizedBBox::set_label(int32_t value) {
_internal_set_label(value);
// @@protoc_insertion_point(field_set:caffe.NormalizedBBox.label)
}
// optional bool difficult = 6;
inline bool NormalizedBBox::_internal_has_difficult() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool NormalizedBBox::has_difficult() const {
return _internal_has_difficult();
}
inline void NormalizedBBox::clear_difficult() {
difficult_ = false;
_has_bits_[0] &= ~0x00000020u;
}
inline bool NormalizedBBox::_internal_difficult() const {
return difficult_;
}
inline bool NormalizedBBox::difficult() const {
// @@protoc_insertion_point(field_get:caffe.NormalizedBBox.difficult)
return _internal_difficult();
}
inline void NormalizedBBox::_internal_set_difficult(bool value) {
_has_bits_[0] |= 0x00000020u;
difficult_ = value;
}
inline void NormalizedBBox::set_difficult(bool value) {
_internal_set_difficult(value);
// @@protoc_insertion_point(field_set:caffe.NormalizedBBox.difficult)
}
// optional float score = 7;
inline bool NormalizedBBox::_internal_has_score() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool NormalizedBBox::has_score() const {
return _internal_has_score();
}
inline void NormalizedBBox::clear_score() {
score_ = 0;
_has_bits_[0] &= ~0x00000040u;
}
inline float NormalizedBBox::_internal_score() const {
return score_;
}
inline float NormalizedBBox::score() const {
// @@protoc_insertion_point(field_get:caffe.NormalizedBBox.score)
return _internal_score();
}
inline void NormalizedBBox::_internal_set_score(float value) {
_has_bits_[0] |= 0x00000040u;
score_ = value;
}
inline void NormalizedBBox::set_score(float value) {
_internal_set_score(value);
// @@protoc_insertion_point(field_set:caffe.NormalizedBBox.score)
}
// optional float size = 8;
inline bool NormalizedBBox::_internal_has_size() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool NormalizedBBox::has_size() const {
return _internal_has_size();
}
inline void NormalizedBBox::clear_size() {
size_ = 0;
_has_bits_[0] &= ~0x00000080u;
}
inline float NormalizedBBox::_internal_size() const {
return size_;
}
inline float NormalizedBBox::size() const {
// @@protoc_insertion_point(field_get:caffe.NormalizedBBox.size)
return _internal_size();
}
inline void NormalizedBBox::_internal_set_size(float value) {
_has_bits_[0] |= 0x00000080u;
size_ = value;
}
inline void NormalizedBBox::set_size(float value) {
_internal_set_size(value);
// @@protoc_insertion_point(field_set:caffe.NormalizedBBox.size)
}
// -------------------------------------------------------------------
// Annotation
// optional int32 instance_id = 1 [default = 0];
inline bool Annotation::_internal_has_instance_id() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool Annotation::has_instance_id() const {
return _internal_has_instance_id();
}
inline void Annotation::clear_instance_id() {
instance_id_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t Annotation::_internal_instance_id() const {
return instance_id_;
}
inline int32_t Annotation::instance_id() const {
// @@protoc_insertion_point(field_get:caffe.Annotation.instance_id)
return _internal_instance_id();
}
inline void Annotation::_internal_set_instance_id(int32_t value) {
_has_bits_[0] |= 0x00000002u;
instance_id_ = value;
}
inline void Annotation::set_instance_id(int32_t value) {
_internal_set_instance_id(value);
// @@protoc_insertion_point(field_set:caffe.Annotation.instance_id)
}
// optional .caffe.NormalizedBBox bbox = 2;
inline bool Annotation::_internal_has_bbox() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || bbox_ != nullptr);
return value;
}
inline bool Annotation::has_bbox() const {
return _internal_has_bbox();
}
inline void Annotation::clear_bbox() {
if (bbox_ != nullptr) bbox_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::NormalizedBBox& Annotation::_internal_bbox() const {
const ::caffe::NormalizedBBox* p = bbox_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::NormalizedBBox&>(
::caffe::_NormalizedBBox_default_instance_);
}
inline const ::caffe::NormalizedBBox& Annotation::bbox() const {
// @@protoc_insertion_point(field_get:caffe.Annotation.bbox)
return _internal_bbox();
}
inline void Annotation::unsafe_arena_set_allocated_bbox(
::caffe::NormalizedBBox* bbox) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bbox_);
}
bbox_ = bbox;
if (bbox) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.Annotation.bbox)
}
inline ::caffe::NormalizedBBox* Annotation::release_bbox() {
_has_bits_[0] &= ~0x00000001u;
::caffe::NormalizedBBox* temp = bbox_;
bbox_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::NormalizedBBox* Annotation::unsafe_arena_release_bbox() {
// @@protoc_insertion_point(field_release:caffe.Annotation.bbox)
_has_bits_[0] &= ~0x00000001u;
::caffe::NormalizedBBox* temp = bbox_;
bbox_ = nullptr;
return temp;
}
inline ::caffe::NormalizedBBox* Annotation::_internal_mutable_bbox() {
_has_bits_[0] |= 0x00000001u;
if (bbox_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::NormalizedBBox>(GetArenaForAllocation());
bbox_ = p;
}
return bbox_;
}
inline ::caffe::NormalizedBBox* Annotation::mutable_bbox() {
::caffe::NormalizedBBox* _msg = _internal_mutable_bbox();
// @@protoc_insertion_point(field_mutable:caffe.Annotation.bbox)
return _msg;
}
inline void Annotation::set_allocated_bbox(::caffe::NormalizedBBox* bbox) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bbox_;
}
if (bbox) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::NormalizedBBox>::GetOwningArena(bbox);
if (message_arena != submessage_arena) {
bbox = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bbox, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
bbox_ = bbox;
// @@protoc_insertion_point(field_set_allocated:caffe.Annotation.bbox)
}
// -------------------------------------------------------------------
// AnnotationGroup
// optional int32 group_label = 1;
inline bool AnnotationGroup::_internal_has_group_label() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool AnnotationGroup::has_group_label() const {
return _internal_has_group_label();
}
inline void AnnotationGroup::clear_group_label() {
group_label_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t AnnotationGroup::_internal_group_label() const {
return group_label_;
}
inline int32_t AnnotationGroup::group_label() const {
// @@protoc_insertion_point(field_get:caffe.AnnotationGroup.group_label)
return _internal_group_label();
}
inline void AnnotationGroup::_internal_set_group_label(int32_t value) {
_has_bits_[0] |= 0x00000001u;
group_label_ = value;
}
inline void AnnotationGroup::set_group_label(int32_t value) {
_internal_set_group_label(value);
// @@protoc_insertion_point(field_set:caffe.AnnotationGroup.group_label)
}
// repeated .caffe.Annotation annotation = 2;
inline int AnnotationGroup::_internal_annotation_size() const {
return annotation_.size();
}
inline int AnnotationGroup::annotation_size() const {
return _internal_annotation_size();
}
inline void AnnotationGroup::clear_annotation() {
annotation_.Clear();
}
inline ::caffe::Annotation* AnnotationGroup::mutable_annotation(int index) {
// @@protoc_insertion_point(field_mutable:caffe.AnnotationGroup.annotation)
return annotation_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::Annotation >*
AnnotationGroup::mutable_annotation() {
// @@protoc_insertion_point(field_mutable_list:caffe.AnnotationGroup.annotation)
return &annotation_;
}
inline const ::caffe::Annotation& AnnotationGroup::_internal_annotation(int index) const {
return annotation_.Get(index);
}
inline const ::caffe::Annotation& AnnotationGroup::annotation(int index) const {
// @@protoc_insertion_point(field_get:caffe.AnnotationGroup.annotation)
return _internal_annotation(index);
}
inline ::caffe::Annotation* AnnotationGroup::_internal_add_annotation() {
return annotation_.Add();
}
inline ::caffe::Annotation* AnnotationGroup::add_annotation() {
::caffe::Annotation* _add = _internal_add_annotation();
// @@protoc_insertion_point(field_add:caffe.AnnotationGroup.annotation)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::Annotation >&
AnnotationGroup::annotation() const {
// @@protoc_insertion_point(field_list:caffe.AnnotationGroup.annotation)
return annotation_;
}
// -------------------------------------------------------------------
// AnnotatedDatum
// optional .caffe.Datum datum = 1;
inline bool AnnotatedDatum::_internal_has_datum() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || datum_ != nullptr);
return value;
}
inline bool AnnotatedDatum::has_datum() const {
return _internal_has_datum();
}
inline void AnnotatedDatum::clear_datum() {
if (datum_ != nullptr) datum_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::Datum& AnnotatedDatum::_internal_datum() const {
const ::caffe::Datum* p = datum_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::Datum&>(
::caffe::_Datum_default_instance_);
}
inline const ::caffe::Datum& AnnotatedDatum::datum() const {
// @@protoc_insertion_point(field_get:caffe.AnnotatedDatum.datum)
return _internal_datum();
}
inline void AnnotatedDatum::unsafe_arena_set_allocated_datum(
::caffe::Datum* datum) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(datum_);
}
datum_ = datum;
if (datum) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.AnnotatedDatum.datum)
}
inline ::caffe::Datum* AnnotatedDatum::release_datum() {
_has_bits_[0] &= ~0x00000001u;
::caffe::Datum* temp = datum_;
datum_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::Datum* AnnotatedDatum::unsafe_arena_release_datum() {
// @@protoc_insertion_point(field_release:caffe.AnnotatedDatum.datum)
_has_bits_[0] &= ~0x00000001u;
::caffe::Datum* temp = datum_;
datum_ = nullptr;
return temp;
}
inline ::caffe::Datum* AnnotatedDatum::_internal_mutable_datum() {
_has_bits_[0] |= 0x00000001u;
if (datum_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::Datum>(GetArenaForAllocation());
datum_ = p;
}
return datum_;
}
inline ::caffe::Datum* AnnotatedDatum::mutable_datum() {
::caffe::Datum* _msg = _internal_mutable_datum();
// @@protoc_insertion_point(field_mutable:caffe.AnnotatedDatum.datum)
return _msg;
}
inline void AnnotatedDatum::set_allocated_datum(::caffe::Datum* datum) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete datum_;
}
if (datum) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::Datum>::GetOwningArena(datum);
if (message_arena != submessage_arena) {
datum = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, datum, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
datum_ = datum;
// @@protoc_insertion_point(field_set_allocated:caffe.AnnotatedDatum.datum)
}
// optional .caffe.AnnotatedDatum.AnnotationType type = 2;
inline bool AnnotatedDatum::_internal_has_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool AnnotatedDatum::has_type() const {
return _internal_has_type();
}
inline void AnnotatedDatum::clear_type() {
type_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::caffe::AnnotatedDatum_AnnotationType AnnotatedDatum::_internal_type() const {
return static_cast< ::caffe::AnnotatedDatum_AnnotationType >(type_);
}
inline ::caffe::AnnotatedDatum_AnnotationType AnnotatedDatum::type() const {
// @@protoc_insertion_point(field_get:caffe.AnnotatedDatum.type)
return _internal_type();
}
inline void AnnotatedDatum::_internal_set_type(::caffe::AnnotatedDatum_AnnotationType value) {
assert(::caffe::AnnotatedDatum_AnnotationType_IsValid(value));
_has_bits_[0] |= 0x00000002u;
type_ = value;
}
inline void AnnotatedDatum::set_type(::caffe::AnnotatedDatum_AnnotationType value) {
_internal_set_type(value);
// @@protoc_insertion_point(field_set:caffe.AnnotatedDatum.type)
}
// repeated .caffe.AnnotationGroup annotation_group = 3;
inline int AnnotatedDatum::_internal_annotation_group_size() const {
return annotation_group_.size();
}
inline int AnnotatedDatum::annotation_group_size() const {
return _internal_annotation_group_size();
}
inline void AnnotatedDatum::clear_annotation_group() {
annotation_group_.Clear();
}
inline ::caffe::AnnotationGroup* AnnotatedDatum::mutable_annotation_group(int index) {
// @@protoc_insertion_point(field_mutable:caffe.AnnotatedDatum.annotation_group)
return annotation_group_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::AnnotationGroup >*
AnnotatedDatum::mutable_annotation_group() {
// @@protoc_insertion_point(field_mutable_list:caffe.AnnotatedDatum.annotation_group)
return &annotation_group_;
}
inline const ::caffe::AnnotationGroup& AnnotatedDatum::_internal_annotation_group(int index) const {
return annotation_group_.Get(index);
}
inline const ::caffe::AnnotationGroup& AnnotatedDatum::annotation_group(int index) const {
// @@protoc_insertion_point(field_get:caffe.AnnotatedDatum.annotation_group)
return _internal_annotation_group(index);
}
inline ::caffe::AnnotationGroup* AnnotatedDatum::_internal_add_annotation_group() {
return annotation_group_.Add();
}
inline ::caffe::AnnotationGroup* AnnotatedDatum::add_annotation_group() {
::caffe::AnnotationGroup* _add = _internal_add_annotation_group();
// @@protoc_insertion_point(field_add:caffe.AnnotatedDatum.annotation_group)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::AnnotationGroup >&
AnnotatedDatum::annotation_group() const {
// @@protoc_insertion_point(field_list:caffe.AnnotatedDatum.annotation_group)
return annotation_group_;
}
// -------------------------------------------------------------------
// FillerParameter
// optional string type = 1 [default = "constant"];
inline bool FillerParameter::_internal_has_type() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool FillerParameter::has_type() const {
return _internal_has_type();
}
inline void FillerParameter::clear_type() {
type_.ClearToDefault(::caffe::FillerParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation());
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& FillerParameter::type() const {
// @@protoc_insertion_point(field_get:caffe.FillerParameter.type)
if (type_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_type_.get();
return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FillerParameter::set_type(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.FillerParameter.type)
}
inline std::string* FillerParameter::mutable_type() {
std::string* _s = _internal_mutable_type();
// @@protoc_insertion_point(field_mutable:caffe.FillerParameter.type)
return _s;
}
inline const std::string& FillerParameter::_internal_type() const {
return type_.Get();
}
inline void FillerParameter::_internal_set_type(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FillerParameter::_internal_mutable_type() {
_has_bits_[0] |= 0x00000001u;
return type_.Mutable(::caffe::FillerParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation());
}
inline std::string* FillerParameter::release_type() {
// @@protoc_insertion_point(field_release:caffe.FillerParameter.type)
if (!_internal_has_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = type_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
return p;
}
inline void FillerParameter::set_allocated_type(std::string* type) {
if (type != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
type_.SetAllocated(nullptr, type,
GetArenaForAllocation());
// @@protoc_insertion_point(field_set_allocated:caffe.FillerParameter.type)
}
// optional float value = 2 [default = 0];
inline bool FillerParameter::_internal_has_value() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool FillerParameter::has_value() const {
return _internal_has_value();
}
inline void FillerParameter::clear_value() {
value_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline float FillerParameter::_internal_value() const {
return value_;
}
inline float FillerParameter::value() const {
// @@protoc_insertion_point(field_get:caffe.FillerParameter.value)
return _internal_value();
}
inline void FillerParameter::_internal_set_value(float value) {
_has_bits_[0] |= 0x00000002u;
value_ = value;
}
inline void FillerParameter::set_value(float value) {
_internal_set_value(value);
// @@protoc_insertion_point(field_set:caffe.FillerParameter.value)
}
// optional float min = 3 [default = 0];
inline bool FillerParameter::_internal_has_min() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool FillerParameter::has_min() const {
return _internal_has_min();
}
inline void FillerParameter::clear_min() {
min_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline float FillerParameter::_internal_min() const {
return min_;
}
inline float FillerParameter::min() const {
// @@protoc_insertion_point(field_get:caffe.FillerParameter.min)
return _internal_min();
}
inline void FillerParameter::_internal_set_min(float value) {
_has_bits_[0] |= 0x00000004u;
min_ = value;
}
inline void FillerParameter::set_min(float value) {
_internal_set_min(value);
// @@protoc_insertion_point(field_set:caffe.FillerParameter.min)
}
// optional float max = 4 [default = 1];
inline bool FillerParameter::_internal_has_max() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool FillerParameter::has_max() const {
return _internal_has_max();
}
inline void FillerParameter::clear_max() {
max_ = 1;
_has_bits_[0] &= ~0x00000040u;
}
inline float FillerParameter::_internal_max() const {
return max_;
}
inline float FillerParameter::max() const {
// @@protoc_insertion_point(field_get:caffe.FillerParameter.max)
return _internal_max();
}
inline void FillerParameter::_internal_set_max(float value) {
_has_bits_[0] |= 0x00000040u;
max_ = value;
}
inline void FillerParameter::set_max(float value) {
_internal_set_max(value);
// @@protoc_insertion_point(field_set:caffe.FillerParameter.max)
}
// optional float mean = 5 [default = 0];
inline bool FillerParameter::_internal_has_mean() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool FillerParameter::has_mean() const {
return _internal_has_mean();
}
inline void FillerParameter::clear_mean() {
mean_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline float FillerParameter::_internal_mean() const {
return mean_;
}
inline float FillerParameter::mean() const {
// @@protoc_insertion_point(field_get:caffe.FillerParameter.mean)
return _internal_mean();
}
inline void FillerParameter::_internal_set_mean(float value) {
_has_bits_[0] |= 0x00000008u;
mean_ = value;
}
inline void FillerParameter::set_mean(float value) {
_internal_set_mean(value);
// @@protoc_insertion_point(field_set:caffe.FillerParameter.mean)
}
// optional float std = 6 [default = 1];
inline bool FillerParameter::_internal_has_std() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool FillerParameter::has_std() const {
return _internal_has_std();
}
inline void FillerParameter::clear_std() {
std_ = 1;
_has_bits_[0] &= ~0x00000080u;
}
inline float FillerParameter::_internal_std() const {
return std_;
}
inline float FillerParameter::std() const {
// @@protoc_insertion_point(field_get:caffe.FillerParameter.std)
return _internal_std();
}
inline void FillerParameter::_internal_set_std(float value) {
_has_bits_[0] |= 0x00000080u;
std_ = value;
}
inline void FillerParameter::set_std(float value) {
_internal_set_std(value);
// @@protoc_insertion_point(field_set:caffe.FillerParameter.std)
}
// optional int32 sparse = 7 [default = -1];
inline bool FillerParameter::_internal_has_sparse() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool FillerParameter::has_sparse() const {
return _internal_has_sparse();
}
inline void FillerParameter::clear_sparse() {
sparse_ = -1;
_has_bits_[0] &= ~0x00000020u;
}
inline int32_t FillerParameter::_internal_sparse() const {
return sparse_;
}
inline int32_t FillerParameter::sparse() const {
// @@protoc_insertion_point(field_get:caffe.FillerParameter.sparse)
return _internal_sparse();
}
inline void FillerParameter::_internal_set_sparse(int32_t value) {
_has_bits_[0] |= 0x00000020u;
sparse_ = value;
}
inline void FillerParameter::set_sparse(int32_t value) {
_internal_set_sparse(value);
// @@protoc_insertion_point(field_set:caffe.FillerParameter.sparse)
}
// optional .caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
inline bool FillerParameter::_internal_has_variance_norm() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool FillerParameter::has_variance_norm() const {
return _internal_has_variance_norm();
}
inline void FillerParameter::clear_variance_norm() {
variance_norm_ = 0;
_has_bits_[0] &= ~0x00000010u;
}
inline ::caffe::FillerParameter_VarianceNorm FillerParameter::_internal_variance_norm() const {
return static_cast< ::caffe::FillerParameter_VarianceNorm >(variance_norm_);
}
inline ::caffe::FillerParameter_VarianceNorm FillerParameter::variance_norm() const {
// @@protoc_insertion_point(field_get:caffe.FillerParameter.variance_norm)
return _internal_variance_norm();
}
inline void FillerParameter::_internal_set_variance_norm(::caffe::FillerParameter_VarianceNorm value) {
assert(::caffe::FillerParameter_VarianceNorm_IsValid(value));
_has_bits_[0] |= 0x00000010u;
variance_norm_ = value;
}
inline void FillerParameter::set_variance_norm(::caffe::FillerParameter_VarianceNorm value) {
_internal_set_variance_norm(value);
// @@protoc_insertion_point(field_set:caffe.FillerParameter.variance_norm)
}
// -------------------------------------------------------------------
// NetParameter
// optional string name = 1;
inline bool NetParameter::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool NetParameter::has_name() const {
return _internal_has_name();
}
inline void NetParameter::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NetParameter::name() const {
// @@protoc_insertion_point(field_get:caffe.NetParameter.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NetParameter::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.NetParameter.name)
}
inline std::string* NetParameter::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:caffe.NetParameter.name)
return _s;
}
inline const std::string& NetParameter::_internal_name() const {
return name_.Get();
}
inline void NetParameter::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* NetParameter::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* NetParameter::release_name() {
// @@protoc_insertion_point(field_release:caffe.NetParameter.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void NetParameter::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.NetParameter.name)
}
// repeated string input = 3;
inline int NetParameter::_internal_input_size() const {
return input_.size();
}
inline int NetParameter::input_size() const {
return _internal_input_size();
}
inline void NetParameter::clear_input() {
input_.Clear();
}
inline std::string* NetParameter::add_input() {
std::string* _s = _internal_add_input();
// @@protoc_insertion_point(field_add_mutable:caffe.NetParameter.input)
return _s;
}
inline const std::string& NetParameter::_internal_input(int index) const {
return input_.Get(index);
}
inline const std::string& NetParameter::input(int index) const {
// @@protoc_insertion_point(field_get:caffe.NetParameter.input)
return _internal_input(index);
}
inline std::string* NetParameter::mutable_input(int index) {
// @@protoc_insertion_point(field_mutable:caffe.NetParameter.input)
return input_.Mutable(index);
}
inline void NetParameter::set_input(int index, const std::string& value) {
input_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.NetParameter.input)
}
inline void NetParameter::set_input(int index, std::string&& value) {
input_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.NetParameter.input)
}
inline void NetParameter::set_input(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
input_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.NetParameter.input)
}
inline void NetParameter::set_input(int index, const char* value, size_t size) {
input_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.NetParameter.input)
}
inline std::string* NetParameter::_internal_add_input() {
return input_.Add();
}
inline void NetParameter::add_input(const std::string& value) {
input_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.NetParameter.input)
}
inline void NetParameter::add_input(std::string&& value) {
input_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.NetParameter.input)
}
inline void NetParameter::add_input(const char* value) {
GOOGLE_DCHECK(value != nullptr);
input_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.NetParameter.input)
}
inline void NetParameter::add_input(const char* value, size_t size) {
input_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.NetParameter.input)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetParameter::input() const {
// @@protoc_insertion_point(field_list:caffe.NetParameter.input)
return input_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetParameter::mutable_input() {
// @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.input)
return &input_;
}
// repeated .caffe.BlobShape input_shape = 8;
inline int NetParameter::_internal_input_shape_size() const {
return input_shape_.size();
}
inline int NetParameter::input_shape_size() const {
return _internal_input_shape_size();
}
inline void NetParameter::clear_input_shape() {
input_shape_.Clear();
}
inline ::caffe::BlobShape* NetParameter::mutable_input_shape(int index) {
// @@protoc_insertion_point(field_mutable:caffe.NetParameter.input_shape)
return input_shape_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >*
NetParameter::mutable_input_shape() {
// @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.input_shape)
return &input_shape_;
}
inline const ::caffe::BlobShape& NetParameter::_internal_input_shape(int index) const {
return input_shape_.Get(index);
}
inline const ::caffe::BlobShape& NetParameter::input_shape(int index) const {
// @@protoc_insertion_point(field_get:caffe.NetParameter.input_shape)
return _internal_input_shape(index);
}
inline ::caffe::BlobShape* NetParameter::_internal_add_input_shape() {
return input_shape_.Add();
}
inline ::caffe::BlobShape* NetParameter::add_input_shape() {
::caffe::BlobShape* _add = _internal_add_input_shape();
// @@protoc_insertion_point(field_add:caffe.NetParameter.input_shape)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >&
NetParameter::input_shape() const {
// @@protoc_insertion_point(field_list:caffe.NetParameter.input_shape)
return input_shape_;
}
// repeated int32 input_dim = 4;
inline int NetParameter::_internal_input_dim_size() const {
return input_dim_.size();
}
inline int NetParameter::input_dim_size() const {
return _internal_input_dim_size();
}
inline void NetParameter::clear_input_dim() {
input_dim_.Clear();
}
inline int32_t NetParameter::_internal_input_dim(int index) const {
return input_dim_.Get(index);
}
inline int32_t NetParameter::input_dim(int index) const {
// @@protoc_insertion_point(field_get:caffe.NetParameter.input_dim)
return _internal_input_dim(index);
}
inline void NetParameter::set_input_dim(int index, int32_t value) {
input_dim_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.NetParameter.input_dim)
}
inline void NetParameter::_internal_add_input_dim(int32_t value) {
input_dim_.Add(value);
}
inline void NetParameter::add_input_dim(int32_t value) {
_internal_add_input_dim(value);
// @@protoc_insertion_point(field_add:caffe.NetParameter.input_dim)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
NetParameter::_internal_input_dim() const {
return input_dim_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
NetParameter::input_dim() const {
// @@protoc_insertion_point(field_list:caffe.NetParameter.input_dim)
return _internal_input_dim();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
NetParameter::_internal_mutable_input_dim() {
return &input_dim_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
NetParameter::mutable_input_dim() {
// @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.input_dim)
return _internal_mutable_input_dim();
}
// optional bool force_backward = 5 [default = false];
inline bool NetParameter::_internal_has_force_backward() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool NetParameter::has_force_backward() const {
return _internal_has_force_backward();
}
inline void NetParameter::clear_force_backward() {
force_backward_ = false;
_has_bits_[0] &= ~0x00000004u;
}
inline bool NetParameter::_internal_force_backward() const {
return force_backward_;
}
inline bool NetParameter::force_backward() const {
// @@protoc_insertion_point(field_get:caffe.NetParameter.force_backward)
return _internal_force_backward();
}
inline void NetParameter::_internal_set_force_backward(bool value) {
_has_bits_[0] |= 0x00000004u;
force_backward_ = value;
}
inline void NetParameter::set_force_backward(bool value) {
_internal_set_force_backward(value);
// @@protoc_insertion_point(field_set:caffe.NetParameter.force_backward)
}
// optional .caffe.NetState state = 6;
inline bool NetParameter::_internal_has_state() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || state_ != nullptr);
return value;
}
inline bool NetParameter::has_state() const {
return _internal_has_state();
}
inline void NetParameter::clear_state() {
if (state_ != nullptr) state_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::NetState& NetParameter::_internal_state() const {
const ::caffe::NetState* p = state_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::NetState&>(
::caffe::_NetState_default_instance_);
}
inline const ::caffe::NetState& NetParameter::state() const {
// @@protoc_insertion_point(field_get:caffe.NetParameter.state)
return _internal_state();
}
inline void NetParameter::unsafe_arena_set_allocated_state(
::caffe::NetState* state) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(state_);
}
state_ = state;
if (state) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.NetParameter.state)
}
inline ::caffe::NetState* NetParameter::release_state() {
_has_bits_[0] &= ~0x00000002u;
::caffe::NetState* temp = state_;
state_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::NetState* NetParameter::unsafe_arena_release_state() {
// @@protoc_insertion_point(field_release:caffe.NetParameter.state)
_has_bits_[0] &= ~0x00000002u;
::caffe::NetState* temp = state_;
state_ = nullptr;
return temp;
}
inline ::caffe::NetState* NetParameter::_internal_mutable_state() {
_has_bits_[0] |= 0x00000002u;
if (state_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::NetState>(GetArenaForAllocation());
state_ = p;
}
return state_;
}
inline ::caffe::NetState* NetParameter::mutable_state() {
::caffe::NetState* _msg = _internal_mutable_state();
// @@protoc_insertion_point(field_mutable:caffe.NetParameter.state)
return _msg;
}
inline void NetParameter::set_allocated_state(::caffe::NetState* state) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete state_;
}
if (state) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::NetState>::GetOwningArena(state);
if (message_arena != submessage_arena) {
state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, state, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
state_ = state;
// @@protoc_insertion_point(field_set_allocated:caffe.NetParameter.state)
}
// optional bool debug_info = 7 [default = false];
inline bool NetParameter::_internal_has_debug_info() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool NetParameter::has_debug_info() const {
return _internal_has_debug_info();
}
inline void NetParameter::clear_debug_info() {
debug_info_ = false;
_has_bits_[0] &= ~0x00000008u;
}
inline bool NetParameter::_internal_debug_info() const {
return debug_info_;
}
inline bool NetParameter::debug_info() const {
// @@protoc_insertion_point(field_get:caffe.NetParameter.debug_info)
return _internal_debug_info();
}
inline void NetParameter::_internal_set_debug_info(bool value) {
_has_bits_[0] |= 0x00000008u;
debug_info_ = value;
}
inline void NetParameter::set_debug_info(bool value) {
_internal_set_debug_info(value);
// @@protoc_insertion_point(field_set:caffe.NetParameter.debug_info)
}
// repeated .caffe.LayerParameter layer = 100;
inline int NetParameter::_internal_layer_size() const {
return layer_.size();
}
inline int NetParameter::layer_size() const {
return _internal_layer_size();
}
inline void NetParameter::clear_layer() {
layer_.Clear();
}
inline ::caffe::LayerParameter* NetParameter::mutable_layer(int index) {
// @@protoc_insertion_point(field_mutable:caffe.NetParameter.layer)
return layer_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LayerParameter >*
NetParameter::mutable_layer() {
// @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.layer)
return &layer_;
}
inline const ::caffe::LayerParameter& NetParameter::_internal_layer(int index) const {
return layer_.Get(index);
}
inline const ::caffe::LayerParameter& NetParameter::layer(int index) const {
// @@protoc_insertion_point(field_get:caffe.NetParameter.layer)
return _internal_layer(index);
}
inline ::caffe::LayerParameter* NetParameter::_internal_add_layer() {
return layer_.Add();
}
inline ::caffe::LayerParameter* NetParameter::add_layer() {
::caffe::LayerParameter* _add = _internal_add_layer();
// @@protoc_insertion_point(field_add:caffe.NetParameter.layer)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::LayerParameter >&
NetParameter::layer() const {
// @@protoc_insertion_point(field_list:caffe.NetParameter.layer)
return layer_;
}
// repeated .caffe.V1LayerParameter layers = 2;
inline int NetParameter::_internal_layers_size() const {
return layers_.size();
}
inline int NetParameter::layers_size() const {
return _internal_layers_size();
}
inline void NetParameter::clear_layers() {
layers_.Clear();
}
inline ::caffe::V1LayerParameter* NetParameter::mutable_layers(int index) {
// @@protoc_insertion_point(field_mutable:caffe.NetParameter.layers)
return layers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::V1LayerParameter >*
NetParameter::mutable_layers() {
// @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.layers)
return &layers_;
}
inline const ::caffe::V1LayerParameter& NetParameter::_internal_layers(int index) const {
return layers_.Get(index);
}
inline const ::caffe::V1LayerParameter& NetParameter::layers(int index) const {
// @@protoc_insertion_point(field_get:caffe.NetParameter.layers)
return _internal_layers(index);
}
inline ::caffe::V1LayerParameter* NetParameter::_internal_add_layers() {
return layers_.Add();
}
inline ::caffe::V1LayerParameter* NetParameter::add_layers() {
::caffe::V1LayerParameter* _add = _internal_add_layers();
// @@protoc_insertion_point(field_add:caffe.NetParameter.layers)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::V1LayerParameter >&
NetParameter::layers() const {
// @@protoc_insertion_point(field_list:caffe.NetParameter.layers)
return layers_;
}
// -------------------------------------------------------------------
// SolverParameter
// optional string net = 24;
inline bool SolverParameter::_internal_has_net() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool SolverParameter::has_net() const {
return _internal_has_net();
}
inline void SolverParameter::clear_net() {
net_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SolverParameter::net() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.net)
return _internal_net();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_net(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000008u;
net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SolverParameter.net)
}
inline std::string* SolverParameter::mutable_net() {
std::string* _s = _internal_mutable_net();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.net)
return _s;
}
inline const std::string& SolverParameter::_internal_net() const {
return net_.Get();
}
inline void SolverParameter::_internal_set_net(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_net() {
_has_bits_[0] |= 0x00000008u;
return net_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_net() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.net)
if (!_internal_has_net()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
auto* p = net_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SolverParameter::set_allocated_net(std::string* net) {
if (net != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
net_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), net,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.net)
}
// optional .caffe.NetParameter net_param = 25;
inline bool SolverParameter::_internal_has_net_param() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
PROTOBUF_ASSUME(!value || net_param_ != nullptr);
return value;
}
inline bool SolverParameter::has_net_param() const {
return _internal_has_net_param();
}
inline void SolverParameter::clear_net_param() {
if (net_param_ != nullptr) net_param_->Clear();
_has_bits_[0] &= ~0x00000200u;
}
inline const ::caffe::NetParameter& SolverParameter::_internal_net_param() const {
const ::caffe::NetParameter* p = net_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::NetParameter&>(
::caffe::_NetParameter_default_instance_);
}
inline const ::caffe::NetParameter& SolverParameter::net_param() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.net_param)
return _internal_net_param();
}
inline void SolverParameter::unsafe_arena_set_allocated_net_param(
::caffe::NetParameter* net_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(net_param_);
}
net_param_ = net_param;
if (net_param) {
_has_bits_[0] |= 0x00000200u;
} else {
_has_bits_[0] &= ~0x00000200u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.SolverParameter.net_param)
}
inline ::caffe::NetParameter* SolverParameter::release_net_param() {
_has_bits_[0] &= ~0x00000200u;
::caffe::NetParameter* temp = net_param_;
net_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::NetParameter* SolverParameter::unsafe_arena_release_net_param() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.net_param)
_has_bits_[0] &= ~0x00000200u;
::caffe::NetParameter* temp = net_param_;
net_param_ = nullptr;
return temp;
}
inline ::caffe::NetParameter* SolverParameter::_internal_mutable_net_param() {
_has_bits_[0] |= 0x00000200u;
if (net_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::NetParameter>(GetArenaForAllocation());
net_param_ = p;
}
return net_param_;
}
inline ::caffe::NetParameter* SolverParameter::mutable_net_param() {
::caffe::NetParameter* _msg = _internal_mutable_net_param();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.net_param)
return _msg;
}
inline void SolverParameter::set_allocated_net_param(::caffe::NetParameter* net_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete net_param_;
}
if (net_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::NetParameter>::GetOwningArena(net_param);
if (message_arena != submessage_arena) {
net_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, net_param, submessage_arena);
}
_has_bits_[0] |= 0x00000200u;
} else {
_has_bits_[0] &= ~0x00000200u;
}
net_param_ = net_param;
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.net_param)
}
// optional string train_net = 1;
inline bool SolverParameter::_internal_has_train_net() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SolverParameter::has_train_net() const {
return _internal_has_train_net();
}
inline void SolverParameter::clear_train_net() {
train_net_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SolverParameter::train_net() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.train_net)
return _internal_train_net();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_train_net(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
train_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SolverParameter.train_net)
}
inline std::string* SolverParameter::mutable_train_net() {
std::string* _s = _internal_mutable_train_net();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.train_net)
return _s;
}
inline const std::string& SolverParameter::_internal_train_net() const {
return train_net_.Get();
}
inline void SolverParameter::_internal_set_train_net(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
train_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_train_net() {
_has_bits_[0] |= 0x00000001u;
return train_net_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_train_net() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.train_net)
if (!_internal_has_train_net()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = train_net_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (train_net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
train_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SolverParameter::set_allocated_train_net(std::string* train_net) {
if (train_net != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
train_net_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), train_net,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (train_net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
train_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.train_net)
}
// repeated string test_net = 2;
inline int SolverParameter::_internal_test_net_size() const {
return test_net_.size();
}
inline int SolverParameter::test_net_size() const {
return _internal_test_net_size();
}
inline void SolverParameter::clear_test_net() {
test_net_.Clear();
}
inline std::string* SolverParameter::add_test_net() {
std::string* _s = _internal_add_test_net();
// @@protoc_insertion_point(field_add_mutable:caffe.SolverParameter.test_net)
return _s;
}
inline const std::string& SolverParameter::_internal_test_net(int index) const {
return test_net_.Get(index);
}
inline const std::string& SolverParameter::test_net(int index) const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.test_net)
return _internal_test_net(index);
}
inline std::string* SolverParameter::mutable_test_net(int index) {
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.test_net)
return test_net_.Mutable(index);
}
inline void SolverParameter::set_test_net(int index, const std::string& value) {
test_net_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.test_net)
}
inline void SolverParameter::set_test_net(int index, std::string&& value) {
test_net_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.SolverParameter.test_net)
}
inline void SolverParameter::set_test_net(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
test_net_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.SolverParameter.test_net)
}
inline void SolverParameter::set_test_net(int index, const char* value, size_t size) {
test_net_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.test_net)
}
inline std::string* SolverParameter::_internal_add_test_net() {
return test_net_.Add();
}
inline void SolverParameter::add_test_net(const std::string& value) {
test_net_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.SolverParameter.test_net)
}
inline void SolverParameter::add_test_net(std::string&& value) {
test_net_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.SolverParameter.test_net)
}
inline void SolverParameter::add_test_net(const char* value) {
GOOGLE_DCHECK(value != nullptr);
test_net_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.SolverParameter.test_net)
}
inline void SolverParameter::add_test_net(const char* value, size_t size) {
test_net_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.SolverParameter.test_net)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SolverParameter::test_net() const {
// @@protoc_insertion_point(field_list:caffe.SolverParameter.test_net)
return test_net_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SolverParameter::mutable_test_net() {
// @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_net)
return &test_net_;
}
// optional .caffe.NetParameter train_net_param = 21;
inline bool SolverParameter::_internal_has_train_net_param() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
PROTOBUF_ASSUME(!value || train_net_param_ != nullptr);
return value;
}
inline bool SolverParameter::has_train_net_param() const {
return _internal_has_train_net_param();
}
inline void SolverParameter::clear_train_net_param() {
if (train_net_param_ != nullptr) train_net_param_->Clear();
_has_bits_[0] &= ~0x00000100u;
}
inline const ::caffe::NetParameter& SolverParameter::_internal_train_net_param() const {
const ::caffe::NetParameter* p = train_net_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::NetParameter&>(
::caffe::_NetParameter_default_instance_);
}
inline const ::caffe::NetParameter& SolverParameter::train_net_param() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.train_net_param)
return _internal_train_net_param();
}
inline void SolverParameter::unsafe_arena_set_allocated_train_net_param(
::caffe::NetParameter* train_net_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(train_net_param_);
}
train_net_param_ = train_net_param;
if (train_net_param) {
_has_bits_[0] |= 0x00000100u;
} else {
_has_bits_[0] &= ~0x00000100u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.SolverParameter.train_net_param)
}
inline ::caffe::NetParameter* SolverParameter::release_train_net_param() {
_has_bits_[0] &= ~0x00000100u;
::caffe::NetParameter* temp = train_net_param_;
train_net_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::NetParameter* SolverParameter::unsafe_arena_release_train_net_param() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.train_net_param)
_has_bits_[0] &= ~0x00000100u;
::caffe::NetParameter* temp = train_net_param_;
train_net_param_ = nullptr;
return temp;
}
inline ::caffe::NetParameter* SolverParameter::_internal_mutable_train_net_param() {
_has_bits_[0] |= 0x00000100u;
if (train_net_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::NetParameter>(GetArenaForAllocation());
train_net_param_ = p;
}
return train_net_param_;
}
inline ::caffe::NetParameter* SolverParameter::mutable_train_net_param() {
::caffe::NetParameter* _msg = _internal_mutable_train_net_param();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.train_net_param)
return _msg;
}
inline void SolverParameter::set_allocated_train_net_param(::caffe::NetParameter* train_net_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete train_net_param_;
}
if (train_net_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::NetParameter>::GetOwningArena(train_net_param);
if (message_arena != submessage_arena) {
train_net_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, train_net_param, submessage_arena);
}
_has_bits_[0] |= 0x00000100u;
} else {
_has_bits_[0] &= ~0x00000100u;
}
train_net_param_ = train_net_param;
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.train_net_param)
}
// repeated .caffe.NetParameter test_net_param = 22;
inline int SolverParameter::_internal_test_net_param_size() const {
return test_net_param_.size();
}
inline int SolverParameter::test_net_param_size() const {
return _internal_test_net_param_size();
}
inline void SolverParameter::clear_test_net_param() {
test_net_param_.Clear();
}
inline ::caffe::NetParameter* SolverParameter::mutable_test_net_param(int index) {
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.test_net_param)
return test_net_param_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetParameter >*
SolverParameter::mutable_test_net_param() {
// @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_net_param)
return &test_net_param_;
}
inline const ::caffe::NetParameter& SolverParameter::_internal_test_net_param(int index) const {
return test_net_param_.Get(index);
}
inline const ::caffe::NetParameter& SolverParameter::test_net_param(int index) const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.test_net_param)
return _internal_test_net_param(index);
}
inline ::caffe::NetParameter* SolverParameter::_internal_add_test_net_param() {
return test_net_param_.Add();
}
inline ::caffe::NetParameter* SolverParameter::add_test_net_param() {
::caffe::NetParameter* _add = _internal_add_test_net_param();
// @@protoc_insertion_point(field_add:caffe.SolverParameter.test_net_param)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetParameter >&
SolverParameter::test_net_param() const {
// @@protoc_insertion_point(field_list:caffe.SolverParameter.test_net_param)
return test_net_param_;
}
// optional .caffe.NetState train_state = 26;
inline bool SolverParameter::_internal_has_train_state() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
PROTOBUF_ASSUME(!value || train_state_ != nullptr);
return value;
}
inline bool SolverParameter::has_train_state() const {
return _internal_has_train_state();
}
inline void SolverParameter::clear_train_state() {
if (train_state_ != nullptr) train_state_->Clear();
_has_bits_[0] &= ~0x00000400u;
}
inline const ::caffe::NetState& SolverParameter::_internal_train_state() const {
const ::caffe::NetState* p = train_state_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::NetState&>(
::caffe::_NetState_default_instance_);
}
inline const ::caffe::NetState& SolverParameter::train_state() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.train_state)
return _internal_train_state();
}
inline void SolverParameter::unsafe_arena_set_allocated_train_state(
::caffe::NetState* train_state) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(train_state_);
}
train_state_ = train_state;
if (train_state) {
_has_bits_[0] |= 0x00000400u;
} else {
_has_bits_[0] &= ~0x00000400u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.SolverParameter.train_state)
}
inline ::caffe::NetState* SolverParameter::release_train_state() {
_has_bits_[0] &= ~0x00000400u;
::caffe::NetState* temp = train_state_;
train_state_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::NetState* SolverParameter::unsafe_arena_release_train_state() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.train_state)
_has_bits_[0] &= ~0x00000400u;
::caffe::NetState* temp = train_state_;
train_state_ = nullptr;
return temp;
}
inline ::caffe::NetState* SolverParameter::_internal_mutable_train_state() {
_has_bits_[0] |= 0x00000400u;
if (train_state_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::NetState>(GetArenaForAllocation());
train_state_ = p;
}
return train_state_;
}
inline ::caffe::NetState* SolverParameter::mutable_train_state() {
::caffe::NetState* _msg = _internal_mutable_train_state();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.train_state)
return _msg;
}
inline void SolverParameter::set_allocated_train_state(::caffe::NetState* train_state) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete train_state_;
}
if (train_state) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::NetState>::GetOwningArena(train_state);
if (message_arena != submessage_arena) {
train_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, train_state, submessage_arena);
}
_has_bits_[0] |= 0x00000400u;
} else {
_has_bits_[0] &= ~0x00000400u;
}
train_state_ = train_state;
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.train_state)
}
// repeated .caffe.NetState test_state = 27;
inline int SolverParameter::_internal_test_state_size() const {
return test_state_.size();
}
inline int SolverParameter::test_state_size() const {
return _internal_test_state_size();
}
inline void SolverParameter::clear_test_state() {
test_state_.Clear();
}
inline ::caffe::NetState* SolverParameter::mutable_test_state(int index) {
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.test_state)
return test_state_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetState >*
SolverParameter::mutable_test_state() {
// @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_state)
return &test_state_;
}
inline const ::caffe::NetState& SolverParameter::_internal_test_state(int index) const {
return test_state_.Get(index);
}
inline const ::caffe::NetState& SolverParameter::test_state(int index) const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.test_state)
return _internal_test_state(index);
}
inline ::caffe::NetState* SolverParameter::_internal_add_test_state() {
return test_state_.Add();
}
inline ::caffe::NetState* SolverParameter::add_test_state() {
::caffe::NetState* _add = _internal_add_test_state();
// @@protoc_insertion_point(field_add:caffe.SolverParameter.test_state)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetState >&
SolverParameter::test_state() const {
// @@protoc_insertion_point(field_list:caffe.SolverParameter.test_state)
return test_state_;
}
// optional string eval_type = 41 [default = "classification"];
inline bool SolverParameter::_internal_has_eval_type() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool SolverParameter::has_eval_type() const {
return _internal_has_eval_type();
}
inline void SolverParameter::clear_eval_type() {
eval_type_.ClearToDefault(::caffe::SolverParameter::_i_give_permission_to_break_this_code_default_eval_type_, GetArenaForAllocation());
_has_bits_[0] &= ~0x00000040u;
}
inline const std::string& SolverParameter::eval_type() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.eval_type)
if (eval_type_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_eval_type_.get();
return _internal_eval_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_eval_type(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000040u;
eval_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SolverParameter.eval_type)
}
inline std::string* SolverParameter::mutable_eval_type() {
std::string* _s = _internal_mutable_eval_type();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.eval_type)
return _s;
}
inline const std::string& SolverParameter::_internal_eval_type() const {
return eval_type_.Get();
}
inline void SolverParameter::_internal_set_eval_type(const std::string& value) {
_has_bits_[0] |= 0x00000040u;
eval_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_eval_type() {
_has_bits_[0] |= 0x00000040u;
return eval_type_.Mutable(::caffe::SolverParameter::_i_give_permission_to_break_this_code_default_eval_type_, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_eval_type() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.eval_type)
if (!_internal_has_eval_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000040u;
auto* p = eval_type_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
return p;
}
inline void SolverParameter::set_allocated_eval_type(std::string* eval_type) {
if (eval_type != nullptr) {
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
eval_type_.SetAllocated(nullptr, eval_type,
GetArenaForAllocation());
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.eval_type)
}
// optional string ap_version = 42 [default = "Integral"];
inline bool SolverParameter::_internal_has_ap_version() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool SolverParameter::has_ap_version() const {
return _internal_has_ap_version();
}
inline void SolverParameter::clear_ap_version() {
ap_version_.ClearToDefault(::caffe::SolverParameter::_i_give_permission_to_break_this_code_default_ap_version_, GetArenaForAllocation());
_has_bits_[0] &= ~0x00000080u;
}
inline const std::string& SolverParameter::ap_version() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.ap_version)
if (ap_version_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_ap_version_.get();
return _internal_ap_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_ap_version(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000080u;
ap_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SolverParameter.ap_version)
}
inline std::string* SolverParameter::mutable_ap_version() {
std::string* _s = _internal_mutable_ap_version();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.ap_version)
return _s;
}
inline const std::string& SolverParameter::_internal_ap_version() const {
return ap_version_.Get();
}
inline void SolverParameter::_internal_set_ap_version(const std::string& value) {
_has_bits_[0] |= 0x00000080u;
ap_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_ap_version() {
_has_bits_[0] |= 0x00000080u;
return ap_version_.Mutable(::caffe::SolverParameter::_i_give_permission_to_break_this_code_default_ap_version_, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_ap_version() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.ap_version)
if (!_internal_has_ap_version()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000080u;
auto* p = ap_version_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
return p;
}
inline void SolverParameter::set_allocated_ap_version(std::string* ap_version) {
if (ap_version != nullptr) {
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
ap_version_.SetAllocated(nullptr, ap_version,
GetArenaForAllocation());
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.ap_version)
}
// optional bool show_per_class_result = 44 [default = false];
inline bool SolverParameter::_internal_has_show_per_class_result() const {
bool value = (_has_bits_[0] & 0x00400000u) != 0;
return value;
}
inline bool SolverParameter::has_show_per_class_result() const {
return _internal_has_show_per_class_result();
}
inline void SolverParameter::clear_show_per_class_result() {
show_per_class_result_ = false;
_has_bits_[0] &= ~0x00400000u;
}
inline bool SolverParameter::_internal_show_per_class_result() const {
return show_per_class_result_;
}
inline bool SolverParameter::show_per_class_result() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.show_per_class_result)
return _internal_show_per_class_result();
}
inline void SolverParameter::_internal_set_show_per_class_result(bool value) {
_has_bits_[0] |= 0x00400000u;
show_per_class_result_ = value;
}
inline void SolverParameter::set_show_per_class_result(bool value) {
_internal_set_show_per_class_result(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.show_per_class_result)
}
// repeated int32 test_iter = 3;
inline int SolverParameter::_internal_test_iter_size() const {
return test_iter_.size();
}
inline int SolverParameter::test_iter_size() const {
return _internal_test_iter_size();
}
inline void SolverParameter::clear_test_iter() {
test_iter_.Clear();
}
inline int32_t SolverParameter::_internal_test_iter(int index) const {
return test_iter_.Get(index);
}
inline int32_t SolverParameter::test_iter(int index) const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.test_iter)
return _internal_test_iter(index);
}
inline void SolverParameter::set_test_iter(int index, int32_t value) {
test_iter_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.test_iter)
}
inline void SolverParameter::_internal_add_test_iter(int32_t value) {
test_iter_.Add(value);
}
inline void SolverParameter::add_test_iter(int32_t value) {
_internal_add_test_iter(value);
// @@protoc_insertion_point(field_add:caffe.SolverParameter.test_iter)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SolverParameter::_internal_test_iter() const {
return test_iter_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SolverParameter::test_iter() const {
// @@protoc_insertion_point(field_list:caffe.SolverParameter.test_iter)
return _internal_test_iter();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SolverParameter::_internal_mutable_test_iter() {
return &test_iter_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SolverParameter::mutable_test_iter() {
// @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_iter)
return _internal_mutable_test_iter();
}
// optional int32 test_interval = 4 [default = 0];
inline bool SolverParameter::_internal_has_test_interval() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool SolverParameter::has_test_interval() const {
return _internal_has_test_interval();
}
inline void SolverParameter::clear_test_interval() {
test_interval_ = 0;
_has_bits_[0] &= ~0x00000800u;
}
inline int32_t SolverParameter::_internal_test_interval() const {
return test_interval_;
}
inline int32_t SolverParameter::test_interval() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.test_interval)
return _internal_test_interval();
}
inline void SolverParameter::_internal_set_test_interval(int32_t value) {
_has_bits_[0] |= 0x00000800u;
test_interval_ = value;
}
inline void SolverParameter::set_test_interval(int32_t value) {
_internal_set_test_interval(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.test_interval)
}
// optional bool test_compute_loss = 19 [default = false];
inline bool SolverParameter::_internal_has_test_compute_loss() const {
bool value = (_has_bits_[0] & 0x00800000u) != 0;
return value;
}
inline bool SolverParameter::has_test_compute_loss() const {
return _internal_has_test_compute_loss();
}
inline void SolverParameter::clear_test_compute_loss() {
test_compute_loss_ = false;
_has_bits_[0] &= ~0x00800000u;
}
inline bool SolverParameter::_internal_test_compute_loss() const {
return test_compute_loss_;
}
inline bool SolverParameter::test_compute_loss() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.test_compute_loss)
return _internal_test_compute_loss();
}
inline void SolverParameter::_internal_set_test_compute_loss(bool value) {
_has_bits_[0] |= 0x00800000u;
test_compute_loss_ = value;
}
inline void SolverParameter::set_test_compute_loss(bool value) {
_internal_set_test_compute_loss(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.test_compute_loss)
}
// optional bool test_initialization = 32 [default = true];
inline bool SolverParameter::_internal_has_test_initialization() const {
bool value = (_has_bits_[1] & 0x00000002u) != 0;
return value;
}
inline bool SolverParameter::has_test_initialization() const {
return _internal_has_test_initialization();
}
inline void SolverParameter::clear_test_initialization() {
test_initialization_ = true;
_has_bits_[1] &= ~0x00000002u;
}
inline bool SolverParameter::_internal_test_initialization() const {
return test_initialization_;
}
inline bool SolverParameter::test_initialization() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.test_initialization)
return _internal_test_initialization();
}
inline void SolverParameter::_internal_set_test_initialization(bool value) {
_has_bits_[1] |= 0x00000002u;
test_initialization_ = value;
}
inline void SolverParameter::set_test_initialization(bool value) {
_internal_set_test_initialization(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.test_initialization)
}
// optional float base_lr = 5;
inline bool SolverParameter::_internal_has_base_lr() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool SolverParameter::has_base_lr() const {
return _internal_has_base_lr();
}
inline void SolverParameter::clear_base_lr() {
base_lr_ = 0;
_has_bits_[0] &= ~0x00001000u;
}
inline float SolverParameter::_internal_base_lr() const {
return base_lr_;
}
inline float SolverParameter::base_lr() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.base_lr)
return _internal_base_lr();
}
inline void SolverParameter::_internal_set_base_lr(float value) {
_has_bits_[0] |= 0x00001000u;
base_lr_ = value;
}
inline void SolverParameter::set_base_lr(float value) {
_internal_set_base_lr(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.base_lr)
}
// optional int32 display = 6;
inline bool SolverParameter::_internal_has_display() const {
bool value = (_has_bits_[0] & 0x00002000u) != 0;
return value;
}
inline bool SolverParameter::has_display() const {
return _internal_has_display();
}
inline void SolverParameter::clear_display() {
display_ = 0;
_has_bits_[0] &= ~0x00002000u;
}
inline int32_t SolverParameter::_internal_display() const {
return display_;
}
inline int32_t SolverParameter::display() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.display)
return _internal_display();
}
inline void SolverParameter::_internal_set_display(int32_t value) {
_has_bits_[0] |= 0x00002000u;
display_ = value;
}
inline void SolverParameter::set_display(int32_t value) {
_internal_set_display(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.display)
}
// optional int32 average_loss = 33 [default = 1];
inline bool SolverParameter::_internal_has_average_loss() const {
bool value = (_has_bits_[0] & 0x80000000u) != 0;
return value;
}
inline bool SolverParameter::has_average_loss() const {
return _internal_has_average_loss();
}
inline void SolverParameter::clear_average_loss() {
average_loss_ = 1;
_has_bits_[0] &= ~0x80000000u;
}
inline int32_t SolverParameter::_internal_average_loss() const {
return average_loss_;
}
inline int32_t SolverParameter::average_loss() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.average_loss)
return _internal_average_loss();
}
inline void SolverParameter::_internal_set_average_loss(int32_t value) {
_has_bits_[0] |= 0x80000000u;
average_loss_ = value;
}
inline void SolverParameter::set_average_loss(int32_t value) {
_internal_set_average_loss(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.average_loss)
}
// optional int32 max_iter = 7;
inline bool SolverParameter::_internal_has_max_iter() const {
bool value = (_has_bits_[0] & 0x00004000u) != 0;
return value;
}
inline bool SolverParameter::has_max_iter() const {
return _internal_has_max_iter();
}
inline void SolverParameter::clear_max_iter() {
max_iter_ = 0;
_has_bits_[0] &= ~0x00004000u;
}
inline int32_t SolverParameter::_internal_max_iter() const {
return max_iter_;
}
inline int32_t SolverParameter::max_iter() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.max_iter)
return _internal_max_iter();
}
inline void SolverParameter::_internal_set_max_iter(int32_t value) {
_has_bits_[0] |= 0x00004000u;
max_iter_ = value;
}
inline void SolverParameter::set_max_iter(int32_t value) {
_internal_set_max_iter(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.max_iter)
}
// optional int32 iter_size = 36 [default = 1];
inline bool SolverParameter::_internal_has_iter_size() const {
bool value = (_has_bits_[1] & 0x00000010u) != 0;
return value;
}
inline bool SolverParameter::has_iter_size() const {
return _internal_has_iter_size();
}
inline void SolverParameter::clear_iter_size() {
iter_size_ = 1;
_has_bits_[1] &= ~0x00000010u;
}
inline int32_t SolverParameter::_internal_iter_size() const {
return iter_size_;
}
inline int32_t SolverParameter::iter_size() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.iter_size)
return _internal_iter_size();
}
inline void SolverParameter::_internal_set_iter_size(int32_t value) {
_has_bits_[1] |= 0x00000010u;
iter_size_ = value;
}
inline void SolverParameter::set_iter_size(int32_t value) {
_internal_set_iter_size(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.iter_size)
}
// optional string lr_policy = 8;
inline bool SolverParameter::_internal_has_lr_policy() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool SolverParameter::has_lr_policy() const {
return _internal_has_lr_policy();
}
inline void SolverParameter::clear_lr_policy() {
lr_policy_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SolverParameter::lr_policy() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.lr_policy)
return _internal_lr_policy();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_lr_policy(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
lr_policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SolverParameter.lr_policy)
}
inline std::string* SolverParameter::mutable_lr_policy() {
std::string* _s = _internal_mutable_lr_policy();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.lr_policy)
return _s;
}
inline const std::string& SolverParameter::_internal_lr_policy() const {
return lr_policy_.Get();
}
inline void SolverParameter::_internal_set_lr_policy(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
lr_policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_lr_policy() {
_has_bits_[0] |= 0x00000002u;
return lr_policy_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_lr_policy() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.lr_policy)
if (!_internal_has_lr_policy()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = lr_policy_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (lr_policy_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
lr_policy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SolverParameter::set_allocated_lr_policy(std::string* lr_policy) {
if (lr_policy != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
lr_policy_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), lr_policy,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (lr_policy_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
lr_policy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.lr_policy)
}
// optional float gamma = 9;
inline bool SolverParameter::_internal_has_gamma() const {
bool value = (_has_bits_[0] & 0x00008000u) != 0;
return value;
}
inline bool SolverParameter::has_gamma() const {
return _internal_has_gamma();
}
inline void SolverParameter::clear_gamma() {
gamma_ = 0;
_has_bits_[0] &= ~0x00008000u;
}
inline float SolverParameter::_internal_gamma() const {
return gamma_;
}
inline float SolverParameter::gamma() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.gamma)
return _internal_gamma();
}
inline void SolverParameter::_internal_set_gamma(float value) {
_has_bits_[0] |= 0x00008000u;
gamma_ = value;
}
inline void SolverParameter::set_gamma(float value) {
_internal_set_gamma(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.gamma)
}
// optional float power = 10;
inline bool SolverParameter::_internal_has_power() const {
bool value = (_has_bits_[0] & 0x00010000u) != 0;
return value;
}
inline bool SolverParameter::has_power() const {
return _internal_has_power();
}
inline void SolverParameter::clear_power() {
power_ = 0;
_has_bits_[0] &= ~0x00010000u;
}
inline float SolverParameter::_internal_power() const {
return power_;
}
inline float SolverParameter::power() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.power)
return _internal_power();
}
inline void SolverParameter::_internal_set_power(float value) {
_has_bits_[0] |= 0x00010000u;
power_ = value;
}
inline void SolverParameter::set_power(float value) {
_internal_set_power(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.power)
}
// optional float momentum = 11;
inline bool SolverParameter::_internal_has_momentum() const {
bool value = (_has_bits_[0] & 0x00020000u) != 0;
return value;
}
inline bool SolverParameter::has_momentum() const {
return _internal_has_momentum();
}
inline void SolverParameter::clear_momentum() {
momentum_ = 0;
_has_bits_[0] &= ~0x00020000u;
}
inline float SolverParameter::_internal_momentum() const {
return momentum_;
}
inline float SolverParameter::momentum() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.momentum)
return _internal_momentum();
}
inline void SolverParameter::_internal_set_momentum(float value) {
_has_bits_[0] |= 0x00020000u;
momentum_ = value;
}
inline void SolverParameter::set_momentum(float value) {
_internal_set_momentum(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.momentum)
}
// optional float weight_decay = 12;
inline bool SolverParameter::_internal_has_weight_decay() const {
bool value = (_has_bits_[0] & 0x00040000u) != 0;
return value;
}
inline bool SolverParameter::has_weight_decay() const {
return _internal_has_weight_decay();
}
inline void SolverParameter::clear_weight_decay() {
weight_decay_ = 0;
_has_bits_[0] &= ~0x00040000u;
}
inline float SolverParameter::_internal_weight_decay() const {
return weight_decay_;
}
inline float SolverParameter::weight_decay() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.weight_decay)
return _internal_weight_decay();
}
inline void SolverParameter::_internal_set_weight_decay(float value) {
_has_bits_[0] |= 0x00040000u;
weight_decay_ = value;
}
inline void SolverParameter::set_weight_decay(float value) {
_internal_set_weight_decay(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.weight_decay)
}
// optional string regularization_type = 29 [default = "L2"];
inline bool SolverParameter::_internal_has_regularization_type() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool SolverParameter::has_regularization_type() const {
return _internal_has_regularization_type();
}
inline void SolverParameter::clear_regularization_type() {
regularization_type_.ClearToDefault(::caffe::SolverParameter::_i_give_permission_to_break_this_code_default_regularization_type_, GetArenaForAllocation());
_has_bits_[0] &= ~0x00000010u;
}
inline const std::string& SolverParameter::regularization_type() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.regularization_type)
if (regularization_type_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_regularization_type_.get();
return _internal_regularization_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_regularization_type(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000010u;
regularization_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SolverParameter.regularization_type)
}
inline std::string* SolverParameter::mutable_regularization_type() {
std::string* _s = _internal_mutable_regularization_type();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.regularization_type)
return _s;
}
inline const std::string& SolverParameter::_internal_regularization_type() const {
return regularization_type_.Get();
}
inline void SolverParameter::_internal_set_regularization_type(const std::string& value) {
_has_bits_[0] |= 0x00000010u;
regularization_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_regularization_type() {
_has_bits_[0] |= 0x00000010u;
return regularization_type_.Mutable(::caffe::SolverParameter::_i_give_permission_to_break_this_code_default_regularization_type_, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_regularization_type() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.regularization_type)
if (!_internal_has_regularization_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000010u;
auto* p = regularization_type_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
return p;
}
inline void SolverParameter::set_allocated_regularization_type(std::string* regularization_type) {
if (regularization_type != nullptr) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
regularization_type_.SetAllocated(nullptr, regularization_type,
GetArenaForAllocation());
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.regularization_type)
}
// optional int32 stepsize = 13;
inline bool SolverParameter::_internal_has_stepsize() const {
bool value = (_has_bits_[0] & 0x00080000u) != 0;
return value;
}
inline bool SolverParameter::has_stepsize() const {
return _internal_has_stepsize();
}
inline void SolverParameter::clear_stepsize() {
stepsize_ = 0;
_has_bits_[0] &= ~0x00080000u;
}
inline int32_t SolverParameter::_internal_stepsize() const {
return stepsize_;
}
inline int32_t SolverParameter::stepsize() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.stepsize)
return _internal_stepsize();
}
inline void SolverParameter::_internal_set_stepsize(int32_t value) {
_has_bits_[0] |= 0x00080000u;
stepsize_ = value;
}
inline void SolverParameter::set_stepsize(int32_t value) {
_internal_set_stepsize(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.stepsize)
}
// repeated int32 stepvalue = 34;
inline int SolverParameter::_internal_stepvalue_size() const {
return stepvalue_.size();
}
inline int SolverParameter::stepvalue_size() const {
return _internal_stepvalue_size();
}
inline void SolverParameter::clear_stepvalue() {
stepvalue_.Clear();
}
inline int32_t SolverParameter::_internal_stepvalue(int index) const {
return stepvalue_.Get(index);
}
inline int32_t SolverParameter::stepvalue(int index) const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.stepvalue)
return _internal_stepvalue(index);
}
inline void SolverParameter::set_stepvalue(int index, int32_t value) {
stepvalue_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.stepvalue)
}
inline void SolverParameter::_internal_add_stepvalue(int32_t value) {
stepvalue_.Add(value);
}
inline void SolverParameter::add_stepvalue(int32_t value) {
_internal_add_stepvalue(value);
// @@protoc_insertion_point(field_add:caffe.SolverParameter.stepvalue)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SolverParameter::_internal_stepvalue() const {
return stepvalue_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SolverParameter::stepvalue() const {
// @@protoc_insertion_point(field_list:caffe.SolverParameter.stepvalue)
return _internal_stepvalue();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SolverParameter::_internal_mutable_stepvalue() {
return &stepvalue_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SolverParameter::mutable_stepvalue() {
// @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.stepvalue)
return _internal_mutable_stepvalue();
}
// optional float clip_gradients = 35 [default = -1];
inline bool SolverParameter::_internal_has_clip_gradients() const {
bool value = (_has_bits_[1] & 0x00000001u) != 0;
return value;
}
inline bool SolverParameter::has_clip_gradients() const {
return _internal_has_clip_gradients();
}
inline void SolverParameter::clear_clip_gradients() {
clip_gradients_ = -1;
_has_bits_[1] &= ~0x00000001u;
}
inline float SolverParameter::_internal_clip_gradients() const {
return clip_gradients_;
}
inline float SolverParameter::clip_gradients() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.clip_gradients)
return _internal_clip_gradients();
}
inline void SolverParameter::_internal_set_clip_gradients(float value) {
_has_bits_[1] |= 0x00000001u;
clip_gradients_ = value;
}
inline void SolverParameter::set_clip_gradients(float value) {
_internal_set_clip_gradients(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.clip_gradients)
}
// optional int32 snapshot = 14 [default = 0];
inline bool SolverParameter::_internal_has_snapshot() const {
bool value = (_has_bits_[0] & 0x00100000u) != 0;
return value;
}
inline bool SolverParameter::has_snapshot() const {
return _internal_has_snapshot();
}
inline void SolverParameter::clear_snapshot() {
snapshot_ = 0;
_has_bits_[0] &= ~0x00100000u;
}
inline int32_t SolverParameter::_internal_snapshot() const {
return snapshot_;
}
inline int32_t SolverParameter::snapshot() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot)
return _internal_snapshot();
}
inline void SolverParameter::_internal_set_snapshot(int32_t value) {
_has_bits_[0] |= 0x00100000u;
snapshot_ = value;
}
inline void SolverParameter::set_snapshot(int32_t value) {
_internal_set_snapshot(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot)
}
// optional string snapshot_prefix = 15;
inline bool SolverParameter::_internal_has_snapshot_prefix() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool SolverParameter::has_snapshot_prefix() const {
return _internal_has_snapshot_prefix();
}
inline void SolverParameter::clear_snapshot_prefix() {
snapshot_prefix_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SolverParameter::snapshot_prefix() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_prefix)
return _internal_snapshot_prefix();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_snapshot_prefix(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
snapshot_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_prefix)
}
inline std::string* SolverParameter::mutable_snapshot_prefix() {
std::string* _s = _internal_mutable_snapshot_prefix();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.snapshot_prefix)
return _s;
}
inline const std::string& SolverParameter::_internal_snapshot_prefix() const {
return snapshot_prefix_.Get();
}
inline void SolverParameter::_internal_set_snapshot_prefix(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
snapshot_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_snapshot_prefix() {
_has_bits_[0] |= 0x00000004u;
return snapshot_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_snapshot_prefix() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.snapshot_prefix)
if (!_internal_has_snapshot_prefix()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = snapshot_prefix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (snapshot_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
snapshot_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SolverParameter::set_allocated_snapshot_prefix(std::string* snapshot_prefix) {
if (snapshot_prefix != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
snapshot_prefix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), snapshot_prefix,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (snapshot_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
snapshot_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.snapshot_prefix)
}
// optional bool snapshot_diff = 16 [default = false];
inline bool SolverParameter::_internal_has_snapshot_diff() const {
bool value = (_has_bits_[0] & 0x01000000u) != 0;
return value;
}
inline bool SolverParameter::has_snapshot_diff() const {
return _internal_has_snapshot_diff();
}
inline void SolverParameter::clear_snapshot_diff() {
snapshot_diff_ = false;
_has_bits_[0] &= ~0x01000000u;
}
inline bool SolverParameter::_internal_snapshot_diff() const {
return snapshot_diff_;
}
inline bool SolverParameter::snapshot_diff() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_diff)
return _internal_snapshot_diff();
}
inline void SolverParameter::_internal_set_snapshot_diff(bool value) {
_has_bits_[0] |= 0x01000000u;
snapshot_diff_ = value;
}
inline void SolverParameter::set_snapshot_diff(bool value) {
_internal_set_snapshot_diff(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_diff)
}
// optional .caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
inline bool SolverParameter::_internal_has_snapshot_format() const {
bool value = (_has_bits_[1] & 0x00000020u) != 0;
return value;
}
inline bool SolverParameter::has_snapshot_format() const {
return _internal_has_snapshot_format();
}
inline void SolverParameter::clear_snapshot_format() {
snapshot_format_ = 1;
_has_bits_[1] &= ~0x00000020u;
}
inline ::caffe::SolverParameter_SnapshotFormat SolverParameter::_internal_snapshot_format() const {
return static_cast< ::caffe::SolverParameter_SnapshotFormat >(snapshot_format_);
}
inline ::caffe::SolverParameter_SnapshotFormat SolverParameter::snapshot_format() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_format)
return _internal_snapshot_format();
}
inline void SolverParameter::_internal_set_snapshot_format(::caffe::SolverParameter_SnapshotFormat value) {
assert(::caffe::SolverParameter_SnapshotFormat_IsValid(value));
_has_bits_[1] |= 0x00000020u;
snapshot_format_ = value;
}
inline void SolverParameter::set_snapshot_format(::caffe::SolverParameter_SnapshotFormat value) {
_internal_set_snapshot_format(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_format)
}
// optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
inline bool SolverParameter::_internal_has_solver_mode() const {
bool value = (_has_bits_[0] & 0x20000000u) != 0;
return value;
}
inline bool SolverParameter::has_solver_mode() const {
return _internal_has_solver_mode();
}
inline void SolverParameter::clear_solver_mode() {
solver_mode_ = 1;
_has_bits_[0] &= ~0x20000000u;
}
inline ::caffe::SolverParameter_SolverMode SolverParameter::_internal_solver_mode() const {
return static_cast< ::caffe::SolverParameter_SolverMode >(solver_mode_);
}
inline ::caffe::SolverParameter_SolverMode SolverParameter::solver_mode() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.solver_mode)
return _internal_solver_mode();
}
inline void SolverParameter::_internal_set_solver_mode(::caffe::SolverParameter_SolverMode value) {
assert(::caffe::SolverParameter_SolverMode_IsValid(value));
_has_bits_[0] |= 0x20000000u;
solver_mode_ = value;
}
inline void SolverParameter::set_solver_mode(::caffe::SolverParameter_SolverMode value) {
_internal_set_solver_mode(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.solver_mode)
}
// optional int32 device_id = 18 [default = 0];
inline bool SolverParameter::_internal_has_device_id() const {
bool value = (_has_bits_[0] & 0x00200000u) != 0;
return value;
}
inline bool SolverParameter::has_device_id() const {
return _internal_has_device_id();
}
inline void SolverParameter::clear_device_id() {
device_id_ = 0;
_has_bits_[0] &= ~0x00200000u;
}
inline int32_t SolverParameter::_internal_device_id() const {
return device_id_;
}
inline int32_t SolverParameter::device_id() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.device_id)
return _internal_device_id();
}
inline void SolverParameter::_internal_set_device_id(int32_t value) {
_has_bits_[0] |= 0x00200000u;
device_id_ = value;
}
inline void SolverParameter::set_device_id(int32_t value) {
_internal_set_device_id(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.device_id)
}
// optional int64 random_seed = 20 [default = -1];
inline bool SolverParameter::_internal_has_random_seed() const {
bool value = (_has_bits_[0] & 0x10000000u) != 0;
return value;
}
inline bool SolverParameter::has_random_seed() const {
return _internal_has_random_seed();
}
inline void SolverParameter::clear_random_seed() {
random_seed_ = int64_t{-1};
_has_bits_[0] &= ~0x10000000u;
}
inline int64_t SolverParameter::_internal_random_seed() const {
return random_seed_;
}
inline int64_t SolverParameter::random_seed() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.random_seed)
return _internal_random_seed();
}
inline void SolverParameter::_internal_set_random_seed(int64_t value) {
_has_bits_[0] |= 0x10000000u;
random_seed_ = value;
}
inline void SolverParameter::set_random_seed(int64_t value) {
_internal_set_random_seed(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.random_seed)
}
// optional string type = 40 [default = "SGD"];
inline bool SolverParameter::_internal_has_type() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool SolverParameter::has_type() const {
return _internal_has_type();
}
inline void SolverParameter::clear_type() {
type_.ClearToDefault(::caffe::SolverParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation());
_has_bits_[0] &= ~0x00000020u;
}
inline const std::string& SolverParameter::type() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.type)
if (type_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_type_.get();
return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_type(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000020u;
type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SolverParameter.type)
}
inline std::string* SolverParameter::mutable_type() {
std::string* _s = _internal_mutable_type();
// @@protoc_insertion_point(field_mutable:caffe.SolverParameter.type)
return _s;
}
inline const std::string& SolverParameter::_internal_type() const {
return type_.Get();
}
inline void SolverParameter::_internal_set_type(const std::string& value) {
_has_bits_[0] |= 0x00000020u;
type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_type() {
_has_bits_[0] |= 0x00000020u;
return type_.Mutable(::caffe::SolverParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_type() {
// @@protoc_insertion_point(field_release:caffe.SolverParameter.type)
if (!_internal_has_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000020u;
auto* p = type_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
return p;
}
inline void SolverParameter::set_allocated_type(std::string* type) {
if (type != nullptr) {
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
type_.SetAllocated(nullptr, type,
GetArenaForAllocation());
// @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.type)
}
// optional float delta = 31 [default = 1e-08];
inline bool SolverParameter::_internal_has_delta() const {
bool value = (_has_bits_[0] & 0x40000000u) != 0;
return value;
}
inline bool SolverParameter::has_delta() const {
return _internal_has_delta();
}
inline void SolverParameter::clear_delta() {
delta_ = 1e-08f;
_has_bits_[0] &= ~0x40000000u;
}
inline float SolverParameter::_internal_delta() const {
return delta_;
}
inline float SolverParameter::delta() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.delta)
return _internal_delta();
}
inline void SolverParameter::_internal_set_delta(float value) {
_has_bits_[0] |= 0x40000000u;
delta_ = value;
}
inline void SolverParameter::set_delta(float value) {
_internal_set_delta(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.delta)
}
// optional float momentum2 = 39 [default = 0.999];
inline bool SolverParameter::_internal_has_momentum2() const {
bool value = (_has_bits_[0] & 0x08000000u) != 0;
return value;
}
inline bool SolverParameter::has_momentum2() const {
return _internal_has_momentum2();
}
inline void SolverParameter::clear_momentum2() {
momentum2_ = 0.999f;
_has_bits_[0] &= ~0x08000000u;
}
inline float SolverParameter::_internal_momentum2() const {
return momentum2_;
}
inline float SolverParameter::momentum2() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.momentum2)
return _internal_momentum2();
}
inline void SolverParameter::_internal_set_momentum2(float value) {
_has_bits_[0] |= 0x08000000u;
momentum2_ = value;
}
inline void SolverParameter::set_momentum2(float value) {
_internal_set_momentum2(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.momentum2)
}
// optional float rms_decay = 38 [default = 0.99];
inline bool SolverParameter::_internal_has_rms_decay() const {
bool value = (_has_bits_[1] & 0x00000040u) != 0;
return value;
}
inline bool SolverParameter::has_rms_decay() const {
return _internal_has_rms_decay();
}
inline void SolverParameter::clear_rms_decay() {
rms_decay_ = 0.99f;
_has_bits_[1] &= ~0x00000040u;
}
inline float SolverParameter::_internal_rms_decay() const {
return rms_decay_;
}
inline float SolverParameter::rms_decay() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.rms_decay)
return _internal_rms_decay();
}
inline void SolverParameter::_internal_set_rms_decay(float value) {
_has_bits_[1] |= 0x00000040u;
rms_decay_ = value;
}
inline void SolverParameter::set_rms_decay(float value) {
_internal_set_rms_decay(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.rms_decay)
}
// optional bool debug_info = 23 [default = false];
inline bool SolverParameter::_internal_has_debug_info() const {
bool value = (_has_bits_[0] & 0x02000000u) != 0;
return value;
}
inline bool SolverParameter::has_debug_info() const {
return _internal_has_debug_info();
}
inline void SolverParameter::clear_debug_info() {
debug_info_ = false;
_has_bits_[0] &= ~0x02000000u;
}
inline bool SolverParameter::_internal_debug_info() const {
return debug_info_;
}
inline bool SolverParameter::debug_info() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.debug_info)
return _internal_debug_info();
}
inline void SolverParameter::_internal_set_debug_info(bool value) {
_has_bits_[0] |= 0x02000000u;
debug_info_ = value;
}
inline void SolverParameter::set_debug_info(bool value) {
_internal_set_debug_info(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.debug_info)
}
// optional bool snapshot_after_train = 28 [default = true];
inline bool SolverParameter::_internal_has_snapshot_after_train() const {
bool value = (_has_bits_[1] & 0x00000004u) != 0;
return value;
}
inline bool SolverParameter::has_snapshot_after_train() const {
return _internal_has_snapshot_after_train();
}
inline void SolverParameter::clear_snapshot_after_train() {
snapshot_after_train_ = true;
_has_bits_[1] &= ~0x00000004u;
}
inline bool SolverParameter::_internal_snapshot_after_train() const {
return snapshot_after_train_;
}
inline bool SolverParameter::snapshot_after_train() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_after_train)
return _internal_snapshot_after_train();
}
inline void SolverParameter::_internal_set_snapshot_after_train(bool value) {
_has_bits_[1] |= 0x00000004u;
snapshot_after_train_ = value;
}
inline void SolverParameter::set_snapshot_after_train(bool value) {
_internal_set_snapshot_after_train(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_after_train)
}
// optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
inline bool SolverParameter::_internal_has_solver_type() const {
bool value = (_has_bits_[0] & 0x04000000u) != 0;
return value;
}
inline bool SolverParameter::has_solver_type() const {
return _internal_has_solver_type();
}
inline void SolverParameter::clear_solver_type() {
solver_type_ = 0;
_has_bits_[0] &= ~0x04000000u;
}
inline ::caffe::SolverParameter_SolverType SolverParameter::_internal_solver_type() const {
return static_cast< ::caffe::SolverParameter_SolverType >(solver_type_);
}
inline ::caffe::SolverParameter_SolverType SolverParameter::solver_type() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.solver_type)
return _internal_solver_type();
}
inline void SolverParameter::_internal_set_solver_type(::caffe::SolverParameter_SolverType value) {
assert(::caffe::SolverParameter_SolverType_IsValid(value));
_has_bits_[0] |= 0x04000000u;
solver_type_ = value;
}
inline void SolverParameter::set_solver_type(::caffe::SolverParameter_SolverType value) {
_internal_set_solver_type(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.solver_type)
}
// optional bool layer_wise_reduce = 45 [default = true];
inline bool SolverParameter::_internal_has_layer_wise_reduce() const {
bool value = (_has_bits_[1] & 0x00000008u) != 0;
return value;
}
inline bool SolverParameter::has_layer_wise_reduce() const {
return _internal_has_layer_wise_reduce();
}
inline void SolverParameter::clear_layer_wise_reduce() {
layer_wise_reduce_ = true;
_has_bits_[1] &= ~0x00000008u;
}
inline bool SolverParameter::_internal_layer_wise_reduce() const {
return layer_wise_reduce_;
}
inline bool SolverParameter::layer_wise_reduce() const {
// @@protoc_insertion_point(field_get:caffe.SolverParameter.layer_wise_reduce)
return _internal_layer_wise_reduce();
}
inline void SolverParameter::_internal_set_layer_wise_reduce(bool value) {
_has_bits_[1] |= 0x00000008u;
layer_wise_reduce_ = value;
}
inline void SolverParameter::set_layer_wise_reduce(bool value) {
_internal_set_layer_wise_reduce(value);
// @@protoc_insertion_point(field_set:caffe.SolverParameter.layer_wise_reduce)
}
// -------------------------------------------------------------------
// SolverState
// optional int32 iter = 1;
inline bool SolverState::_internal_has_iter() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool SolverState::has_iter() const {
return _internal_has_iter();
}
inline void SolverState::clear_iter() {
iter_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t SolverState::_internal_iter() const {
return iter_;
}
inline int32_t SolverState::iter() const {
// @@protoc_insertion_point(field_get:caffe.SolverState.iter)
return _internal_iter();
}
inline void SolverState::_internal_set_iter(int32_t value) {
_has_bits_[0] |= 0x00000002u;
iter_ = value;
}
inline void SolverState::set_iter(int32_t value) {
_internal_set_iter(value);
// @@protoc_insertion_point(field_set:caffe.SolverState.iter)
}
// optional string learned_net = 2;
inline bool SolverState::_internal_has_learned_net() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SolverState::has_learned_net() const {
return _internal_has_learned_net();
}
inline void SolverState::clear_learned_net() {
learned_net_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SolverState::learned_net() const {
// @@protoc_insertion_point(field_get:caffe.SolverState.learned_net)
return _internal_learned_net();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverState::set_learned_net(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
learned_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SolverState.learned_net)
}
inline std::string* SolverState::mutable_learned_net() {
std::string* _s = _internal_mutable_learned_net();
// @@protoc_insertion_point(field_mutable:caffe.SolverState.learned_net)
return _s;
}
inline const std::string& SolverState::_internal_learned_net() const {
return learned_net_.Get();
}
inline void SolverState::_internal_set_learned_net(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
learned_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SolverState::_internal_mutable_learned_net() {
_has_bits_[0] |= 0x00000001u;
return learned_net_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SolverState::release_learned_net() {
// @@protoc_insertion_point(field_release:caffe.SolverState.learned_net)
if (!_internal_has_learned_net()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = learned_net_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (learned_net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
learned_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SolverState::set_allocated_learned_net(std::string* learned_net) {
if (learned_net != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
learned_net_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), learned_net,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (learned_net_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
learned_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SolverState.learned_net)
}
// repeated .caffe.BlobProto history = 3;
inline int SolverState::_internal_history_size() const {
return history_.size();
}
inline int SolverState::history_size() const {
return _internal_history_size();
}
inline void SolverState::clear_history() {
history_.Clear();
}
inline ::caffe::BlobProto* SolverState::mutable_history(int index) {
// @@protoc_insertion_point(field_mutable:caffe.SolverState.history)
return history_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
SolverState::mutable_history() {
// @@protoc_insertion_point(field_mutable_list:caffe.SolverState.history)
return &history_;
}
inline const ::caffe::BlobProto& SolverState::_internal_history(int index) const {
return history_.Get(index);
}
inline const ::caffe::BlobProto& SolverState::history(int index) const {
// @@protoc_insertion_point(field_get:caffe.SolverState.history)
return _internal_history(index);
}
inline ::caffe::BlobProto* SolverState::_internal_add_history() {
return history_.Add();
}
inline ::caffe::BlobProto* SolverState::add_history() {
::caffe::BlobProto* _add = _internal_add_history();
// @@protoc_insertion_point(field_add:caffe.SolverState.history)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
SolverState::history() const {
// @@protoc_insertion_point(field_list:caffe.SolverState.history)
return history_;
}
// optional int32 current_step = 4 [default = 0];
inline bool SolverState::_internal_has_current_step() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool SolverState::has_current_step() const {
return _internal_has_current_step();
}
inline void SolverState::clear_current_step() {
current_step_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t SolverState::_internal_current_step() const {
return current_step_;
}
inline int32_t SolverState::current_step() const {
// @@protoc_insertion_point(field_get:caffe.SolverState.current_step)
return _internal_current_step();
}
inline void SolverState::_internal_set_current_step(int32_t value) {
_has_bits_[0] |= 0x00000004u;
current_step_ = value;
}
inline void SolverState::set_current_step(int32_t value) {
_internal_set_current_step(value);
// @@protoc_insertion_point(field_set:caffe.SolverState.current_step)
}
// -------------------------------------------------------------------
// NetState
// optional .caffe.Phase phase = 1 [default = TEST];
inline bool NetState::_internal_has_phase() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool NetState::has_phase() const {
return _internal_has_phase();
}
inline void NetState::clear_phase() {
phase_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline ::caffe::Phase NetState::_internal_phase() const {
return static_cast< ::caffe::Phase >(phase_);
}
inline ::caffe::Phase NetState::phase() const {
// @@protoc_insertion_point(field_get:caffe.NetState.phase)
return _internal_phase();
}
inline void NetState::_internal_set_phase(::caffe::Phase value) {
assert(::caffe::Phase_IsValid(value));
_has_bits_[0] |= 0x00000002u;
phase_ = value;
}
inline void NetState::set_phase(::caffe::Phase value) {
_internal_set_phase(value);
// @@protoc_insertion_point(field_set:caffe.NetState.phase)
}
// optional int32 level = 2 [default = 0];
inline bool NetState::_internal_has_level() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool NetState::has_level() const {
return _internal_has_level();
}
inline void NetState::clear_level() {
level_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t NetState::_internal_level() const {
return level_;
}
inline int32_t NetState::level() const {
// @@protoc_insertion_point(field_get:caffe.NetState.level)
return _internal_level();
}
inline void NetState::_internal_set_level(int32_t value) {
_has_bits_[0] |= 0x00000001u;
level_ = value;
}
inline void NetState::set_level(int32_t value) {
_internal_set_level(value);
// @@protoc_insertion_point(field_set:caffe.NetState.level)
}
// repeated string stage = 3;
inline int NetState::_internal_stage_size() const {
return stage_.size();
}
inline int NetState::stage_size() const {
return _internal_stage_size();
}
inline void NetState::clear_stage() {
stage_.Clear();
}
inline std::string* NetState::add_stage() {
std::string* _s = _internal_add_stage();
// @@protoc_insertion_point(field_add_mutable:caffe.NetState.stage)
return _s;
}
inline const std::string& NetState::_internal_stage(int index) const {
return stage_.Get(index);
}
inline const std::string& NetState::stage(int index) const {
// @@protoc_insertion_point(field_get:caffe.NetState.stage)
return _internal_stage(index);
}
inline std::string* NetState::mutable_stage(int index) {
// @@protoc_insertion_point(field_mutable:caffe.NetState.stage)
return stage_.Mutable(index);
}
inline void NetState::set_stage(int index, const std::string& value) {
stage_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.NetState.stage)
}
inline void NetState::set_stage(int index, std::string&& value) {
stage_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.NetState.stage)
}
inline void NetState::set_stage(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
stage_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.NetState.stage)
}
inline void NetState::set_stage(int index, const char* value, size_t size) {
stage_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.NetState.stage)
}
inline std::string* NetState::_internal_add_stage() {
return stage_.Add();
}
inline void NetState::add_stage(const std::string& value) {
stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.NetState.stage)
}
inline void NetState::add_stage(std::string&& value) {
stage_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.NetState.stage)
}
inline void NetState::add_stage(const char* value) {
GOOGLE_DCHECK(value != nullptr);
stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.NetState.stage)
}
inline void NetState::add_stage(const char* value, size_t size) {
stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.NetState.stage)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetState::stage() const {
// @@protoc_insertion_point(field_list:caffe.NetState.stage)
return stage_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetState::mutable_stage() {
// @@protoc_insertion_point(field_mutable_list:caffe.NetState.stage)
return &stage_;
}
// -------------------------------------------------------------------
// NetStateRule
// optional .caffe.Phase phase = 1;
inline bool NetStateRule::_internal_has_phase() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool NetStateRule::has_phase() const {
return _internal_has_phase();
}
inline void NetStateRule::clear_phase() {
phase_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::Phase NetStateRule::_internal_phase() const {
return static_cast< ::caffe::Phase >(phase_);
}
inline ::caffe::Phase NetStateRule::phase() const {
// @@protoc_insertion_point(field_get:caffe.NetStateRule.phase)
return _internal_phase();
}
inline void NetStateRule::_internal_set_phase(::caffe::Phase value) {
assert(::caffe::Phase_IsValid(value));
_has_bits_[0] |= 0x00000001u;
phase_ = value;
}
inline void NetStateRule::set_phase(::caffe::Phase value) {
_internal_set_phase(value);
// @@protoc_insertion_point(field_set:caffe.NetStateRule.phase)
}
// optional int32 min_level = 2;
inline bool NetStateRule::_internal_has_min_level() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool NetStateRule::has_min_level() const {
return _internal_has_min_level();
}
inline void NetStateRule::clear_min_level() {
min_level_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t NetStateRule::_internal_min_level() const {
return min_level_;
}
inline int32_t NetStateRule::min_level() const {
// @@protoc_insertion_point(field_get:caffe.NetStateRule.min_level)
return _internal_min_level();
}
inline void NetStateRule::_internal_set_min_level(int32_t value) {
_has_bits_[0] |= 0x00000002u;
min_level_ = value;
}
inline void NetStateRule::set_min_level(int32_t value) {
_internal_set_min_level(value);
// @@protoc_insertion_point(field_set:caffe.NetStateRule.min_level)
}
// optional int32 max_level = 3;
inline bool NetStateRule::_internal_has_max_level() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool NetStateRule::has_max_level() const {
return _internal_has_max_level();
}
inline void NetStateRule::clear_max_level() {
max_level_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t NetStateRule::_internal_max_level() const {
return max_level_;
}
inline int32_t NetStateRule::max_level() const {
// @@protoc_insertion_point(field_get:caffe.NetStateRule.max_level)
return _internal_max_level();
}
inline void NetStateRule::_internal_set_max_level(int32_t value) {
_has_bits_[0] |= 0x00000004u;
max_level_ = value;
}
inline void NetStateRule::set_max_level(int32_t value) {
_internal_set_max_level(value);
// @@protoc_insertion_point(field_set:caffe.NetStateRule.max_level)
}
// repeated string stage = 4;
inline int NetStateRule::_internal_stage_size() const {
return stage_.size();
}
inline int NetStateRule::stage_size() const {
return _internal_stage_size();
}
inline void NetStateRule::clear_stage() {
stage_.Clear();
}
inline std::string* NetStateRule::add_stage() {
std::string* _s = _internal_add_stage();
// @@protoc_insertion_point(field_add_mutable:caffe.NetStateRule.stage)
return _s;
}
inline const std::string& NetStateRule::_internal_stage(int index) const {
return stage_.Get(index);
}
inline const std::string& NetStateRule::stage(int index) const {
// @@protoc_insertion_point(field_get:caffe.NetStateRule.stage)
return _internal_stage(index);
}
inline std::string* NetStateRule::mutable_stage(int index) {
// @@protoc_insertion_point(field_mutable:caffe.NetStateRule.stage)
return stage_.Mutable(index);
}
inline void NetStateRule::set_stage(int index, const std::string& value) {
stage_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.NetStateRule.stage)
}
inline void NetStateRule::set_stage(int index, std::string&& value) {
stage_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.NetStateRule.stage)
}
inline void NetStateRule::set_stage(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
stage_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.NetStateRule.stage)
}
inline void NetStateRule::set_stage(int index, const char* value, size_t size) {
stage_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.NetStateRule.stage)
}
inline std::string* NetStateRule::_internal_add_stage() {
return stage_.Add();
}
inline void NetStateRule::add_stage(const std::string& value) {
stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.NetStateRule.stage)
}
inline void NetStateRule::add_stage(std::string&& value) {
stage_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.NetStateRule.stage)
}
inline void NetStateRule::add_stage(const char* value) {
GOOGLE_DCHECK(value != nullptr);
stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.NetStateRule.stage)
}
inline void NetStateRule::add_stage(const char* value, size_t size) {
stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.NetStateRule.stage)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetStateRule::stage() const {
// @@protoc_insertion_point(field_list:caffe.NetStateRule.stage)
return stage_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetStateRule::mutable_stage() {
// @@protoc_insertion_point(field_mutable_list:caffe.NetStateRule.stage)
return &stage_;
}
// repeated string not_stage = 5;
inline int NetStateRule::_internal_not_stage_size() const {
return not_stage_.size();
}
inline int NetStateRule::not_stage_size() const {
return _internal_not_stage_size();
}
inline void NetStateRule::clear_not_stage() {
not_stage_.Clear();
}
inline std::string* NetStateRule::add_not_stage() {
std::string* _s = _internal_add_not_stage();
// @@protoc_insertion_point(field_add_mutable:caffe.NetStateRule.not_stage)
return _s;
}
inline const std::string& NetStateRule::_internal_not_stage(int index) const {
return not_stage_.Get(index);
}
inline const std::string& NetStateRule::not_stage(int index) const {
// @@protoc_insertion_point(field_get:caffe.NetStateRule.not_stage)
return _internal_not_stage(index);
}
inline std::string* NetStateRule::mutable_not_stage(int index) {
// @@protoc_insertion_point(field_mutable:caffe.NetStateRule.not_stage)
return not_stage_.Mutable(index);
}
inline void NetStateRule::set_not_stage(int index, const std::string& value) {
not_stage_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.NetStateRule.not_stage)
}
inline void NetStateRule::set_not_stage(int index, std::string&& value) {
not_stage_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.NetStateRule.not_stage)
}
inline void NetStateRule::set_not_stage(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
not_stage_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.NetStateRule.not_stage)
}
inline void NetStateRule::set_not_stage(int index, const char* value, size_t size) {
not_stage_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.NetStateRule.not_stage)
}
inline std::string* NetStateRule::_internal_add_not_stage() {
return not_stage_.Add();
}
inline void NetStateRule::add_not_stage(const std::string& value) {
not_stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.NetStateRule.not_stage)
}
inline void NetStateRule::add_not_stage(std::string&& value) {
not_stage_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.NetStateRule.not_stage)
}
inline void NetStateRule::add_not_stage(const char* value) {
GOOGLE_DCHECK(value != nullptr);
not_stage_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.NetStateRule.not_stage)
}
inline void NetStateRule::add_not_stage(const char* value, size_t size) {
not_stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.NetStateRule.not_stage)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetStateRule::not_stage() const {
// @@protoc_insertion_point(field_list:caffe.NetStateRule.not_stage)
return not_stage_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetStateRule::mutable_not_stage() {
// @@protoc_insertion_point(field_mutable_list:caffe.NetStateRule.not_stage)
return &not_stage_;
}
// -------------------------------------------------------------------
// ParamSpec
// optional string name = 1;
inline bool ParamSpec::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ParamSpec::has_name() const {
return _internal_has_name();
}
inline void ParamSpec::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ParamSpec::name() const {
// @@protoc_insertion_point(field_get:caffe.ParamSpec.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ParamSpec::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.ParamSpec.name)
}
inline std::string* ParamSpec::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:caffe.ParamSpec.name)
return _s;
}
inline const std::string& ParamSpec::_internal_name() const {
return name_.Get();
}
inline void ParamSpec::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ParamSpec::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ParamSpec::release_name() {
// @@protoc_insertion_point(field_release:caffe.ParamSpec.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ParamSpec::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.ParamSpec.name)
}
// optional .caffe.ParamSpec.DimCheckMode share_mode = 2;
inline bool ParamSpec::_internal_has_share_mode() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ParamSpec::has_share_mode() const {
return _internal_has_share_mode();
}
inline void ParamSpec::clear_share_mode() {
share_mode_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::caffe::ParamSpec_DimCheckMode ParamSpec::_internal_share_mode() const {
return static_cast< ::caffe::ParamSpec_DimCheckMode >(share_mode_);
}
inline ::caffe::ParamSpec_DimCheckMode ParamSpec::share_mode() const {
// @@protoc_insertion_point(field_get:caffe.ParamSpec.share_mode)
return _internal_share_mode();
}
inline void ParamSpec::_internal_set_share_mode(::caffe::ParamSpec_DimCheckMode value) {
assert(::caffe::ParamSpec_DimCheckMode_IsValid(value));
_has_bits_[0] |= 0x00000002u;
share_mode_ = value;
}
inline void ParamSpec::set_share_mode(::caffe::ParamSpec_DimCheckMode value) {
_internal_set_share_mode(value);
// @@protoc_insertion_point(field_set:caffe.ParamSpec.share_mode)
}
// optional float lr_mult = 3 [default = 1];
inline bool ParamSpec::_internal_has_lr_mult() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ParamSpec::has_lr_mult() const {
return _internal_has_lr_mult();
}
inline void ParamSpec::clear_lr_mult() {
lr_mult_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline float ParamSpec::_internal_lr_mult() const {
return lr_mult_;
}
inline float ParamSpec::lr_mult() const {
// @@protoc_insertion_point(field_get:caffe.ParamSpec.lr_mult)
return _internal_lr_mult();
}
inline void ParamSpec::_internal_set_lr_mult(float value) {
_has_bits_[0] |= 0x00000004u;
lr_mult_ = value;
}
inline void ParamSpec::set_lr_mult(float value) {
_internal_set_lr_mult(value);
// @@protoc_insertion_point(field_set:caffe.ParamSpec.lr_mult)
}
// optional float decay_mult = 4 [default = 1];
inline bool ParamSpec::_internal_has_decay_mult() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool ParamSpec::has_decay_mult() const {
return _internal_has_decay_mult();
}
inline void ParamSpec::clear_decay_mult() {
decay_mult_ = 1;
_has_bits_[0] &= ~0x00000008u;
}
inline float ParamSpec::_internal_decay_mult() const {
return decay_mult_;
}
inline float ParamSpec::decay_mult() const {
// @@protoc_insertion_point(field_get:caffe.ParamSpec.decay_mult)
return _internal_decay_mult();
}
inline void ParamSpec::_internal_set_decay_mult(float value) {
_has_bits_[0] |= 0x00000008u;
decay_mult_ = value;
}
inline void ParamSpec::set_decay_mult(float value) {
_internal_set_decay_mult(value);
// @@protoc_insertion_point(field_set:caffe.ParamSpec.decay_mult)
}
// -------------------------------------------------------------------
// LayerParameter
// optional string name = 1;
inline bool LayerParameter::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool LayerParameter::has_name() const {
return _internal_has_name();
}
inline void LayerParameter::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LayerParameter::name() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LayerParameter::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.LayerParameter.name)
}
inline std::string* LayerParameter::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.name)
return _s;
}
inline const std::string& LayerParameter::_internal_name() const {
return name_.Get();
}
inline void LayerParameter::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LayerParameter::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LayerParameter::release_name() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void LayerParameter::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.name)
}
// optional string type = 2;
inline bool LayerParameter::_internal_has_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool LayerParameter::has_type() const {
return _internal_has_type();
}
inline void LayerParameter::clear_type() {
type_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LayerParameter::type() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.type)
return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LayerParameter::set_type(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.LayerParameter.type)
}
inline std::string* LayerParameter::mutable_type() {
std::string* _s = _internal_mutable_type();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.type)
return _s;
}
inline const std::string& LayerParameter::_internal_type() const {
return type_.Get();
}
inline void LayerParameter::_internal_set_type(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LayerParameter::_internal_mutable_type() {
_has_bits_[0] |= 0x00000002u;
return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LayerParameter::release_type() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.type)
if (!_internal_has_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void LayerParameter::set_allocated_type(std::string* type) {
if (type != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.type)
}
// repeated string bottom = 3;
inline int LayerParameter::_internal_bottom_size() const {
return bottom_.size();
}
inline int LayerParameter::bottom_size() const {
return _internal_bottom_size();
}
inline void LayerParameter::clear_bottom() {
bottom_.Clear();
}
inline std::string* LayerParameter::add_bottom() {
std::string* _s = _internal_add_bottom();
// @@protoc_insertion_point(field_add_mutable:caffe.LayerParameter.bottom)
return _s;
}
inline const std::string& LayerParameter::_internal_bottom(int index) const {
return bottom_.Get(index);
}
inline const std::string& LayerParameter::bottom(int index) const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.bottom)
return _internal_bottom(index);
}
inline std::string* LayerParameter::mutable_bottom(int index) {
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.bottom)
return bottom_.Mutable(index);
}
inline void LayerParameter::set_bottom(int index, const std::string& value) {
bottom_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.LayerParameter.bottom)
}
inline void LayerParameter::set_bottom(int index, std::string&& value) {
bottom_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.LayerParameter.bottom)
}
inline void LayerParameter::set_bottom(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
bottom_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.LayerParameter.bottom)
}
inline void LayerParameter::set_bottom(int index, const char* value, size_t size) {
bottom_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.bottom)
}
inline std::string* LayerParameter::_internal_add_bottom() {
return bottom_.Add();
}
inline void LayerParameter::add_bottom(const std::string& value) {
bottom_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.LayerParameter.bottom)
}
inline void LayerParameter::add_bottom(std::string&& value) {
bottom_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.LayerParameter.bottom)
}
inline void LayerParameter::add_bottom(const char* value) {
GOOGLE_DCHECK(value != nullptr);
bottom_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.LayerParameter.bottom)
}
inline void LayerParameter::add_bottom(const char* value, size_t size) {
bottom_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.LayerParameter.bottom)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
LayerParameter::bottom() const {
// @@protoc_insertion_point(field_list:caffe.LayerParameter.bottom)
return bottom_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
LayerParameter::mutable_bottom() {
// @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.bottom)
return &bottom_;
}
// repeated string top = 4;
inline int LayerParameter::_internal_top_size() const {
return top_.size();
}
inline int LayerParameter::top_size() const {
return _internal_top_size();
}
inline void LayerParameter::clear_top() {
top_.Clear();
}
inline std::string* LayerParameter::add_top() {
std::string* _s = _internal_add_top();
// @@protoc_insertion_point(field_add_mutable:caffe.LayerParameter.top)
return _s;
}
inline const std::string& LayerParameter::_internal_top(int index) const {
return top_.Get(index);
}
inline const std::string& LayerParameter::top(int index) const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.top)
return _internal_top(index);
}
inline std::string* LayerParameter::mutable_top(int index) {
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.top)
return top_.Mutable(index);
}
inline void LayerParameter::set_top(int index, const std::string& value) {
top_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.LayerParameter.top)
}
inline void LayerParameter::set_top(int index, std::string&& value) {
top_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.LayerParameter.top)
}
inline void LayerParameter::set_top(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
top_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.LayerParameter.top)
}
inline void LayerParameter::set_top(int index, const char* value, size_t size) {
top_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.top)
}
inline std::string* LayerParameter::_internal_add_top() {
return top_.Add();
}
inline void LayerParameter::add_top(const std::string& value) {
top_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.LayerParameter.top)
}
inline void LayerParameter::add_top(std::string&& value) {
top_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.LayerParameter.top)
}
inline void LayerParameter::add_top(const char* value) {
GOOGLE_DCHECK(value != nullptr);
top_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.LayerParameter.top)
}
inline void LayerParameter::add_top(const char* value, size_t size) {
top_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.LayerParameter.top)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
LayerParameter::top() const {
// @@protoc_insertion_point(field_list:caffe.LayerParameter.top)
return top_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
LayerParameter::mutable_top() {
// @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.top)
return &top_;
}
// optional .caffe.Phase phase = 10;
inline bool LayerParameter::_internal_has_phase() const {
bool value = (_has_bits_[2] & 0x00000010u) != 0;
return value;
}
inline bool LayerParameter::has_phase() const {
return _internal_has_phase();
}
inline void LayerParameter::clear_phase() {
phase_ = 0;
_has_bits_[2] &= ~0x00000010u;
}
inline ::caffe::Phase LayerParameter::_internal_phase() const {
return static_cast< ::caffe::Phase >(phase_);
}
inline ::caffe::Phase LayerParameter::phase() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.phase)
return _internal_phase();
}
inline void LayerParameter::_internal_set_phase(::caffe::Phase value) {
assert(::caffe::Phase_IsValid(value));
_has_bits_[2] |= 0x00000010u;
phase_ = value;
}
inline void LayerParameter::set_phase(::caffe::Phase value) {
_internal_set_phase(value);
// @@protoc_insertion_point(field_set:caffe.LayerParameter.phase)
}
// repeated float loss_weight = 5;
inline int LayerParameter::_internal_loss_weight_size() const {
return loss_weight_.size();
}
inline int LayerParameter::loss_weight_size() const {
return _internal_loss_weight_size();
}
inline void LayerParameter::clear_loss_weight() {
loss_weight_.Clear();
}
inline float LayerParameter::_internal_loss_weight(int index) const {
return loss_weight_.Get(index);
}
inline float LayerParameter::loss_weight(int index) const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.loss_weight)
return _internal_loss_weight(index);
}
inline void LayerParameter::set_loss_weight(int index, float value) {
loss_weight_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.LayerParameter.loss_weight)
}
inline void LayerParameter::_internal_add_loss_weight(float value) {
loss_weight_.Add(value);
}
inline void LayerParameter::add_loss_weight(float value) {
_internal_add_loss_weight(value);
// @@protoc_insertion_point(field_add:caffe.LayerParameter.loss_weight)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerParameter::_internal_loss_weight() const {
return loss_weight_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerParameter::loss_weight() const {
// @@protoc_insertion_point(field_list:caffe.LayerParameter.loss_weight)
return _internal_loss_weight();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerParameter::_internal_mutable_loss_weight() {
return &loss_weight_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerParameter::mutable_loss_weight() {
// @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.loss_weight)
return _internal_mutable_loss_weight();
}
// repeated .caffe.ParamSpec param = 6;
inline int LayerParameter::_internal_param_size() const {
return param_.size();
}
inline int LayerParameter::param_size() const {
return _internal_param_size();
}
inline void LayerParameter::clear_param() {
param_.Clear();
}
inline ::caffe::ParamSpec* LayerParameter::mutable_param(int index) {
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.param)
return param_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::ParamSpec >*
LayerParameter::mutable_param() {
// @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.param)
return &param_;
}
inline const ::caffe::ParamSpec& LayerParameter::_internal_param(int index) const {
return param_.Get(index);
}
inline const ::caffe::ParamSpec& LayerParameter::param(int index) const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.param)
return _internal_param(index);
}
inline ::caffe::ParamSpec* LayerParameter::_internal_add_param() {
return param_.Add();
}
inline ::caffe::ParamSpec* LayerParameter::add_param() {
::caffe::ParamSpec* _add = _internal_add_param();
// @@protoc_insertion_point(field_add:caffe.LayerParameter.param)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::ParamSpec >&
LayerParameter::param() const {
// @@protoc_insertion_point(field_list:caffe.LayerParameter.param)
return param_;
}
// repeated .caffe.BlobProto blobs = 7;
inline int LayerParameter::_internal_blobs_size() const {
return blobs_.size();
}
inline int LayerParameter::blobs_size() const {
return _internal_blobs_size();
}
inline void LayerParameter::clear_blobs() {
blobs_.Clear();
}
inline ::caffe::BlobProto* LayerParameter::mutable_blobs(int index) {
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.blobs)
return blobs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
LayerParameter::mutable_blobs() {
// @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.blobs)
return &blobs_;
}
inline const ::caffe::BlobProto& LayerParameter::_internal_blobs(int index) const {
return blobs_.Get(index);
}
inline const ::caffe::BlobProto& LayerParameter::blobs(int index) const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.blobs)
return _internal_blobs(index);
}
inline ::caffe::BlobProto* LayerParameter::_internal_add_blobs() {
return blobs_.Add();
}
inline ::caffe::BlobProto* LayerParameter::add_blobs() {
::caffe::BlobProto* _add = _internal_add_blobs();
// @@protoc_insertion_point(field_add:caffe.LayerParameter.blobs)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
LayerParameter::blobs() const {
// @@protoc_insertion_point(field_list:caffe.LayerParameter.blobs)
return blobs_;
}
// repeated bool propagate_down = 11;
inline int LayerParameter::_internal_propagate_down_size() const {
return propagate_down_.size();
}
inline int LayerParameter::propagate_down_size() const {
return _internal_propagate_down_size();
}
inline void LayerParameter::clear_propagate_down() {
propagate_down_.Clear();
}
inline bool LayerParameter::_internal_propagate_down(int index) const {
return propagate_down_.Get(index);
}
inline bool LayerParameter::propagate_down(int index) const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.propagate_down)
return _internal_propagate_down(index);
}
inline void LayerParameter::set_propagate_down(int index, bool value) {
propagate_down_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.LayerParameter.propagate_down)
}
inline void LayerParameter::_internal_add_propagate_down(bool value) {
propagate_down_.Add(value);
}
inline void LayerParameter::add_propagate_down(bool value) {
_internal_add_propagate_down(value);
// @@protoc_insertion_point(field_add:caffe.LayerParameter.propagate_down)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
LayerParameter::_internal_propagate_down() const {
return propagate_down_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
LayerParameter::propagate_down() const {
// @@protoc_insertion_point(field_list:caffe.LayerParameter.propagate_down)
return _internal_propagate_down();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
LayerParameter::_internal_mutable_propagate_down() {
return &propagate_down_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
LayerParameter::mutable_propagate_down() {
// @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.propagate_down)
return _internal_mutable_propagate_down();
}
// repeated .caffe.NetStateRule include = 8;
inline int LayerParameter::_internal_include_size() const {
return include_.size();
}
inline int LayerParameter::include_size() const {
return _internal_include_size();
}
inline void LayerParameter::clear_include() {
include_.Clear();
}
inline ::caffe::NetStateRule* LayerParameter::mutable_include(int index) {
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.include)
return include_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >*
LayerParameter::mutable_include() {
// @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.include)
return &include_;
}
inline const ::caffe::NetStateRule& LayerParameter::_internal_include(int index) const {
return include_.Get(index);
}
inline const ::caffe::NetStateRule& LayerParameter::include(int index) const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.include)
return _internal_include(index);
}
inline ::caffe::NetStateRule* LayerParameter::_internal_add_include() {
return include_.Add();
}
inline ::caffe::NetStateRule* LayerParameter::add_include() {
::caffe::NetStateRule* _add = _internal_add_include();
// @@protoc_insertion_point(field_add:caffe.LayerParameter.include)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >&
LayerParameter::include() const {
// @@protoc_insertion_point(field_list:caffe.LayerParameter.include)
return include_;
}
// repeated .caffe.NetStateRule exclude = 9;
inline int LayerParameter::_internal_exclude_size() const {
return exclude_.size();
}
inline int LayerParameter::exclude_size() const {
return _internal_exclude_size();
}
inline void LayerParameter::clear_exclude() {
exclude_.Clear();
}
inline ::caffe::NetStateRule* LayerParameter::mutable_exclude(int index) {
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.exclude)
return exclude_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >*
LayerParameter::mutable_exclude() {
// @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.exclude)
return &exclude_;
}
inline const ::caffe::NetStateRule& LayerParameter::_internal_exclude(int index) const {
return exclude_.Get(index);
}
inline const ::caffe::NetStateRule& LayerParameter::exclude(int index) const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.exclude)
return _internal_exclude(index);
}
inline ::caffe::NetStateRule* LayerParameter::_internal_add_exclude() {
return exclude_.Add();
}
inline ::caffe::NetStateRule* LayerParameter::add_exclude() {
::caffe::NetStateRule* _add = _internal_add_exclude();
// @@protoc_insertion_point(field_add:caffe.LayerParameter.exclude)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >&
LayerParameter::exclude() const {
// @@protoc_insertion_point(field_list:caffe.LayerParameter.exclude)
return exclude_;
}
// optional .caffe.TransformationParameter transform_param = 100;
inline bool LayerParameter::_internal_has_transform_param() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
PROTOBUF_ASSUME(!value || transform_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_transform_param() const {
return _internal_has_transform_param();
}
inline void LayerParameter::clear_transform_param() {
if (transform_param_ != nullptr) transform_param_->Clear();
_has_bits_[0] &= ~0x00000004u;
}
inline const ::caffe::TransformationParameter& LayerParameter::_internal_transform_param() const {
const ::caffe::TransformationParameter* p = transform_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::TransformationParameter&>(
::caffe::_TransformationParameter_default_instance_);
}
inline const ::caffe::TransformationParameter& LayerParameter::transform_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.transform_param)
return _internal_transform_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_transform_param(
::caffe::TransformationParameter* transform_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(transform_param_);
}
transform_param_ = transform_param;
if (transform_param) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.transform_param)
}
inline ::caffe::TransformationParameter* LayerParameter::release_transform_param() {
_has_bits_[0] &= ~0x00000004u;
::caffe::TransformationParameter* temp = transform_param_;
transform_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::TransformationParameter* LayerParameter::unsafe_arena_release_transform_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.transform_param)
_has_bits_[0] &= ~0x00000004u;
::caffe::TransformationParameter* temp = transform_param_;
transform_param_ = nullptr;
return temp;
}
inline ::caffe::TransformationParameter* LayerParameter::_internal_mutable_transform_param() {
_has_bits_[0] |= 0x00000004u;
if (transform_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::TransformationParameter>(GetArenaForAllocation());
transform_param_ = p;
}
return transform_param_;
}
inline ::caffe::TransformationParameter* LayerParameter::mutable_transform_param() {
::caffe::TransformationParameter* _msg = _internal_mutable_transform_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.transform_param)
return _msg;
}
inline void LayerParameter::set_allocated_transform_param(::caffe::TransformationParameter* transform_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete transform_param_;
}
if (transform_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::TransformationParameter>::GetOwningArena(transform_param);
if (message_arena != submessage_arena) {
transform_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, transform_param, submessage_arena);
}
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
transform_param_ = transform_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.transform_param)
}
// optional .caffe.LossParameter loss_param = 101;
inline bool LayerParameter::_internal_has_loss_param() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
PROTOBUF_ASSUME(!value || loss_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_loss_param() const {
return _internal_has_loss_param();
}
inline void LayerParameter::clear_loss_param() {
if (loss_param_ != nullptr) loss_param_->Clear();
_has_bits_[0] &= ~0x00000008u;
}
inline const ::caffe::LossParameter& LayerParameter::_internal_loss_param() const {
const ::caffe::LossParameter* p = loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::LossParameter&>(
::caffe::_LossParameter_default_instance_);
}
inline const ::caffe::LossParameter& LayerParameter::loss_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.loss_param)
return _internal_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_loss_param(
::caffe::LossParameter* loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(loss_param_);
}
loss_param_ = loss_param;
if (loss_param) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.loss_param)
}
inline ::caffe::LossParameter* LayerParameter::release_loss_param() {
_has_bits_[0] &= ~0x00000008u;
::caffe::LossParameter* temp = loss_param_;
loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::LossParameter* LayerParameter::unsafe_arena_release_loss_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.loss_param)
_has_bits_[0] &= ~0x00000008u;
::caffe::LossParameter* temp = loss_param_;
loss_param_ = nullptr;
return temp;
}
inline ::caffe::LossParameter* LayerParameter::_internal_mutable_loss_param() {
_has_bits_[0] |= 0x00000008u;
if (loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::LossParameter>(GetArenaForAllocation());
loss_param_ = p;
}
return loss_param_;
}
inline ::caffe::LossParameter* LayerParameter::mutable_loss_param() {
::caffe::LossParameter* _msg = _internal_mutable_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.loss_param)
return _msg;
}
inline void LayerParameter::set_allocated_loss_param(::caffe::LossParameter* loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete loss_param_;
}
if (loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::LossParameter>::GetOwningArena(loss_param);
if (message_arena != submessage_arena) {
loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, loss_param, submessage_arena);
}
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
loss_param_ = loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.loss_param)
}
// optional .caffe.AccuracyParameter accuracy_param = 102;
inline bool LayerParameter::_internal_has_accuracy_param() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
PROTOBUF_ASSUME(!value || accuracy_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_accuracy_param() const {
return _internal_has_accuracy_param();
}
inline void LayerParameter::clear_accuracy_param() {
if (accuracy_param_ != nullptr) accuracy_param_->Clear();
_has_bits_[0] &= ~0x00000010u;
}
inline const ::caffe::AccuracyParameter& LayerParameter::_internal_accuracy_param() const {
const ::caffe::AccuracyParameter* p = accuracy_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::AccuracyParameter&>(
::caffe::_AccuracyParameter_default_instance_);
}
inline const ::caffe::AccuracyParameter& LayerParameter::accuracy_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.accuracy_param)
return _internal_accuracy_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_accuracy_param(
::caffe::AccuracyParameter* accuracy_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(accuracy_param_);
}
accuracy_param_ = accuracy_param;
if (accuracy_param) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.accuracy_param)
}
inline ::caffe::AccuracyParameter* LayerParameter::release_accuracy_param() {
_has_bits_[0] &= ~0x00000010u;
::caffe::AccuracyParameter* temp = accuracy_param_;
accuracy_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::AccuracyParameter* LayerParameter::unsafe_arena_release_accuracy_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.accuracy_param)
_has_bits_[0] &= ~0x00000010u;
::caffe::AccuracyParameter* temp = accuracy_param_;
accuracy_param_ = nullptr;
return temp;
}
inline ::caffe::AccuracyParameter* LayerParameter::_internal_mutable_accuracy_param() {
_has_bits_[0] |= 0x00000010u;
if (accuracy_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::AccuracyParameter>(GetArenaForAllocation());
accuracy_param_ = p;
}
return accuracy_param_;
}
inline ::caffe::AccuracyParameter* LayerParameter::mutable_accuracy_param() {
::caffe::AccuracyParameter* _msg = _internal_mutable_accuracy_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.accuracy_param)
return _msg;
}
inline void LayerParameter::set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete accuracy_param_;
}
if (accuracy_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::AccuracyParameter>::GetOwningArena(accuracy_param);
if (message_arena != submessage_arena) {
accuracy_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, accuracy_param, submessage_arena);
}
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
accuracy_param_ = accuracy_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.accuracy_param)
}
// optional .caffe.AnnotatedDataParameter annotated_data_param = 200;
inline bool LayerParameter::_internal_has_annotated_data_param() const {
bool value = (_has_bits_[1] & 0x00080000u) != 0;
PROTOBUF_ASSUME(!value || annotated_data_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_annotated_data_param() const {
return _internal_has_annotated_data_param();
}
inline void LayerParameter::clear_annotated_data_param() {
if (annotated_data_param_ != nullptr) annotated_data_param_->Clear();
_has_bits_[1] &= ~0x00080000u;
}
inline const ::caffe::AnnotatedDataParameter& LayerParameter::_internal_annotated_data_param() const {
const ::caffe::AnnotatedDataParameter* p = annotated_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::AnnotatedDataParameter&>(
::caffe::_AnnotatedDataParameter_default_instance_);
}
inline const ::caffe::AnnotatedDataParameter& LayerParameter::annotated_data_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.annotated_data_param)
return _internal_annotated_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_annotated_data_param(
::caffe::AnnotatedDataParameter* annotated_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(annotated_data_param_);
}
annotated_data_param_ = annotated_data_param;
if (annotated_data_param) {
_has_bits_[1] |= 0x00080000u;
} else {
_has_bits_[1] &= ~0x00080000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.annotated_data_param)
}
inline ::caffe::AnnotatedDataParameter* LayerParameter::release_annotated_data_param() {
_has_bits_[1] &= ~0x00080000u;
::caffe::AnnotatedDataParameter* temp = annotated_data_param_;
annotated_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::AnnotatedDataParameter* LayerParameter::unsafe_arena_release_annotated_data_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.annotated_data_param)
_has_bits_[1] &= ~0x00080000u;
::caffe::AnnotatedDataParameter* temp = annotated_data_param_;
annotated_data_param_ = nullptr;
return temp;
}
inline ::caffe::AnnotatedDataParameter* LayerParameter::_internal_mutable_annotated_data_param() {
_has_bits_[1] |= 0x00080000u;
if (annotated_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::AnnotatedDataParameter>(GetArenaForAllocation());
annotated_data_param_ = p;
}
return annotated_data_param_;
}
inline ::caffe::AnnotatedDataParameter* LayerParameter::mutable_annotated_data_param() {
::caffe::AnnotatedDataParameter* _msg = _internal_mutable_annotated_data_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.annotated_data_param)
return _msg;
}
inline void LayerParameter::set_allocated_annotated_data_param(::caffe::AnnotatedDataParameter* annotated_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete annotated_data_param_;
}
if (annotated_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::AnnotatedDataParameter>::GetOwningArena(annotated_data_param);
if (message_arena != submessage_arena) {
annotated_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, annotated_data_param, submessage_arena);
}
_has_bits_[1] |= 0x00080000u;
} else {
_has_bits_[1] &= ~0x00080000u;
}
annotated_data_param_ = annotated_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.annotated_data_param)
}
// optional .caffe.ArgMaxParameter argmax_param = 103;
inline bool LayerParameter::_internal_has_argmax_param() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
PROTOBUF_ASSUME(!value || argmax_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_argmax_param() const {
return _internal_has_argmax_param();
}
inline void LayerParameter::clear_argmax_param() {
if (argmax_param_ != nullptr) argmax_param_->Clear();
_has_bits_[0] &= ~0x00000020u;
}
inline const ::caffe::ArgMaxParameter& LayerParameter::_internal_argmax_param() const {
const ::caffe::ArgMaxParameter* p = argmax_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ArgMaxParameter&>(
::caffe::_ArgMaxParameter_default_instance_);
}
inline const ::caffe::ArgMaxParameter& LayerParameter::argmax_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.argmax_param)
return _internal_argmax_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_argmax_param(
::caffe::ArgMaxParameter* argmax_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(argmax_param_);
}
argmax_param_ = argmax_param;
if (argmax_param) {
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.argmax_param)
}
inline ::caffe::ArgMaxParameter* LayerParameter::release_argmax_param() {
_has_bits_[0] &= ~0x00000020u;
::caffe::ArgMaxParameter* temp = argmax_param_;
argmax_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ArgMaxParameter* LayerParameter::unsafe_arena_release_argmax_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.argmax_param)
_has_bits_[0] &= ~0x00000020u;
::caffe::ArgMaxParameter* temp = argmax_param_;
argmax_param_ = nullptr;
return temp;
}
inline ::caffe::ArgMaxParameter* LayerParameter::_internal_mutable_argmax_param() {
_has_bits_[0] |= 0x00000020u;
if (argmax_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ArgMaxParameter>(GetArenaForAllocation());
argmax_param_ = p;
}
return argmax_param_;
}
inline ::caffe::ArgMaxParameter* LayerParameter::mutable_argmax_param() {
::caffe::ArgMaxParameter* _msg = _internal_mutable_argmax_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.argmax_param)
return _msg;
}
inline void LayerParameter::set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete argmax_param_;
}
if (argmax_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ArgMaxParameter>::GetOwningArena(argmax_param);
if (message_arena != submessage_arena) {
argmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, argmax_param, submessage_arena);
}
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
argmax_param_ = argmax_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.argmax_param)
}
// optional .caffe.BatchNormParameter batch_norm_param = 139;
inline bool LayerParameter::_internal_has_batch_norm_param() const {
bool value = (_has_bits_[1] & 0x00000200u) != 0;
PROTOBUF_ASSUME(!value || batch_norm_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_batch_norm_param() const {
return _internal_has_batch_norm_param();
}
inline void LayerParameter::clear_batch_norm_param() {
if (batch_norm_param_ != nullptr) batch_norm_param_->Clear();
_has_bits_[1] &= ~0x00000200u;
}
inline const ::caffe::BatchNormParameter& LayerParameter::_internal_batch_norm_param() const {
const ::caffe::BatchNormParameter* p = batch_norm_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::BatchNormParameter&>(
::caffe::_BatchNormParameter_default_instance_);
}
inline const ::caffe::BatchNormParameter& LayerParameter::batch_norm_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.batch_norm_param)
return _internal_batch_norm_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_batch_norm_param(
::caffe::BatchNormParameter* batch_norm_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(batch_norm_param_);
}
batch_norm_param_ = batch_norm_param;
if (batch_norm_param) {
_has_bits_[1] |= 0x00000200u;
} else {
_has_bits_[1] &= ~0x00000200u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.batch_norm_param)
}
inline ::caffe::BatchNormParameter* LayerParameter::release_batch_norm_param() {
_has_bits_[1] &= ~0x00000200u;
::caffe::BatchNormParameter* temp = batch_norm_param_;
batch_norm_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::BatchNormParameter* LayerParameter::unsafe_arena_release_batch_norm_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.batch_norm_param)
_has_bits_[1] &= ~0x00000200u;
::caffe::BatchNormParameter* temp = batch_norm_param_;
batch_norm_param_ = nullptr;
return temp;
}
inline ::caffe::BatchNormParameter* LayerParameter::_internal_mutable_batch_norm_param() {
_has_bits_[1] |= 0x00000200u;
if (batch_norm_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::BatchNormParameter>(GetArenaForAllocation());
batch_norm_param_ = p;
}
return batch_norm_param_;
}
inline ::caffe::BatchNormParameter* LayerParameter::mutable_batch_norm_param() {
::caffe::BatchNormParameter* _msg = _internal_mutable_batch_norm_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.batch_norm_param)
return _msg;
}
inline void LayerParameter::set_allocated_batch_norm_param(::caffe::BatchNormParameter* batch_norm_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete batch_norm_param_;
}
if (batch_norm_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::BatchNormParameter>::GetOwningArena(batch_norm_param);
if (message_arena != submessage_arena) {
batch_norm_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, batch_norm_param, submessage_arena);
}
_has_bits_[1] |= 0x00000200u;
} else {
_has_bits_[1] &= ~0x00000200u;
}
batch_norm_param_ = batch_norm_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.batch_norm_param)
}
// optional .caffe.BiasParameter bias_param = 141;
inline bool LayerParameter::_internal_has_bias_param() const {
bool value = (_has_bits_[1] & 0x00000800u) != 0;
PROTOBUF_ASSUME(!value || bias_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_bias_param() const {
return _internal_has_bias_param();
}
inline void LayerParameter::clear_bias_param() {
if (bias_param_ != nullptr) bias_param_->Clear();
_has_bits_[1] &= ~0x00000800u;
}
inline const ::caffe::BiasParameter& LayerParameter::_internal_bias_param() const {
const ::caffe::BiasParameter* p = bias_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::BiasParameter&>(
::caffe::_BiasParameter_default_instance_);
}
inline const ::caffe::BiasParameter& LayerParameter::bias_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.bias_param)
return _internal_bias_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_bias_param(
::caffe::BiasParameter* bias_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_param_);
}
bias_param_ = bias_param;
if (bias_param) {
_has_bits_[1] |= 0x00000800u;
} else {
_has_bits_[1] &= ~0x00000800u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.bias_param)
}
inline ::caffe::BiasParameter* LayerParameter::release_bias_param() {
_has_bits_[1] &= ~0x00000800u;
::caffe::BiasParameter* temp = bias_param_;
bias_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::BiasParameter* LayerParameter::unsafe_arena_release_bias_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.bias_param)
_has_bits_[1] &= ~0x00000800u;
::caffe::BiasParameter* temp = bias_param_;
bias_param_ = nullptr;
return temp;
}
inline ::caffe::BiasParameter* LayerParameter::_internal_mutable_bias_param() {
_has_bits_[1] |= 0x00000800u;
if (bias_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::BiasParameter>(GetArenaForAllocation());
bias_param_ = p;
}
return bias_param_;
}
inline ::caffe::BiasParameter* LayerParameter::mutable_bias_param() {
::caffe::BiasParameter* _msg = _internal_mutable_bias_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.bias_param)
return _msg;
}
inline void LayerParameter::set_allocated_bias_param(::caffe::BiasParameter* bias_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_param_;
}
if (bias_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::BiasParameter>::GetOwningArena(bias_param);
if (message_arena != submessage_arena) {
bias_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_param, submessage_arena);
}
_has_bits_[1] |= 0x00000800u;
} else {
_has_bits_[1] &= ~0x00000800u;
}
bias_param_ = bias_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.bias_param)
}
// optional .caffe.ConcatParameter concat_param = 104;
inline bool LayerParameter::_internal_has_concat_param() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
PROTOBUF_ASSUME(!value || concat_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_concat_param() const {
return _internal_has_concat_param();
}
inline void LayerParameter::clear_concat_param() {
if (concat_param_ != nullptr) concat_param_->Clear();
_has_bits_[0] &= ~0x00000040u;
}
inline const ::caffe::ConcatParameter& LayerParameter::_internal_concat_param() const {
const ::caffe::ConcatParameter* p = concat_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ConcatParameter&>(
::caffe::_ConcatParameter_default_instance_);
}
inline const ::caffe::ConcatParameter& LayerParameter::concat_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.concat_param)
return _internal_concat_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_concat_param(
::caffe::ConcatParameter* concat_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(concat_param_);
}
concat_param_ = concat_param;
if (concat_param) {
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.concat_param)
}
inline ::caffe::ConcatParameter* LayerParameter::release_concat_param() {
_has_bits_[0] &= ~0x00000040u;
::caffe::ConcatParameter* temp = concat_param_;
concat_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ConcatParameter* LayerParameter::unsafe_arena_release_concat_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.concat_param)
_has_bits_[0] &= ~0x00000040u;
::caffe::ConcatParameter* temp = concat_param_;
concat_param_ = nullptr;
return temp;
}
inline ::caffe::ConcatParameter* LayerParameter::_internal_mutable_concat_param() {
_has_bits_[0] |= 0x00000040u;
if (concat_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ConcatParameter>(GetArenaForAllocation());
concat_param_ = p;
}
return concat_param_;
}
inline ::caffe::ConcatParameter* LayerParameter::mutable_concat_param() {
::caffe::ConcatParameter* _msg = _internal_mutable_concat_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.concat_param)
return _msg;
}
inline void LayerParameter::set_allocated_concat_param(::caffe::ConcatParameter* concat_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete concat_param_;
}
if (concat_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ConcatParameter>::GetOwningArena(concat_param);
if (message_arena != submessage_arena) {
concat_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, concat_param, submessage_arena);
}
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
concat_param_ = concat_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.concat_param)
}
// optional .caffe.ContrastiveLossParameter contrastive_loss_param = 105;
inline bool LayerParameter::_internal_has_contrastive_loss_param() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
PROTOBUF_ASSUME(!value || contrastive_loss_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_contrastive_loss_param() const {
return _internal_has_contrastive_loss_param();
}
inline void LayerParameter::clear_contrastive_loss_param() {
if (contrastive_loss_param_ != nullptr) contrastive_loss_param_->Clear();
_has_bits_[0] &= ~0x00000080u;
}
inline const ::caffe::ContrastiveLossParameter& LayerParameter::_internal_contrastive_loss_param() const {
const ::caffe::ContrastiveLossParameter* p = contrastive_loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ContrastiveLossParameter&>(
::caffe::_ContrastiveLossParameter_default_instance_);
}
inline const ::caffe::ContrastiveLossParameter& LayerParameter::contrastive_loss_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.contrastive_loss_param)
return _internal_contrastive_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_contrastive_loss_param(
::caffe::ContrastiveLossParameter* contrastive_loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(contrastive_loss_param_);
}
contrastive_loss_param_ = contrastive_loss_param;
if (contrastive_loss_param) {
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.contrastive_loss_param)
}
inline ::caffe::ContrastiveLossParameter* LayerParameter::release_contrastive_loss_param() {
_has_bits_[0] &= ~0x00000080u;
::caffe::ContrastiveLossParameter* temp = contrastive_loss_param_;
contrastive_loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ContrastiveLossParameter* LayerParameter::unsafe_arena_release_contrastive_loss_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.contrastive_loss_param)
_has_bits_[0] &= ~0x00000080u;
::caffe::ContrastiveLossParameter* temp = contrastive_loss_param_;
contrastive_loss_param_ = nullptr;
return temp;
}
inline ::caffe::ContrastiveLossParameter* LayerParameter::_internal_mutable_contrastive_loss_param() {
_has_bits_[0] |= 0x00000080u;
if (contrastive_loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ContrastiveLossParameter>(GetArenaForAllocation());
contrastive_loss_param_ = p;
}
return contrastive_loss_param_;
}
inline ::caffe::ContrastiveLossParameter* LayerParameter::mutable_contrastive_loss_param() {
::caffe::ContrastiveLossParameter* _msg = _internal_mutable_contrastive_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.contrastive_loss_param)
return _msg;
}
inline void LayerParameter::set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete contrastive_loss_param_;
}
if (contrastive_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ContrastiveLossParameter>::GetOwningArena(contrastive_loss_param);
if (message_arena != submessage_arena) {
contrastive_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, contrastive_loss_param, submessage_arena);
}
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
contrastive_loss_param_ = contrastive_loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.contrastive_loss_param)
}
// optional .caffe.ConvolutionParameter convolution_param = 106;
inline bool LayerParameter::_internal_has_convolution_param() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
PROTOBUF_ASSUME(!value || convolution_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_convolution_param() const {
return _internal_has_convolution_param();
}
inline void LayerParameter::clear_convolution_param() {
if (convolution_param_ != nullptr) convolution_param_->Clear();
_has_bits_[0] &= ~0x00000100u;
}
inline const ::caffe::ConvolutionParameter& LayerParameter::_internal_convolution_param() const {
const ::caffe::ConvolutionParameter* p = convolution_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ConvolutionParameter&>(
::caffe::_ConvolutionParameter_default_instance_);
}
inline const ::caffe::ConvolutionParameter& LayerParameter::convolution_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.convolution_param)
return _internal_convolution_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_convolution_param(
::caffe::ConvolutionParameter* convolution_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(convolution_param_);
}
convolution_param_ = convolution_param;
if (convolution_param) {
_has_bits_[0] |= 0x00000100u;
} else {
_has_bits_[0] &= ~0x00000100u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.convolution_param)
}
inline ::caffe::ConvolutionParameter* LayerParameter::release_convolution_param() {
_has_bits_[0] &= ~0x00000100u;
::caffe::ConvolutionParameter* temp = convolution_param_;
convolution_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ConvolutionParameter* LayerParameter::unsafe_arena_release_convolution_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.convolution_param)
_has_bits_[0] &= ~0x00000100u;
::caffe::ConvolutionParameter* temp = convolution_param_;
convolution_param_ = nullptr;
return temp;
}
inline ::caffe::ConvolutionParameter* LayerParameter::_internal_mutable_convolution_param() {
_has_bits_[0] |= 0x00000100u;
if (convolution_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ConvolutionParameter>(GetArenaForAllocation());
convolution_param_ = p;
}
return convolution_param_;
}
inline ::caffe::ConvolutionParameter* LayerParameter::mutable_convolution_param() {
::caffe::ConvolutionParameter* _msg = _internal_mutable_convolution_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.convolution_param)
return _msg;
}
inline void LayerParameter::set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete convolution_param_;
}
if (convolution_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ConvolutionParameter>::GetOwningArena(convolution_param);
if (message_arena != submessage_arena) {
convolution_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, convolution_param, submessage_arena);
}
_has_bits_[0] |= 0x00000100u;
} else {
_has_bits_[0] &= ~0x00000100u;
}
convolution_param_ = convolution_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.convolution_param)
}
// optional .caffe.Convolution3DParameter convolution3d_param = 147;
inline bool LayerParameter::_internal_has_convolution3d_param() const {
bool value = (_has_bits_[1] & 0x00020000u) != 0;
PROTOBUF_ASSUME(!value || convolution3d_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_convolution3d_param() const {
return _internal_has_convolution3d_param();
}
inline void LayerParameter::clear_convolution3d_param() {
if (convolution3d_param_ != nullptr) convolution3d_param_->Clear();
_has_bits_[1] &= ~0x00020000u;
}
inline const ::caffe::Convolution3DParameter& LayerParameter::_internal_convolution3d_param() const {
const ::caffe::Convolution3DParameter* p = convolution3d_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::Convolution3DParameter&>(
::caffe::_Convolution3DParameter_default_instance_);
}
inline const ::caffe::Convolution3DParameter& LayerParameter::convolution3d_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.convolution3d_param)
return _internal_convolution3d_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_convolution3d_param(
::caffe::Convolution3DParameter* convolution3d_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(convolution3d_param_);
}
convolution3d_param_ = convolution3d_param;
if (convolution3d_param) {
_has_bits_[1] |= 0x00020000u;
} else {
_has_bits_[1] &= ~0x00020000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.convolution3d_param)
}
inline ::caffe::Convolution3DParameter* LayerParameter::release_convolution3d_param() {
_has_bits_[1] &= ~0x00020000u;
::caffe::Convolution3DParameter* temp = convolution3d_param_;
convolution3d_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::Convolution3DParameter* LayerParameter::unsafe_arena_release_convolution3d_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.convolution3d_param)
_has_bits_[1] &= ~0x00020000u;
::caffe::Convolution3DParameter* temp = convolution3d_param_;
convolution3d_param_ = nullptr;
return temp;
}
inline ::caffe::Convolution3DParameter* LayerParameter::_internal_mutable_convolution3d_param() {
_has_bits_[1] |= 0x00020000u;
if (convolution3d_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::Convolution3DParameter>(GetArenaForAllocation());
convolution3d_param_ = p;
}
return convolution3d_param_;
}
inline ::caffe::Convolution3DParameter* LayerParameter::mutable_convolution3d_param() {
::caffe::Convolution3DParameter* _msg = _internal_mutable_convolution3d_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.convolution3d_param)
return _msg;
}
inline void LayerParameter::set_allocated_convolution3d_param(::caffe::Convolution3DParameter* convolution3d_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete convolution3d_param_;
}
if (convolution3d_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::Convolution3DParameter>::GetOwningArena(convolution3d_param);
if (message_arena != submessage_arena) {
convolution3d_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, convolution3d_param, submessage_arena);
}
_has_bits_[1] |= 0x00020000u;
} else {
_has_bits_[1] &= ~0x00020000u;
}
convolution3d_param_ = convolution3d_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.convolution3d_param)
}
// optional .caffe.CropParameter crop_param = 144;
inline bool LayerParameter::_internal_has_crop_param() const {
bool value = (_has_bits_[1] & 0x00004000u) != 0;
PROTOBUF_ASSUME(!value || crop_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_crop_param() const {
return _internal_has_crop_param();
}
inline void LayerParameter::clear_crop_param() {
if (crop_param_ != nullptr) crop_param_->Clear();
_has_bits_[1] &= ~0x00004000u;
}
inline const ::caffe::CropParameter& LayerParameter::_internal_crop_param() const {
const ::caffe::CropParameter* p = crop_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::CropParameter&>(
::caffe::_CropParameter_default_instance_);
}
inline const ::caffe::CropParameter& LayerParameter::crop_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.crop_param)
return _internal_crop_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_crop_param(
::caffe::CropParameter* crop_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(crop_param_);
}
crop_param_ = crop_param;
if (crop_param) {
_has_bits_[1] |= 0x00004000u;
} else {
_has_bits_[1] &= ~0x00004000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.crop_param)
}
inline ::caffe::CropParameter* LayerParameter::release_crop_param() {
_has_bits_[1] &= ~0x00004000u;
::caffe::CropParameter* temp = crop_param_;
crop_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::CropParameter* LayerParameter::unsafe_arena_release_crop_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.crop_param)
_has_bits_[1] &= ~0x00004000u;
::caffe::CropParameter* temp = crop_param_;
crop_param_ = nullptr;
return temp;
}
inline ::caffe::CropParameter* LayerParameter::_internal_mutable_crop_param() {
_has_bits_[1] |= 0x00004000u;
if (crop_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::CropParameter>(GetArenaForAllocation());
crop_param_ = p;
}
return crop_param_;
}
inline ::caffe::CropParameter* LayerParameter::mutable_crop_param() {
::caffe::CropParameter* _msg = _internal_mutable_crop_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.crop_param)
return _msg;
}
inline void LayerParameter::set_allocated_crop_param(::caffe::CropParameter* crop_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete crop_param_;
}
if (crop_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::CropParameter>::GetOwningArena(crop_param);
if (message_arena != submessage_arena) {
crop_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, crop_param, submessage_arena);
}
_has_bits_[1] |= 0x00004000u;
} else {
_has_bits_[1] &= ~0x00004000u;
}
crop_param_ = crop_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.crop_param)
}
// optional .caffe.DataParameter data_param = 107;
inline bool LayerParameter::_internal_has_data_param() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
PROTOBUF_ASSUME(!value || data_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_data_param() const {
return _internal_has_data_param();
}
inline void LayerParameter::clear_data_param() {
if (data_param_ != nullptr) data_param_->Clear();
_has_bits_[0] &= ~0x00000200u;
}
inline const ::caffe::DataParameter& LayerParameter::_internal_data_param() const {
const ::caffe::DataParameter* p = data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::DataParameter&>(
::caffe::_DataParameter_default_instance_);
}
inline const ::caffe::DataParameter& LayerParameter::data_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.data_param)
return _internal_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_data_param(
::caffe::DataParameter* data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(data_param_);
}
data_param_ = data_param;
if (data_param) {
_has_bits_[0] |= 0x00000200u;
} else {
_has_bits_[0] &= ~0x00000200u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.data_param)
}
inline ::caffe::DataParameter* LayerParameter::release_data_param() {
_has_bits_[0] &= ~0x00000200u;
::caffe::DataParameter* temp = data_param_;
data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::DataParameter* LayerParameter::unsafe_arena_release_data_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.data_param)
_has_bits_[0] &= ~0x00000200u;
::caffe::DataParameter* temp = data_param_;
data_param_ = nullptr;
return temp;
}
inline ::caffe::DataParameter* LayerParameter::_internal_mutable_data_param() {
_has_bits_[0] |= 0x00000200u;
if (data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::DataParameter>(GetArenaForAllocation());
data_param_ = p;
}
return data_param_;
}
inline ::caffe::DataParameter* LayerParameter::mutable_data_param() {
::caffe::DataParameter* _msg = _internal_mutable_data_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.data_param)
return _msg;
}
inline void LayerParameter::set_allocated_data_param(::caffe::DataParameter* data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete data_param_;
}
if (data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::DataParameter>::GetOwningArena(data_param);
if (message_arena != submessage_arena) {
data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, data_param, submessage_arena);
}
_has_bits_[0] |= 0x00000200u;
} else {
_has_bits_[0] &= ~0x00000200u;
}
data_param_ = data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.data_param)
}
// optional .caffe.DetectionEvaluateParameter detection_evaluate_param = 205;
inline bool LayerParameter::_internal_has_detection_evaluate_param() const {
bool value = (_has_bits_[1] & 0x01000000u) != 0;
PROTOBUF_ASSUME(!value || detection_evaluate_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_detection_evaluate_param() const {
return _internal_has_detection_evaluate_param();
}
inline void LayerParameter::clear_detection_evaluate_param() {
if (detection_evaluate_param_ != nullptr) detection_evaluate_param_->Clear();
_has_bits_[1] &= ~0x01000000u;
}
inline const ::caffe::DetectionEvaluateParameter& LayerParameter::_internal_detection_evaluate_param() const {
const ::caffe::DetectionEvaluateParameter* p = detection_evaluate_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::DetectionEvaluateParameter&>(
::caffe::_DetectionEvaluateParameter_default_instance_);
}
inline const ::caffe::DetectionEvaluateParameter& LayerParameter::detection_evaluate_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.detection_evaluate_param)
return _internal_detection_evaluate_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_detection_evaluate_param(
::caffe::DetectionEvaluateParameter* detection_evaluate_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detection_evaluate_param_);
}
detection_evaluate_param_ = detection_evaluate_param;
if (detection_evaluate_param) {
_has_bits_[1] |= 0x01000000u;
} else {
_has_bits_[1] &= ~0x01000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.detection_evaluate_param)
}
inline ::caffe::DetectionEvaluateParameter* LayerParameter::release_detection_evaluate_param() {
_has_bits_[1] &= ~0x01000000u;
::caffe::DetectionEvaluateParameter* temp = detection_evaluate_param_;
detection_evaluate_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::DetectionEvaluateParameter* LayerParameter::unsafe_arena_release_detection_evaluate_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.detection_evaluate_param)
_has_bits_[1] &= ~0x01000000u;
::caffe::DetectionEvaluateParameter* temp = detection_evaluate_param_;
detection_evaluate_param_ = nullptr;
return temp;
}
inline ::caffe::DetectionEvaluateParameter* LayerParameter::_internal_mutable_detection_evaluate_param() {
_has_bits_[1] |= 0x01000000u;
if (detection_evaluate_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::DetectionEvaluateParameter>(GetArenaForAllocation());
detection_evaluate_param_ = p;
}
return detection_evaluate_param_;
}
inline ::caffe::DetectionEvaluateParameter* LayerParameter::mutable_detection_evaluate_param() {
::caffe::DetectionEvaluateParameter* _msg = _internal_mutable_detection_evaluate_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.detection_evaluate_param)
return _msg;
}
inline void LayerParameter::set_allocated_detection_evaluate_param(::caffe::DetectionEvaluateParameter* detection_evaluate_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete detection_evaluate_param_;
}
if (detection_evaluate_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::DetectionEvaluateParameter>::GetOwningArena(detection_evaluate_param);
if (message_arena != submessage_arena) {
detection_evaluate_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, detection_evaluate_param, submessage_arena);
}
_has_bits_[1] |= 0x01000000u;
} else {
_has_bits_[1] &= ~0x01000000u;
}
detection_evaluate_param_ = detection_evaluate_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.detection_evaluate_param)
}
// optional .caffe.DetectionOutputParameter detection_output_param = 204;
inline bool LayerParameter::_internal_has_detection_output_param() const {
bool value = (_has_bits_[1] & 0x00800000u) != 0;
PROTOBUF_ASSUME(!value || detection_output_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_detection_output_param() const {
return _internal_has_detection_output_param();
}
inline void LayerParameter::clear_detection_output_param() {
if (detection_output_param_ != nullptr) detection_output_param_->Clear();
_has_bits_[1] &= ~0x00800000u;
}
inline const ::caffe::DetectionOutputParameter& LayerParameter::_internal_detection_output_param() const {
const ::caffe::DetectionOutputParameter* p = detection_output_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::DetectionOutputParameter&>(
::caffe::_DetectionOutputParameter_default_instance_);
}
inline const ::caffe::DetectionOutputParameter& LayerParameter::detection_output_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.detection_output_param)
return _internal_detection_output_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_detection_output_param(
::caffe::DetectionOutputParameter* detection_output_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detection_output_param_);
}
detection_output_param_ = detection_output_param;
if (detection_output_param) {
_has_bits_[1] |= 0x00800000u;
} else {
_has_bits_[1] &= ~0x00800000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.detection_output_param)
}
inline ::caffe::DetectionOutputParameter* LayerParameter::release_detection_output_param() {
_has_bits_[1] &= ~0x00800000u;
::caffe::DetectionOutputParameter* temp = detection_output_param_;
detection_output_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::DetectionOutputParameter* LayerParameter::unsafe_arena_release_detection_output_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.detection_output_param)
_has_bits_[1] &= ~0x00800000u;
::caffe::DetectionOutputParameter* temp = detection_output_param_;
detection_output_param_ = nullptr;
return temp;
}
inline ::caffe::DetectionOutputParameter* LayerParameter::_internal_mutable_detection_output_param() {
_has_bits_[1] |= 0x00800000u;
if (detection_output_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::DetectionOutputParameter>(GetArenaForAllocation());
detection_output_param_ = p;
}
return detection_output_param_;
}
inline ::caffe::DetectionOutputParameter* LayerParameter::mutable_detection_output_param() {
::caffe::DetectionOutputParameter* _msg = _internal_mutable_detection_output_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.detection_output_param)
return _msg;
}
inline void LayerParameter::set_allocated_detection_output_param(::caffe::DetectionOutputParameter* detection_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete detection_output_param_;
}
if (detection_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::DetectionOutputParameter>::GetOwningArena(detection_output_param);
if (message_arena != submessage_arena) {
detection_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, detection_output_param, submessage_arena);
}
_has_bits_[1] |= 0x00800000u;
} else {
_has_bits_[1] &= ~0x00800000u;
}
detection_output_param_ = detection_output_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.detection_output_param)
}
// optional .caffe.DropoutParameter dropout_param = 108;
inline bool LayerParameter::_internal_has_dropout_param() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
PROTOBUF_ASSUME(!value || dropout_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_dropout_param() const {
return _internal_has_dropout_param();
}
inline void LayerParameter::clear_dropout_param() {
if (dropout_param_ != nullptr) dropout_param_->Clear();
_has_bits_[0] &= ~0x00000400u;
}
inline const ::caffe::DropoutParameter& LayerParameter::_internal_dropout_param() const {
const ::caffe::DropoutParameter* p = dropout_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::DropoutParameter&>(
::caffe::_DropoutParameter_default_instance_);
}
inline const ::caffe::DropoutParameter& LayerParameter::dropout_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.dropout_param)
return _internal_dropout_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_dropout_param(
::caffe::DropoutParameter* dropout_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dropout_param_);
}
dropout_param_ = dropout_param;
if (dropout_param) {
_has_bits_[0] |= 0x00000400u;
} else {
_has_bits_[0] &= ~0x00000400u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.dropout_param)
}
inline ::caffe::DropoutParameter* LayerParameter::release_dropout_param() {
_has_bits_[0] &= ~0x00000400u;
::caffe::DropoutParameter* temp = dropout_param_;
dropout_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::DropoutParameter* LayerParameter::unsafe_arena_release_dropout_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.dropout_param)
_has_bits_[0] &= ~0x00000400u;
::caffe::DropoutParameter* temp = dropout_param_;
dropout_param_ = nullptr;
return temp;
}
inline ::caffe::DropoutParameter* LayerParameter::_internal_mutable_dropout_param() {
_has_bits_[0] |= 0x00000400u;
if (dropout_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::DropoutParameter>(GetArenaForAllocation());
dropout_param_ = p;
}
return dropout_param_;
}
inline ::caffe::DropoutParameter* LayerParameter::mutable_dropout_param() {
::caffe::DropoutParameter* _msg = _internal_mutable_dropout_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.dropout_param)
return _msg;
}
inline void LayerParameter::set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete dropout_param_;
}
if (dropout_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::DropoutParameter>::GetOwningArena(dropout_param);
if (message_arena != submessage_arena) {
dropout_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, dropout_param, submessage_arena);
}
_has_bits_[0] |= 0x00000400u;
} else {
_has_bits_[0] &= ~0x00000400u;
}
dropout_param_ = dropout_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.dropout_param)
}
// optional .caffe.DummyDataParameter dummy_data_param = 109;
inline bool LayerParameter::_internal_has_dummy_data_param() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
PROTOBUF_ASSUME(!value || dummy_data_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_dummy_data_param() const {
return _internal_has_dummy_data_param();
}
inline void LayerParameter::clear_dummy_data_param() {
if (dummy_data_param_ != nullptr) dummy_data_param_->Clear();
_has_bits_[0] &= ~0x00000800u;
}
inline const ::caffe::DummyDataParameter& LayerParameter::_internal_dummy_data_param() const {
const ::caffe::DummyDataParameter* p = dummy_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::DummyDataParameter&>(
::caffe::_DummyDataParameter_default_instance_);
}
inline const ::caffe::DummyDataParameter& LayerParameter::dummy_data_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.dummy_data_param)
return _internal_dummy_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_dummy_data_param(
::caffe::DummyDataParameter* dummy_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dummy_data_param_);
}
dummy_data_param_ = dummy_data_param;
if (dummy_data_param) {
_has_bits_[0] |= 0x00000800u;
} else {
_has_bits_[0] &= ~0x00000800u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.dummy_data_param)
}
inline ::caffe::DummyDataParameter* LayerParameter::release_dummy_data_param() {
_has_bits_[0] &= ~0x00000800u;
::caffe::DummyDataParameter* temp = dummy_data_param_;
dummy_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::DummyDataParameter* LayerParameter::unsafe_arena_release_dummy_data_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.dummy_data_param)
_has_bits_[0] &= ~0x00000800u;
::caffe::DummyDataParameter* temp = dummy_data_param_;
dummy_data_param_ = nullptr;
return temp;
}
inline ::caffe::DummyDataParameter* LayerParameter::_internal_mutable_dummy_data_param() {
_has_bits_[0] |= 0x00000800u;
if (dummy_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::DummyDataParameter>(GetArenaForAllocation());
dummy_data_param_ = p;
}
return dummy_data_param_;
}
inline ::caffe::DummyDataParameter* LayerParameter::mutable_dummy_data_param() {
::caffe::DummyDataParameter* _msg = _internal_mutable_dummy_data_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.dummy_data_param)
return _msg;
}
inline void LayerParameter::set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete dummy_data_param_;
}
if (dummy_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::DummyDataParameter>::GetOwningArena(dummy_data_param);
if (message_arena != submessage_arena) {
dummy_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, dummy_data_param, submessage_arena);
}
_has_bits_[0] |= 0x00000800u;
} else {
_has_bits_[0] &= ~0x00000800u;
}
dummy_data_param_ = dummy_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.dummy_data_param)
}
// optional .caffe.EltwiseParameter eltwise_param = 110;
inline bool LayerParameter::_internal_has_eltwise_param() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
PROTOBUF_ASSUME(!value || eltwise_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_eltwise_param() const {
return _internal_has_eltwise_param();
}
inline void LayerParameter::clear_eltwise_param() {
if (eltwise_param_ != nullptr) eltwise_param_->Clear();
_has_bits_[0] &= ~0x00001000u;
}
inline const ::caffe::EltwiseParameter& LayerParameter::_internal_eltwise_param() const {
const ::caffe::EltwiseParameter* p = eltwise_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::EltwiseParameter&>(
::caffe::_EltwiseParameter_default_instance_);
}
inline const ::caffe::EltwiseParameter& LayerParameter::eltwise_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.eltwise_param)
return _internal_eltwise_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_eltwise_param(
::caffe::EltwiseParameter* eltwise_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(eltwise_param_);
}
eltwise_param_ = eltwise_param;
if (eltwise_param) {
_has_bits_[0] |= 0x00001000u;
} else {
_has_bits_[0] &= ~0x00001000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.eltwise_param)
}
inline ::caffe::EltwiseParameter* LayerParameter::release_eltwise_param() {
_has_bits_[0] &= ~0x00001000u;
::caffe::EltwiseParameter* temp = eltwise_param_;
eltwise_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::EltwiseParameter* LayerParameter::unsafe_arena_release_eltwise_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.eltwise_param)
_has_bits_[0] &= ~0x00001000u;
::caffe::EltwiseParameter* temp = eltwise_param_;
eltwise_param_ = nullptr;
return temp;
}
inline ::caffe::EltwiseParameter* LayerParameter::_internal_mutable_eltwise_param() {
_has_bits_[0] |= 0x00001000u;
if (eltwise_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::EltwiseParameter>(GetArenaForAllocation());
eltwise_param_ = p;
}
return eltwise_param_;
}
inline ::caffe::EltwiseParameter* LayerParameter::mutable_eltwise_param() {
::caffe::EltwiseParameter* _msg = _internal_mutable_eltwise_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.eltwise_param)
return _msg;
}
inline void LayerParameter::set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete eltwise_param_;
}
if (eltwise_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::EltwiseParameter>::GetOwningArena(eltwise_param);
if (message_arena != submessage_arena) {
eltwise_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, eltwise_param, submessage_arena);
}
_has_bits_[0] |= 0x00001000u;
} else {
_has_bits_[0] &= ~0x00001000u;
}
eltwise_param_ = eltwise_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.eltwise_param)
}
// optional .caffe.ELUParameter elu_param = 140;
inline bool LayerParameter::_internal_has_elu_param() const {
bool value = (_has_bits_[1] & 0x00000400u) != 0;
PROTOBUF_ASSUME(!value || elu_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_elu_param() const {
return _internal_has_elu_param();
}
inline void LayerParameter::clear_elu_param() {
if (elu_param_ != nullptr) elu_param_->Clear();
_has_bits_[1] &= ~0x00000400u;
}
inline const ::caffe::ELUParameter& LayerParameter::_internal_elu_param() const {
const ::caffe::ELUParameter* p = elu_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ELUParameter&>(
::caffe::_ELUParameter_default_instance_);
}
inline const ::caffe::ELUParameter& LayerParameter::elu_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.elu_param)
return _internal_elu_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_elu_param(
::caffe::ELUParameter* elu_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(elu_param_);
}
elu_param_ = elu_param;
if (elu_param) {
_has_bits_[1] |= 0x00000400u;
} else {
_has_bits_[1] &= ~0x00000400u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.elu_param)
}
inline ::caffe::ELUParameter* LayerParameter::release_elu_param() {
_has_bits_[1] &= ~0x00000400u;
::caffe::ELUParameter* temp = elu_param_;
elu_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ELUParameter* LayerParameter::unsafe_arena_release_elu_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.elu_param)
_has_bits_[1] &= ~0x00000400u;
::caffe::ELUParameter* temp = elu_param_;
elu_param_ = nullptr;
return temp;
}
inline ::caffe::ELUParameter* LayerParameter::_internal_mutable_elu_param() {
_has_bits_[1] |= 0x00000400u;
if (elu_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ELUParameter>(GetArenaForAllocation());
elu_param_ = p;
}
return elu_param_;
}
inline ::caffe::ELUParameter* LayerParameter::mutable_elu_param() {
::caffe::ELUParameter* _msg = _internal_mutable_elu_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.elu_param)
return _msg;
}
inline void LayerParameter::set_allocated_elu_param(::caffe::ELUParameter* elu_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete elu_param_;
}
if (elu_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ELUParameter>::GetOwningArena(elu_param);
if (message_arena != submessage_arena) {
elu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, elu_param, submessage_arena);
}
_has_bits_[1] |= 0x00000400u;
} else {
_has_bits_[1] &= ~0x00000400u;
}
elu_param_ = elu_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.elu_param)
}
// optional .caffe.EmbedParameter embed_param = 137;
inline bool LayerParameter::_internal_has_embed_param() const {
bool value = (_has_bits_[1] & 0x00000080u) != 0;
PROTOBUF_ASSUME(!value || embed_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_embed_param() const {
return _internal_has_embed_param();
}
inline void LayerParameter::clear_embed_param() {
if (embed_param_ != nullptr) embed_param_->Clear();
_has_bits_[1] &= ~0x00000080u;
}
inline const ::caffe::EmbedParameter& LayerParameter::_internal_embed_param() const {
const ::caffe::EmbedParameter* p = embed_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::EmbedParameter&>(
::caffe::_EmbedParameter_default_instance_);
}
inline const ::caffe::EmbedParameter& LayerParameter::embed_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.embed_param)
return _internal_embed_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_embed_param(
::caffe::EmbedParameter* embed_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(embed_param_);
}
embed_param_ = embed_param;
if (embed_param) {
_has_bits_[1] |= 0x00000080u;
} else {
_has_bits_[1] &= ~0x00000080u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.embed_param)
}
inline ::caffe::EmbedParameter* LayerParameter::release_embed_param() {
_has_bits_[1] &= ~0x00000080u;
::caffe::EmbedParameter* temp = embed_param_;
embed_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::EmbedParameter* LayerParameter::unsafe_arena_release_embed_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.embed_param)
_has_bits_[1] &= ~0x00000080u;
::caffe::EmbedParameter* temp = embed_param_;
embed_param_ = nullptr;
return temp;
}
inline ::caffe::EmbedParameter* LayerParameter::_internal_mutable_embed_param() {
_has_bits_[1] |= 0x00000080u;
if (embed_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::EmbedParameter>(GetArenaForAllocation());
embed_param_ = p;
}
return embed_param_;
}
inline ::caffe::EmbedParameter* LayerParameter::mutable_embed_param() {
::caffe::EmbedParameter* _msg = _internal_mutable_embed_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.embed_param)
return _msg;
}
inline void LayerParameter::set_allocated_embed_param(::caffe::EmbedParameter* embed_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete embed_param_;
}
if (embed_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::EmbedParameter>::GetOwningArena(embed_param);
if (message_arena != submessage_arena) {
embed_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, embed_param, submessage_arena);
}
_has_bits_[1] |= 0x00000080u;
} else {
_has_bits_[1] &= ~0x00000080u;
}
embed_param_ = embed_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.embed_param)
}
// optional .caffe.ExpParameter exp_param = 111;
inline bool LayerParameter::_internal_has_exp_param() const {
bool value = (_has_bits_[0] & 0x00002000u) != 0;
PROTOBUF_ASSUME(!value || exp_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_exp_param() const {
return _internal_has_exp_param();
}
inline void LayerParameter::clear_exp_param() {
if (exp_param_ != nullptr) exp_param_->Clear();
_has_bits_[0] &= ~0x00002000u;
}
inline const ::caffe::ExpParameter& LayerParameter::_internal_exp_param() const {
const ::caffe::ExpParameter* p = exp_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ExpParameter&>(
::caffe::_ExpParameter_default_instance_);
}
inline const ::caffe::ExpParameter& LayerParameter::exp_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.exp_param)
return _internal_exp_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_exp_param(
::caffe::ExpParameter* exp_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(exp_param_);
}
exp_param_ = exp_param;
if (exp_param) {
_has_bits_[0] |= 0x00002000u;
} else {
_has_bits_[0] &= ~0x00002000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.exp_param)
}
inline ::caffe::ExpParameter* LayerParameter::release_exp_param() {
_has_bits_[0] &= ~0x00002000u;
::caffe::ExpParameter* temp = exp_param_;
exp_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ExpParameter* LayerParameter::unsafe_arena_release_exp_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.exp_param)
_has_bits_[0] &= ~0x00002000u;
::caffe::ExpParameter* temp = exp_param_;
exp_param_ = nullptr;
return temp;
}
inline ::caffe::ExpParameter* LayerParameter::_internal_mutable_exp_param() {
_has_bits_[0] |= 0x00002000u;
if (exp_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ExpParameter>(GetArenaForAllocation());
exp_param_ = p;
}
return exp_param_;
}
inline ::caffe::ExpParameter* LayerParameter::mutable_exp_param() {
::caffe::ExpParameter* _msg = _internal_mutable_exp_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.exp_param)
return _msg;
}
inline void LayerParameter::set_allocated_exp_param(::caffe::ExpParameter* exp_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete exp_param_;
}
if (exp_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ExpParameter>::GetOwningArena(exp_param);
if (message_arena != submessage_arena) {
exp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, exp_param, submessage_arena);
}
_has_bits_[0] |= 0x00002000u;
} else {
_has_bits_[0] &= ~0x00002000u;
}
exp_param_ = exp_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.exp_param)
}
// optional .caffe.FlattenParameter flatten_param = 135;
inline bool LayerParameter::_internal_has_flatten_param() const {
bool value = (_has_bits_[1] & 0x00000020u) != 0;
PROTOBUF_ASSUME(!value || flatten_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_flatten_param() const {
return _internal_has_flatten_param();
}
inline void LayerParameter::clear_flatten_param() {
if (flatten_param_ != nullptr) flatten_param_->Clear();
_has_bits_[1] &= ~0x00000020u;
}
inline const ::caffe::FlattenParameter& LayerParameter::_internal_flatten_param() const {
const ::caffe::FlattenParameter* p = flatten_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FlattenParameter&>(
::caffe::_FlattenParameter_default_instance_);
}
inline const ::caffe::FlattenParameter& LayerParameter::flatten_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.flatten_param)
return _internal_flatten_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_flatten_param(
::caffe::FlattenParameter* flatten_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(flatten_param_);
}
flatten_param_ = flatten_param;
if (flatten_param) {
_has_bits_[1] |= 0x00000020u;
} else {
_has_bits_[1] &= ~0x00000020u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.flatten_param)
}
inline ::caffe::FlattenParameter* LayerParameter::release_flatten_param() {
_has_bits_[1] &= ~0x00000020u;
::caffe::FlattenParameter* temp = flatten_param_;
flatten_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FlattenParameter* LayerParameter::unsafe_arena_release_flatten_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.flatten_param)
_has_bits_[1] &= ~0x00000020u;
::caffe::FlattenParameter* temp = flatten_param_;
flatten_param_ = nullptr;
return temp;
}
inline ::caffe::FlattenParameter* LayerParameter::_internal_mutable_flatten_param() {
_has_bits_[1] |= 0x00000020u;
if (flatten_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FlattenParameter>(GetArenaForAllocation());
flatten_param_ = p;
}
return flatten_param_;
}
inline ::caffe::FlattenParameter* LayerParameter::mutable_flatten_param() {
::caffe::FlattenParameter* _msg = _internal_mutable_flatten_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.flatten_param)
return _msg;
}
inline void LayerParameter::set_allocated_flatten_param(::caffe::FlattenParameter* flatten_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete flatten_param_;
}
if (flatten_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FlattenParameter>::GetOwningArena(flatten_param);
if (message_arena != submessage_arena) {
flatten_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, flatten_param, submessage_arena);
}
_has_bits_[1] |= 0x00000020u;
} else {
_has_bits_[1] &= ~0x00000020u;
}
flatten_param_ = flatten_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.flatten_param)
}
// optional .caffe.HDF5DataParameter hdf5_data_param = 112;
inline bool LayerParameter::_internal_has_hdf5_data_param() const {
bool value = (_has_bits_[0] & 0x00004000u) != 0;
PROTOBUF_ASSUME(!value || hdf5_data_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_hdf5_data_param() const {
return _internal_has_hdf5_data_param();
}
inline void LayerParameter::clear_hdf5_data_param() {
if (hdf5_data_param_ != nullptr) hdf5_data_param_->Clear();
_has_bits_[0] &= ~0x00004000u;
}
inline const ::caffe::HDF5DataParameter& LayerParameter::_internal_hdf5_data_param() const {
const ::caffe::HDF5DataParameter* p = hdf5_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::HDF5DataParameter&>(
::caffe::_HDF5DataParameter_default_instance_);
}
inline const ::caffe::HDF5DataParameter& LayerParameter::hdf5_data_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.hdf5_data_param)
return _internal_hdf5_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_hdf5_data_param(
::caffe::HDF5DataParameter* hdf5_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_data_param_);
}
hdf5_data_param_ = hdf5_data_param;
if (hdf5_data_param) {
_has_bits_[0] |= 0x00004000u;
} else {
_has_bits_[0] &= ~0x00004000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.hdf5_data_param)
}
inline ::caffe::HDF5DataParameter* LayerParameter::release_hdf5_data_param() {
_has_bits_[0] &= ~0x00004000u;
::caffe::HDF5DataParameter* temp = hdf5_data_param_;
hdf5_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::HDF5DataParameter* LayerParameter::unsafe_arena_release_hdf5_data_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.hdf5_data_param)
_has_bits_[0] &= ~0x00004000u;
::caffe::HDF5DataParameter* temp = hdf5_data_param_;
hdf5_data_param_ = nullptr;
return temp;
}
inline ::caffe::HDF5DataParameter* LayerParameter::_internal_mutable_hdf5_data_param() {
_has_bits_[0] |= 0x00004000u;
if (hdf5_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::HDF5DataParameter>(GetArenaForAllocation());
hdf5_data_param_ = p;
}
return hdf5_data_param_;
}
inline ::caffe::HDF5DataParameter* LayerParameter::mutable_hdf5_data_param() {
::caffe::HDF5DataParameter* _msg = _internal_mutable_hdf5_data_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.hdf5_data_param)
return _msg;
}
inline void LayerParameter::set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete hdf5_data_param_;
}
if (hdf5_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::HDF5DataParameter>::GetOwningArena(hdf5_data_param);
if (message_arena != submessage_arena) {
hdf5_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, hdf5_data_param, submessage_arena);
}
_has_bits_[0] |= 0x00004000u;
} else {
_has_bits_[0] &= ~0x00004000u;
}
hdf5_data_param_ = hdf5_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.hdf5_data_param)
}
// optional .caffe.HDF5OutputParameter hdf5_output_param = 113;
inline bool LayerParameter::_internal_has_hdf5_output_param() const {
bool value = (_has_bits_[0] & 0x00008000u) != 0;
PROTOBUF_ASSUME(!value || hdf5_output_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_hdf5_output_param() const {
return _internal_has_hdf5_output_param();
}
inline void LayerParameter::clear_hdf5_output_param() {
if (hdf5_output_param_ != nullptr) hdf5_output_param_->Clear();
_has_bits_[0] &= ~0x00008000u;
}
inline const ::caffe::HDF5OutputParameter& LayerParameter::_internal_hdf5_output_param() const {
const ::caffe::HDF5OutputParameter* p = hdf5_output_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::HDF5OutputParameter&>(
::caffe::_HDF5OutputParameter_default_instance_);
}
inline const ::caffe::HDF5OutputParameter& LayerParameter::hdf5_output_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.hdf5_output_param)
return _internal_hdf5_output_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_hdf5_output_param(
::caffe::HDF5OutputParameter* hdf5_output_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_output_param_);
}
hdf5_output_param_ = hdf5_output_param;
if (hdf5_output_param) {
_has_bits_[0] |= 0x00008000u;
} else {
_has_bits_[0] &= ~0x00008000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.hdf5_output_param)
}
inline ::caffe::HDF5OutputParameter* LayerParameter::release_hdf5_output_param() {
_has_bits_[0] &= ~0x00008000u;
::caffe::HDF5OutputParameter* temp = hdf5_output_param_;
hdf5_output_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::HDF5OutputParameter* LayerParameter::unsafe_arena_release_hdf5_output_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.hdf5_output_param)
_has_bits_[0] &= ~0x00008000u;
::caffe::HDF5OutputParameter* temp = hdf5_output_param_;
hdf5_output_param_ = nullptr;
return temp;
}
inline ::caffe::HDF5OutputParameter* LayerParameter::_internal_mutable_hdf5_output_param() {
_has_bits_[0] |= 0x00008000u;
if (hdf5_output_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::HDF5OutputParameter>(GetArenaForAllocation());
hdf5_output_param_ = p;
}
return hdf5_output_param_;
}
inline ::caffe::HDF5OutputParameter* LayerParameter::mutable_hdf5_output_param() {
::caffe::HDF5OutputParameter* _msg = _internal_mutable_hdf5_output_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.hdf5_output_param)
return _msg;
}
inline void LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete hdf5_output_param_;
}
if (hdf5_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::HDF5OutputParameter>::GetOwningArena(hdf5_output_param);
if (message_arena != submessage_arena) {
hdf5_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, hdf5_output_param, submessage_arena);
}
_has_bits_[0] |= 0x00008000u;
} else {
_has_bits_[0] &= ~0x00008000u;
}
hdf5_output_param_ = hdf5_output_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.hdf5_output_param)
}
// optional .caffe.HingeLossParameter hinge_loss_param = 114;
inline bool LayerParameter::_internal_has_hinge_loss_param() const {
bool value = (_has_bits_[0] & 0x00010000u) != 0;
PROTOBUF_ASSUME(!value || hinge_loss_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_hinge_loss_param() const {
return _internal_has_hinge_loss_param();
}
inline void LayerParameter::clear_hinge_loss_param() {
if (hinge_loss_param_ != nullptr) hinge_loss_param_->Clear();
_has_bits_[0] &= ~0x00010000u;
}
inline const ::caffe::HingeLossParameter& LayerParameter::_internal_hinge_loss_param() const {
const ::caffe::HingeLossParameter* p = hinge_loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::HingeLossParameter&>(
::caffe::_HingeLossParameter_default_instance_);
}
inline const ::caffe::HingeLossParameter& LayerParameter::hinge_loss_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.hinge_loss_param)
return _internal_hinge_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_hinge_loss_param(
::caffe::HingeLossParameter* hinge_loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hinge_loss_param_);
}
hinge_loss_param_ = hinge_loss_param;
if (hinge_loss_param) {
_has_bits_[0] |= 0x00010000u;
} else {
_has_bits_[0] &= ~0x00010000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.hinge_loss_param)
}
inline ::caffe::HingeLossParameter* LayerParameter::release_hinge_loss_param() {
_has_bits_[0] &= ~0x00010000u;
::caffe::HingeLossParameter* temp = hinge_loss_param_;
hinge_loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::HingeLossParameter* LayerParameter::unsafe_arena_release_hinge_loss_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.hinge_loss_param)
_has_bits_[0] &= ~0x00010000u;
::caffe::HingeLossParameter* temp = hinge_loss_param_;
hinge_loss_param_ = nullptr;
return temp;
}
inline ::caffe::HingeLossParameter* LayerParameter::_internal_mutable_hinge_loss_param() {
_has_bits_[0] |= 0x00010000u;
if (hinge_loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::HingeLossParameter>(GetArenaForAllocation());
hinge_loss_param_ = p;
}
return hinge_loss_param_;
}
inline ::caffe::HingeLossParameter* LayerParameter::mutable_hinge_loss_param() {
::caffe::HingeLossParameter* _msg = _internal_mutable_hinge_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.hinge_loss_param)
return _msg;
}
inline void LayerParameter::set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete hinge_loss_param_;
}
if (hinge_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::HingeLossParameter>::GetOwningArena(hinge_loss_param);
if (message_arena != submessage_arena) {
hinge_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, hinge_loss_param, submessage_arena);
}
_has_bits_[0] |= 0x00010000u;
} else {
_has_bits_[0] &= ~0x00010000u;
}
hinge_loss_param_ = hinge_loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.hinge_loss_param)
}
// optional .caffe.ImageDataParameter image_data_param = 115;
inline bool LayerParameter::_internal_has_image_data_param() const {
bool value = (_has_bits_[0] & 0x00020000u) != 0;
PROTOBUF_ASSUME(!value || image_data_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_image_data_param() const {
return _internal_has_image_data_param();
}
inline void LayerParameter::clear_image_data_param() {
if (image_data_param_ != nullptr) image_data_param_->Clear();
_has_bits_[0] &= ~0x00020000u;
}
inline const ::caffe::ImageDataParameter& LayerParameter::_internal_image_data_param() const {
const ::caffe::ImageDataParameter* p = image_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ImageDataParameter&>(
::caffe::_ImageDataParameter_default_instance_);
}
inline const ::caffe::ImageDataParameter& LayerParameter::image_data_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.image_data_param)
return _internal_image_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_image_data_param(
::caffe::ImageDataParameter* image_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(image_data_param_);
}
image_data_param_ = image_data_param;
if (image_data_param) {
_has_bits_[0] |= 0x00020000u;
} else {
_has_bits_[0] &= ~0x00020000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.image_data_param)
}
inline ::caffe::ImageDataParameter* LayerParameter::release_image_data_param() {
_has_bits_[0] &= ~0x00020000u;
::caffe::ImageDataParameter* temp = image_data_param_;
image_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ImageDataParameter* LayerParameter::unsafe_arena_release_image_data_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.image_data_param)
_has_bits_[0] &= ~0x00020000u;
::caffe::ImageDataParameter* temp = image_data_param_;
image_data_param_ = nullptr;
return temp;
}
inline ::caffe::ImageDataParameter* LayerParameter::_internal_mutable_image_data_param() {
_has_bits_[0] |= 0x00020000u;
if (image_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ImageDataParameter>(GetArenaForAllocation());
image_data_param_ = p;
}
return image_data_param_;
}
inline ::caffe::ImageDataParameter* LayerParameter::mutable_image_data_param() {
::caffe::ImageDataParameter* _msg = _internal_mutable_image_data_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.image_data_param)
return _msg;
}
inline void LayerParameter::set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete image_data_param_;
}
if (image_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ImageDataParameter>::GetOwningArena(image_data_param);
if (message_arena != submessage_arena) {
image_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, image_data_param, submessage_arena);
}
_has_bits_[0] |= 0x00020000u;
} else {
_has_bits_[0] &= ~0x00020000u;
}
image_data_param_ = image_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.image_data_param)
}
// optional .caffe.InfogainLossParameter infogain_loss_param = 116;
inline bool LayerParameter::_internal_has_infogain_loss_param() const {
bool value = (_has_bits_[0] & 0x00040000u) != 0;
PROTOBUF_ASSUME(!value || infogain_loss_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_infogain_loss_param() const {
return _internal_has_infogain_loss_param();
}
inline void LayerParameter::clear_infogain_loss_param() {
if (infogain_loss_param_ != nullptr) infogain_loss_param_->Clear();
_has_bits_[0] &= ~0x00040000u;
}
inline const ::caffe::InfogainLossParameter& LayerParameter::_internal_infogain_loss_param() const {
const ::caffe::InfogainLossParameter* p = infogain_loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::InfogainLossParameter&>(
::caffe::_InfogainLossParameter_default_instance_);
}
inline const ::caffe::InfogainLossParameter& LayerParameter::infogain_loss_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.infogain_loss_param)
return _internal_infogain_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_infogain_loss_param(
::caffe::InfogainLossParameter* infogain_loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(infogain_loss_param_);
}
infogain_loss_param_ = infogain_loss_param;
if (infogain_loss_param) {
_has_bits_[0] |= 0x00040000u;
} else {
_has_bits_[0] &= ~0x00040000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.infogain_loss_param)
}
inline ::caffe::InfogainLossParameter* LayerParameter::release_infogain_loss_param() {
_has_bits_[0] &= ~0x00040000u;
::caffe::InfogainLossParameter* temp = infogain_loss_param_;
infogain_loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::InfogainLossParameter* LayerParameter::unsafe_arena_release_infogain_loss_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.infogain_loss_param)
_has_bits_[0] &= ~0x00040000u;
::caffe::InfogainLossParameter* temp = infogain_loss_param_;
infogain_loss_param_ = nullptr;
return temp;
}
inline ::caffe::InfogainLossParameter* LayerParameter::_internal_mutable_infogain_loss_param() {
_has_bits_[0] |= 0x00040000u;
if (infogain_loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::InfogainLossParameter>(GetArenaForAllocation());
infogain_loss_param_ = p;
}
return infogain_loss_param_;
}
inline ::caffe::InfogainLossParameter* LayerParameter::mutable_infogain_loss_param() {
::caffe::InfogainLossParameter* _msg = _internal_mutable_infogain_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.infogain_loss_param)
return _msg;
}
inline void LayerParameter::set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete infogain_loss_param_;
}
if (infogain_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::InfogainLossParameter>::GetOwningArena(infogain_loss_param);
if (message_arena != submessage_arena) {
infogain_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, infogain_loss_param, submessage_arena);
}
_has_bits_[0] |= 0x00040000u;
} else {
_has_bits_[0] &= ~0x00040000u;
}
infogain_loss_param_ = infogain_loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.infogain_loss_param)
}
// optional .caffe.InnerProductParameter inner_product_param = 117;
inline bool LayerParameter::_internal_has_inner_product_param() const {
bool value = (_has_bits_[0] & 0x00080000u) != 0;
PROTOBUF_ASSUME(!value || inner_product_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_inner_product_param() const {
return _internal_has_inner_product_param();
}
inline void LayerParameter::clear_inner_product_param() {
if (inner_product_param_ != nullptr) inner_product_param_->Clear();
_has_bits_[0] &= ~0x00080000u;
}
inline const ::caffe::InnerProductParameter& LayerParameter::_internal_inner_product_param() const {
const ::caffe::InnerProductParameter* p = inner_product_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::InnerProductParameter&>(
::caffe::_InnerProductParameter_default_instance_);
}
inline const ::caffe::InnerProductParameter& LayerParameter::inner_product_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.inner_product_param)
return _internal_inner_product_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_inner_product_param(
::caffe::InnerProductParameter* inner_product_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(inner_product_param_);
}
inner_product_param_ = inner_product_param;
if (inner_product_param) {
_has_bits_[0] |= 0x00080000u;
} else {
_has_bits_[0] &= ~0x00080000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.inner_product_param)
}
inline ::caffe::InnerProductParameter* LayerParameter::release_inner_product_param() {
_has_bits_[0] &= ~0x00080000u;
::caffe::InnerProductParameter* temp = inner_product_param_;
inner_product_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::InnerProductParameter* LayerParameter::unsafe_arena_release_inner_product_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.inner_product_param)
_has_bits_[0] &= ~0x00080000u;
::caffe::InnerProductParameter* temp = inner_product_param_;
inner_product_param_ = nullptr;
return temp;
}
inline ::caffe::InnerProductParameter* LayerParameter::_internal_mutable_inner_product_param() {
_has_bits_[0] |= 0x00080000u;
if (inner_product_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::InnerProductParameter>(GetArenaForAllocation());
inner_product_param_ = p;
}
return inner_product_param_;
}
inline ::caffe::InnerProductParameter* LayerParameter::mutable_inner_product_param() {
::caffe::InnerProductParameter* _msg = _internal_mutable_inner_product_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.inner_product_param)
return _msg;
}
inline void LayerParameter::set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete inner_product_param_;
}
if (inner_product_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::InnerProductParameter>::GetOwningArena(inner_product_param);
if (message_arena != submessage_arena) {
inner_product_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, inner_product_param, submessage_arena);
}
_has_bits_[0] |= 0x00080000u;
} else {
_has_bits_[0] &= ~0x00080000u;
}
inner_product_param_ = inner_product_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.inner_product_param)
}
// optional .caffe.InputParameter input_param = 143;
inline bool LayerParameter::_internal_has_input_param() const {
bool value = (_has_bits_[1] & 0x00002000u) != 0;
PROTOBUF_ASSUME(!value || input_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_input_param() const {
return _internal_has_input_param();
}
inline void LayerParameter::clear_input_param() {
if (input_param_ != nullptr) input_param_->Clear();
_has_bits_[1] &= ~0x00002000u;
}
inline const ::caffe::InputParameter& LayerParameter::_internal_input_param() const {
const ::caffe::InputParameter* p = input_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::InputParameter&>(
::caffe::_InputParameter_default_instance_);
}
inline const ::caffe::InputParameter& LayerParameter::input_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.input_param)
return _internal_input_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_input_param(
::caffe::InputParameter* input_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_param_);
}
input_param_ = input_param;
if (input_param) {
_has_bits_[1] |= 0x00002000u;
} else {
_has_bits_[1] &= ~0x00002000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.input_param)
}
inline ::caffe::InputParameter* LayerParameter::release_input_param() {
_has_bits_[1] &= ~0x00002000u;
::caffe::InputParameter* temp = input_param_;
input_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::InputParameter* LayerParameter::unsafe_arena_release_input_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.input_param)
_has_bits_[1] &= ~0x00002000u;
::caffe::InputParameter* temp = input_param_;
input_param_ = nullptr;
return temp;
}
inline ::caffe::InputParameter* LayerParameter::_internal_mutable_input_param() {
_has_bits_[1] |= 0x00002000u;
if (input_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::InputParameter>(GetArenaForAllocation());
input_param_ = p;
}
return input_param_;
}
inline ::caffe::InputParameter* LayerParameter::mutable_input_param() {
::caffe::InputParameter* _msg = _internal_mutable_input_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.input_param)
return _msg;
}
inline void LayerParameter::set_allocated_input_param(::caffe::InputParameter* input_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete input_param_;
}
if (input_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::InputParameter>::GetOwningArena(input_param);
if (message_arena != submessage_arena) {
input_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, input_param, submessage_arena);
}
_has_bits_[1] |= 0x00002000u;
} else {
_has_bits_[1] &= ~0x00002000u;
}
input_param_ = input_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.input_param)
}
// optional .caffe.LogParameter log_param = 134;
inline bool LayerParameter::_internal_has_log_param() const {
bool value = (_has_bits_[1] & 0x00000010u) != 0;
PROTOBUF_ASSUME(!value || log_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_log_param() const {
return _internal_has_log_param();
}
inline void LayerParameter::clear_log_param() {
if (log_param_ != nullptr) log_param_->Clear();
_has_bits_[1] &= ~0x00000010u;
}
inline const ::caffe::LogParameter& LayerParameter::_internal_log_param() const {
const ::caffe::LogParameter* p = log_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::LogParameter&>(
::caffe::_LogParameter_default_instance_);
}
inline const ::caffe::LogParameter& LayerParameter::log_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.log_param)
return _internal_log_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_log_param(
::caffe::LogParameter* log_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(log_param_);
}
log_param_ = log_param;
if (log_param) {
_has_bits_[1] |= 0x00000010u;
} else {
_has_bits_[1] &= ~0x00000010u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.log_param)
}
inline ::caffe::LogParameter* LayerParameter::release_log_param() {
_has_bits_[1] &= ~0x00000010u;
::caffe::LogParameter* temp = log_param_;
log_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::LogParameter* LayerParameter::unsafe_arena_release_log_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.log_param)
_has_bits_[1] &= ~0x00000010u;
::caffe::LogParameter* temp = log_param_;
log_param_ = nullptr;
return temp;
}
inline ::caffe::LogParameter* LayerParameter::_internal_mutable_log_param() {
_has_bits_[1] |= 0x00000010u;
if (log_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::LogParameter>(GetArenaForAllocation());
log_param_ = p;
}
return log_param_;
}
inline ::caffe::LogParameter* LayerParameter::mutable_log_param() {
::caffe::LogParameter* _msg = _internal_mutable_log_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.log_param)
return _msg;
}
inline void LayerParameter::set_allocated_log_param(::caffe::LogParameter* log_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete log_param_;
}
if (log_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::LogParameter>::GetOwningArena(log_param);
if (message_arena != submessage_arena) {
log_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, log_param, submessage_arena);
}
_has_bits_[1] |= 0x00000010u;
} else {
_has_bits_[1] &= ~0x00000010u;
}
log_param_ = log_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.log_param)
}
// optional .caffe.LRNParameter lrn_param = 118;
inline bool LayerParameter::_internal_has_lrn_param() const {
bool value = (_has_bits_[0] & 0x00100000u) != 0;
PROTOBUF_ASSUME(!value || lrn_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_lrn_param() const {
return _internal_has_lrn_param();
}
inline void LayerParameter::clear_lrn_param() {
if (lrn_param_ != nullptr) lrn_param_->Clear();
_has_bits_[0] &= ~0x00100000u;
}
inline const ::caffe::LRNParameter& LayerParameter::_internal_lrn_param() const {
const ::caffe::LRNParameter* p = lrn_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::LRNParameter&>(
::caffe::_LRNParameter_default_instance_);
}
inline const ::caffe::LRNParameter& LayerParameter::lrn_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.lrn_param)
return _internal_lrn_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_lrn_param(
::caffe::LRNParameter* lrn_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lrn_param_);
}
lrn_param_ = lrn_param;
if (lrn_param) {
_has_bits_[0] |= 0x00100000u;
} else {
_has_bits_[0] &= ~0x00100000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.lrn_param)
}
inline ::caffe::LRNParameter* LayerParameter::release_lrn_param() {
_has_bits_[0] &= ~0x00100000u;
::caffe::LRNParameter* temp = lrn_param_;
lrn_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::LRNParameter* LayerParameter::unsafe_arena_release_lrn_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.lrn_param)
_has_bits_[0] &= ~0x00100000u;
::caffe::LRNParameter* temp = lrn_param_;
lrn_param_ = nullptr;
return temp;
}
inline ::caffe::LRNParameter* LayerParameter::_internal_mutable_lrn_param() {
_has_bits_[0] |= 0x00100000u;
if (lrn_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::LRNParameter>(GetArenaForAllocation());
lrn_param_ = p;
}
return lrn_param_;
}
inline ::caffe::LRNParameter* LayerParameter::mutable_lrn_param() {
::caffe::LRNParameter* _msg = _internal_mutable_lrn_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.lrn_param)
return _msg;
}
inline void LayerParameter::set_allocated_lrn_param(::caffe::LRNParameter* lrn_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete lrn_param_;
}
if (lrn_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::LRNParameter>::GetOwningArena(lrn_param);
if (message_arena != submessage_arena) {
lrn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, lrn_param, submessage_arena);
}
_has_bits_[0] |= 0x00100000u;
} else {
_has_bits_[0] &= ~0x00100000u;
}
lrn_param_ = lrn_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.lrn_param)
}
// optional .caffe.LSTMParameter lstm_param = 210;
inline bool LayerParameter::_internal_has_lstm_param() const {
bool value = (_has_bits_[1] & 0x20000000u) != 0;
PROTOBUF_ASSUME(!value || lstm_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_lstm_param() const {
return _internal_has_lstm_param();
}
inline void LayerParameter::clear_lstm_param() {
if (lstm_param_ != nullptr) lstm_param_->Clear();
_has_bits_[1] &= ~0x20000000u;
}
inline const ::caffe::LSTMParameter& LayerParameter::_internal_lstm_param() const {
const ::caffe::LSTMParameter* p = lstm_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::LSTMParameter&>(
::caffe::_LSTMParameter_default_instance_);
}
inline const ::caffe::LSTMParameter& LayerParameter::lstm_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.lstm_param)
return _internal_lstm_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_lstm_param(
::caffe::LSTMParameter* lstm_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lstm_param_);
}
lstm_param_ = lstm_param;
if (lstm_param) {
_has_bits_[1] |= 0x20000000u;
} else {
_has_bits_[1] &= ~0x20000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.lstm_param)
}
inline ::caffe::LSTMParameter* LayerParameter::release_lstm_param() {
_has_bits_[1] &= ~0x20000000u;
::caffe::LSTMParameter* temp = lstm_param_;
lstm_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::LSTMParameter* LayerParameter::unsafe_arena_release_lstm_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.lstm_param)
_has_bits_[1] &= ~0x20000000u;
::caffe::LSTMParameter* temp = lstm_param_;
lstm_param_ = nullptr;
return temp;
}
inline ::caffe::LSTMParameter* LayerParameter::_internal_mutable_lstm_param() {
_has_bits_[1] |= 0x20000000u;
if (lstm_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::LSTMParameter>(GetArenaForAllocation());
lstm_param_ = p;
}
return lstm_param_;
}
inline ::caffe::LSTMParameter* LayerParameter::mutable_lstm_param() {
::caffe::LSTMParameter* _msg = _internal_mutable_lstm_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.lstm_param)
return _msg;
}
inline void LayerParameter::set_allocated_lstm_param(::caffe::LSTMParameter* lstm_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete lstm_param_;
}
if (lstm_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::LSTMParameter>::GetOwningArena(lstm_param);
if (message_arena != submessage_arena) {
lstm_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, lstm_param, submessage_arena);
}
_has_bits_[1] |= 0x20000000u;
} else {
_has_bits_[1] &= ~0x20000000u;
}
lstm_param_ = lstm_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.lstm_param)
}
// optional .caffe.Im2seqParameter im2seq_param = 207;
inline bool LayerParameter::_internal_has_im2seq_param() const {
bool value = (_has_bits_[1] & 0x04000000u) != 0;
PROTOBUF_ASSUME(!value || im2seq_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_im2seq_param() const {
return _internal_has_im2seq_param();
}
inline void LayerParameter::clear_im2seq_param() {
if (im2seq_param_ != nullptr) im2seq_param_->Clear();
_has_bits_[1] &= ~0x04000000u;
}
inline const ::caffe::Im2seqParameter& LayerParameter::_internal_im2seq_param() const {
const ::caffe::Im2seqParameter* p = im2seq_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::Im2seqParameter&>(
::caffe::_Im2seqParameter_default_instance_);
}
inline const ::caffe::Im2seqParameter& LayerParameter::im2seq_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.im2seq_param)
return _internal_im2seq_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_im2seq_param(
::caffe::Im2seqParameter* im2seq_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(im2seq_param_);
}
im2seq_param_ = im2seq_param;
if (im2seq_param) {
_has_bits_[1] |= 0x04000000u;
} else {
_has_bits_[1] &= ~0x04000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.im2seq_param)
}
inline ::caffe::Im2seqParameter* LayerParameter::release_im2seq_param() {
_has_bits_[1] &= ~0x04000000u;
::caffe::Im2seqParameter* temp = im2seq_param_;
im2seq_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::Im2seqParameter* LayerParameter::unsafe_arena_release_im2seq_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.im2seq_param)
_has_bits_[1] &= ~0x04000000u;
::caffe::Im2seqParameter* temp = im2seq_param_;
im2seq_param_ = nullptr;
return temp;
}
inline ::caffe::Im2seqParameter* LayerParameter::_internal_mutable_im2seq_param() {
_has_bits_[1] |= 0x04000000u;
if (im2seq_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::Im2seqParameter>(GetArenaForAllocation());
im2seq_param_ = p;
}
return im2seq_param_;
}
inline ::caffe::Im2seqParameter* LayerParameter::mutable_im2seq_param() {
::caffe::Im2seqParameter* _msg = _internal_mutable_im2seq_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.im2seq_param)
return _msg;
}
inline void LayerParameter::set_allocated_im2seq_param(::caffe::Im2seqParameter* im2seq_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete im2seq_param_;
}
if (im2seq_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::Im2seqParameter>::GetOwningArena(im2seq_param);
if (message_arena != submessage_arena) {
im2seq_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, im2seq_param, submessage_arena);
}
_has_bits_[1] |= 0x04000000u;
} else {
_has_bits_[1] &= ~0x04000000u;
}
im2seq_param_ = im2seq_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.im2seq_param)
}
// optional .caffe.Seq2outParameter seq2out_param = 208;
inline bool LayerParameter::_internal_has_seq2out_param() const {
bool value = (_has_bits_[1] & 0x08000000u) != 0;
PROTOBUF_ASSUME(!value || seq2out_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_seq2out_param() const {
return _internal_has_seq2out_param();
}
inline void LayerParameter::clear_seq2out_param() {
if (seq2out_param_ != nullptr) seq2out_param_->Clear();
_has_bits_[1] &= ~0x08000000u;
}
inline const ::caffe::Seq2outParameter& LayerParameter::_internal_seq2out_param() const {
const ::caffe::Seq2outParameter* p = seq2out_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::Seq2outParameter&>(
::caffe::_Seq2outParameter_default_instance_);
}
inline const ::caffe::Seq2outParameter& LayerParameter::seq2out_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.seq2out_param)
return _internal_seq2out_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_seq2out_param(
::caffe::Seq2outParameter* seq2out_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(seq2out_param_);
}
seq2out_param_ = seq2out_param;
if (seq2out_param) {
_has_bits_[1] |= 0x08000000u;
} else {
_has_bits_[1] &= ~0x08000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.seq2out_param)
}
inline ::caffe::Seq2outParameter* LayerParameter::release_seq2out_param() {
_has_bits_[1] &= ~0x08000000u;
::caffe::Seq2outParameter* temp = seq2out_param_;
seq2out_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::Seq2outParameter* LayerParameter::unsafe_arena_release_seq2out_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.seq2out_param)
_has_bits_[1] &= ~0x08000000u;
::caffe::Seq2outParameter* temp = seq2out_param_;
seq2out_param_ = nullptr;
return temp;
}
inline ::caffe::Seq2outParameter* LayerParameter::_internal_mutable_seq2out_param() {
_has_bits_[1] |= 0x08000000u;
if (seq2out_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::Seq2outParameter>(GetArenaForAllocation());
seq2out_param_ = p;
}
return seq2out_param_;
}
inline ::caffe::Seq2outParameter* LayerParameter::mutable_seq2out_param() {
::caffe::Seq2outParameter* _msg = _internal_mutable_seq2out_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.seq2out_param)
return _msg;
}
inline void LayerParameter::set_allocated_seq2out_param(::caffe::Seq2outParameter* seq2out_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete seq2out_param_;
}
if (seq2out_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::Seq2outParameter>::GetOwningArena(seq2out_param);
if (message_arena != submessage_arena) {
seq2out_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, seq2out_param, submessage_arena);
}
_has_bits_[1] |= 0x08000000u;
} else {
_has_bits_[1] &= ~0x08000000u;
}
seq2out_param_ = seq2out_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.seq2out_param)
}
// optional .caffe.ImgSizeParameter img_size_param = 209;
inline bool LayerParameter::_internal_has_img_size_param() const {
bool value = (_has_bits_[1] & 0x10000000u) != 0;
PROTOBUF_ASSUME(!value || img_size_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_img_size_param() const {
return _internal_has_img_size_param();
}
inline void LayerParameter::clear_img_size_param() {
if (img_size_param_ != nullptr) img_size_param_->Clear();
_has_bits_[1] &= ~0x10000000u;
}
inline const ::caffe::ImgSizeParameter& LayerParameter::_internal_img_size_param() const {
const ::caffe::ImgSizeParameter* p = img_size_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ImgSizeParameter&>(
::caffe::_ImgSizeParameter_default_instance_);
}
inline const ::caffe::ImgSizeParameter& LayerParameter::img_size_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.img_size_param)
return _internal_img_size_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_img_size_param(
::caffe::ImgSizeParameter* img_size_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(img_size_param_);
}
img_size_param_ = img_size_param;
if (img_size_param) {
_has_bits_[1] |= 0x10000000u;
} else {
_has_bits_[1] &= ~0x10000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.img_size_param)
}
inline ::caffe::ImgSizeParameter* LayerParameter::release_img_size_param() {
_has_bits_[1] &= ~0x10000000u;
::caffe::ImgSizeParameter* temp = img_size_param_;
img_size_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ImgSizeParameter* LayerParameter::unsafe_arena_release_img_size_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.img_size_param)
_has_bits_[1] &= ~0x10000000u;
::caffe::ImgSizeParameter* temp = img_size_param_;
img_size_param_ = nullptr;
return temp;
}
inline ::caffe::ImgSizeParameter* LayerParameter::_internal_mutable_img_size_param() {
_has_bits_[1] |= 0x10000000u;
if (img_size_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ImgSizeParameter>(GetArenaForAllocation());
img_size_param_ = p;
}
return img_size_param_;
}
inline ::caffe::ImgSizeParameter* LayerParameter::mutable_img_size_param() {
::caffe::ImgSizeParameter* _msg = _internal_mutable_img_size_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.img_size_param)
return _msg;
}
inline void LayerParameter::set_allocated_img_size_param(::caffe::ImgSizeParameter* img_size_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete img_size_param_;
}
if (img_size_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ImgSizeParameter>::GetOwningArena(img_size_param);
if (message_arena != submessage_arena) {
img_size_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, img_size_param, submessage_arena);
}
_has_bits_[1] |= 0x10000000u;
} else {
_has_bits_[1] &= ~0x10000000u;
}
img_size_param_ = img_size_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.img_size_param)
}
// optional .caffe.MemoryDataParameter memory_data_param = 119;
inline bool LayerParameter::_internal_has_memory_data_param() const {
bool value = (_has_bits_[0] & 0x00200000u) != 0;
PROTOBUF_ASSUME(!value || memory_data_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_memory_data_param() const {
return _internal_has_memory_data_param();
}
inline void LayerParameter::clear_memory_data_param() {
if (memory_data_param_ != nullptr) memory_data_param_->Clear();
_has_bits_[0] &= ~0x00200000u;
}
inline const ::caffe::MemoryDataParameter& LayerParameter::_internal_memory_data_param() const {
const ::caffe::MemoryDataParameter* p = memory_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::MemoryDataParameter&>(
::caffe::_MemoryDataParameter_default_instance_);
}
inline const ::caffe::MemoryDataParameter& LayerParameter::memory_data_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.memory_data_param)
return _internal_memory_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_memory_data_param(
::caffe::MemoryDataParameter* memory_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(memory_data_param_);
}
memory_data_param_ = memory_data_param;
if (memory_data_param) {
_has_bits_[0] |= 0x00200000u;
} else {
_has_bits_[0] &= ~0x00200000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.memory_data_param)
}
inline ::caffe::MemoryDataParameter* LayerParameter::release_memory_data_param() {
_has_bits_[0] &= ~0x00200000u;
::caffe::MemoryDataParameter* temp = memory_data_param_;
memory_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::MemoryDataParameter* LayerParameter::unsafe_arena_release_memory_data_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.memory_data_param)
_has_bits_[0] &= ~0x00200000u;
::caffe::MemoryDataParameter* temp = memory_data_param_;
memory_data_param_ = nullptr;
return temp;
}
inline ::caffe::MemoryDataParameter* LayerParameter::_internal_mutable_memory_data_param() {
_has_bits_[0] |= 0x00200000u;
if (memory_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::MemoryDataParameter>(GetArenaForAllocation());
memory_data_param_ = p;
}
return memory_data_param_;
}
inline ::caffe::MemoryDataParameter* LayerParameter::mutable_memory_data_param() {
::caffe::MemoryDataParameter* _msg = _internal_mutable_memory_data_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.memory_data_param)
return _msg;
}
inline void LayerParameter::set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete memory_data_param_;
}
if (memory_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::MemoryDataParameter>::GetOwningArena(memory_data_param);
if (message_arena != submessage_arena) {
memory_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, memory_data_param, submessage_arena);
}
_has_bits_[0] |= 0x00200000u;
} else {
_has_bits_[0] &= ~0x00200000u;
}
memory_data_param_ = memory_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.memory_data_param)
}
// optional .caffe.MultiBoxLossParameter multibox_loss_param = 201;
inline bool LayerParameter::_internal_has_multibox_loss_param() const {
bool value = (_has_bits_[1] & 0x00100000u) != 0;
PROTOBUF_ASSUME(!value || multibox_loss_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_multibox_loss_param() const {
return _internal_has_multibox_loss_param();
}
inline void LayerParameter::clear_multibox_loss_param() {
if (multibox_loss_param_ != nullptr) multibox_loss_param_->Clear();
_has_bits_[1] &= ~0x00100000u;
}
inline const ::caffe::MultiBoxLossParameter& LayerParameter::_internal_multibox_loss_param() const {
const ::caffe::MultiBoxLossParameter* p = multibox_loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::MultiBoxLossParameter&>(
::caffe::_MultiBoxLossParameter_default_instance_);
}
inline const ::caffe::MultiBoxLossParameter& LayerParameter::multibox_loss_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.multibox_loss_param)
return _internal_multibox_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_multibox_loss_param(
::caffe::MultiBoxLossParameter* multibox_loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(multibox_loss_param_);
}
multibox_loss_param_ = multibox_loss_param;
if (multibox_loss_param) {
_has_bits_[1] |= 0x00100000u;
} else {
_has_bits_[1] &= ~0x00100000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.multibox_loss_param)
}
inline ::caffe::MultiBoxLossParameter* LayerParameter::release_multibox_loss_param() {
_has_bits_[1] &= ~0x00100000u;
::caffe::MultiBoxLossParameter* temp = multibox_loss_param_;
multibox_loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::MultiBoxLossParameter* LayerParameter::unsafe_arena_release_multibox_loss_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.multibox_loss_param)
_has_bits_[1] &= ~0x00100000u;
::caffe::MultiBoxLossParameter* temp = multibox_loss_param_;
multibox_loss_param_ = nullptr;
return temp;
}
inline ::caffe::MultiBoxLossParameter* LayerParameter::_internal_mutable_multibox_loss_param() {
_has_bits_[1] |= 0x00100000u;
if (multibox_loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::MultiBoxLossParameter>(GetArenaForAllocation());
multibox_loss_param_ = p;
}
return multibox_loss_param_;
}
inline ::caffe::MultiBoxLossParameter* LayerParameter::mutable_multibox_loss_param() {
::caffe::MultiBoxLossParameter* _msg = _internal_mutable_multibox_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.multibox_loss_param)
return _msg;
}
inline void LayerParameter::set_allocated_multibox_loss_param(::caffe::MultiBoxLossParameter* multibox_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete multibox_loss_param_;
}
if (multibox_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::MultiBoxLossParameter>::GetOwningArena(multibox_loss_param);
if (message_arena != submessage_arena) {
multibox_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, multibox_loss_param, submessage_arena);
}
_has_bits_[1] |= 0x00100000u;
} else {
_has_bits_[1] &= ~0x00100000u;
}
multibox_loss_param_ = multibox_loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.multibox_loss_param)
}
// optional .caffe.MVNParameter mvn_param = 120;
inline bool LayerParameter::_internal_has_mvn_param() const {
bool value = (_has_bits_[0] & 0x00400000u) != 0;
PROTOBUF_ASSUME(!value || mvn_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_mvn_param() const {
return _internal_has_mvn_param();
}
inline void LayerParameter::clear_mvn_param() {
if (mvn_param_ != nullptr) mvn_param_->Clear();
_has_bits_[0] &= ~0x00400000u;
}
inline const ::caffe::MVNParameter& LayerParameter::_internal_mvn_param() const {
const ::caffe::MVNParameter* p = mvn_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::MVNParameter&>(
::caffe::_MVNParameter_default_instance_);
}
inline const ::caffe::MVNParameter& LayerParameter::mvn_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.mvn_param)
return _internal_mvn_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_mvn_param(
::caffe::MVNParameter* mvn_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mvn_param_);
}
mvn_param_ = mvn_param;
if (mvn_param) {
_has_bits_[0] |= 0x00400000u;
} else {
_has_bits_[0] &= ~0x00400000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.mvn_param)
}
inline ::caffe::MVNParameter* LayerParameter::release_mvn_param() {
_has_bits_[0] &= ~0x00400000u;
::caffe::MVNParameter* temp = mvn_param_;
mvn_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::MVNParameter* LayerParameter::unsafe_arena_release_mvn_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.mvn_param)
_has_bits_[0] &= ~0x00400000u;
::caffe::MVNParameter* temp = mvn_param_;
mvn_param_ = nullptr;
return temp;
}
inline ::caffe::MVNParameter* LayerParameter::_internal_mutable_mvn_param() {
_has_bits_[0] |= 0x00400000u;
if (mvn_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::MVNParameter>(GetArenaForAllocation());
mvn_param_ = p;
}
return mvn_param_;
}
inline ::caffe::MVNParameter* LayerParameter::mutable_mvn_param() {
::caffe::MVNParameter* _msg = _internal_mutable_mvn_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.mvn_param)
return _msg;
}
inline void LayerParameter::set_allocated_mvn_param(::caffe::MVNParameter* mvn_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete mvn_param_;
}
if (mvn_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::MVNParameter>::GetOwningArena(mvn_param);
if (message_arena != submessage_arena) {
mvn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, mvn_param, submessage_arena);
}
_has_bits_[0] |= 0x00400000u;
} else {
_has_bits_[0] &= ~0x00400000u;
}
mvn_param_ = mvn_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.mvn_param)
}
// optional .caffe.NormalizeParameter norm_param = 206;
inline bool LayerParameter::_internal_has_norm_param() const {
bool value = (_has_bits_[1] & 0x02000000u) != 0;
PROTOBUF_ASSUME(!value || norm_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_norm_param() const {
return _internal_has_norm_param();
}
inline void LayerParameter::clear_norm_param() {
if (norm_param_ != nullptr) norm_param_->Clear();
_has_bits_[1] &= ~0x02000000u;
}
inline const ::caffe::NormalizeParameter& LayerParameter::_internal_norm_param() const {
const ::caffe::NormalizeParameter* p = norm_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::NormalizeParameter&>(
::caffe::_NormalizeParameter_default_instance_);
}
inline const ::caffe::NormalizeParameter& LayerParameter::norm_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.norm_param)
return _internal_norm_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_norm_param(
::caffe::NormalizeParameter* norm_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(norm_param_);
}
norm_param_ = norm_param;
if (norm_param) {
_has_bits_[1] |= 0x02000000u;
} else {
_has_bits_[1] &= ~0x02000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.norm_param)
}
inline ::caffe::NormalizeParameter* LayerParameter::release_norm_param() {
_has_bits_[1] &= ~0x02000000u;
::caffe::NormalizeParameter* temp = norm_param_;
norm_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::NormalizeParameter* LayerParameter::unsafe_arena_release_norm_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.norm_param)
_has_bits_[1] &= ~0x02000000u;
::caffe::NormalizeParameter* temp = norm_param_;
norm_param_ = nullptr;
return temp;
}
inline ::caffe::NormalizeParameter* LayerParameter::_internal_mutable_norm_param() {
_has_bits_[1] |= 0x02000000u;
if (norm_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::NormalizeParameter>(GetArenaForAllocation());
norm_param_ = p;
}
return norm_param_;
}
inline ::caffe::NormalizeParameter* LayerParameter::mutable_norm_param() {
::caffe::NormalizeParameter* _msg = _internal_mutable_norm_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.norm_param)
return _msg;
}
inline void LayerParameter::set_allocated_norm_param(::caffe::NormalizeParameter* norm_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete norm_param_;
}
if (norm_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::NormalizeParameter>::GetOwningArena(norm_param);
if (message_arena != submessage_arena) {
norm_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, norm_param, submessage_arena);
}
_has_bits_[1] |= 0x02000000u;
} else {
_has_bits_[1] &= ~0x02000000u;
}
norm_param_ = norm_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.norm_param)
}
// optional .caffe.ParameterParameter parameter_param = 145;
inline bool LayerParameter::_internal_has_parameter_param() const {
bool value = (_has_bits_[1] & 0x00008000u) != 0;
PROTOBUF_ASSUME(!value || parameter_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_parameter_param() const {
return _internal_has_parameter_param();
}
inline void LayerParameter::clear_parameter_param() {
if (parameter_param_ != nullptr) parameter_param_->Clear();
_has_bits_[1] &= ~0x00008000u;
}
inline const ::caffe::ParameterParameter& LayerParameter::_internal_parameter_param() const {
const ::caffe::ParameterParameter* p = parameter_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ParameterParameter&>(
::caffe::_ParameterParameter_default_instance_);
}
inline const ::caffe::ParameterParameter& LayerParameter::parameter_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.parameter_param)
return _internal_parameter_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_parameter_param(
::caffe::ParameterParameter* parameter_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameter_param_);
}
parameter_param_ = parameter_param;
if (parameter_param) {
_has_bits_[1] |= 0x00008000u;
} else {
_has_bits_[1] &= ~0x00008000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.parameter_param)
}
inline ::caffe::ParameterParameter* LayerParameter::release_parameter_param() {
_has_bits_[1] &= ~0x00008000u;
::caffe::ParameterParameter* temp = parameter_param_;
parameter_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ParameterParameter* LayerParameter::unsafe_arena_release_parameter_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.parameter_param)
_has_bits_[1] &= ~0x00008000u;
::caffe::ParameterParameter* temp = parameter_param_;
parameter_param_ = nullptr;
return temp;
}
inline ::caffe::ParameterParameter* LayerParameter::_internal_mutable_parameter_param() {
_has_bits_[1] |= 0x00008000u;
if (parameter_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ParameterParameter>(GetArenaForAllocation());
parameter_param_ = p;
}
return parameter_param_;
}
inline ::caffe::ParameterParameter* LayerParameter::mutable_parameter_param() {
::caffe::ParameterParameter* _msg = _internal_mutable_parameter_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.parameter_param)
return _msg;
}
inline void LayerParameter::set_allocated_parameter_param(::caffe::ParameterParameter* parameter_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete parameter_param_;
}
if (parameter_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ParameterParameter>::GetOwningArena(parameter_param);
if (message_arena != submessage_arena) {
parameter_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, parameter_param, submessage_arena);
}
_has_bits_[1] |= 0x00008000u;
} else {
_has_bits_[1] &= ~0x00008000u;
}
parameter_param_ = parameter_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.parameter_param)
}
// optional .caffe.PermuteParameter permute_param = 202;
inline bool LayerParameter::_internal_has_permute_param() const {
bool value = (_has_bits_[1] & 0x00200000u) != 0;
PROTOBUF_ASSUME(!value || permute_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_permute_param() const {
return _internal_has_permute_param();
}
inline void LayerParameter::clear_permute_param() {
if (permute_param_ != nullptr) permute_param_->Clear();
_has_bits_[1] &= ~0x00200000u;
}
inline const ::caffe::PermuteParameter& LayerParameter::_internal_permute_param() const {
const ::caffe::PermuteParameter* p = permute_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::PermuteParameter&>(
::caffe::_PermuteParameter_default_instance_);
}
inline const ::caffe::PermuteParameter& LayerParameter::permute_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.permute_param)
return _internal_permute_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_permute_param(
::caffe::PermuteParameter* permute_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(permute_param_);
}
permute_param_ = permute_param;
if (permute_param) {
_has_bits_[1] |= 0x00200000u;
} else {
_has_bits_[1] &= ~0x00200000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.permute_param)
}
inline ::caffe::PermuteParameter* LayerParameter::release_permute_param() {
_has_bits_[1] &= ~0x00200000u;
::caffe::PermuteParameter* temp = permute_param_;
permute_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::PermuteParameter* LayerParameter::unsafe_arena_release_permute_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.permute_param)
_has_bits_[1] &= ~0x00200000u;
::caffe::PermuteParameter* temp = permute_param_;
permute_param_ = nullptr;
return temp;
}
inline ::caffe::PermuteParameter* LayerParameter::_internal_mutable_permute_param() {
_has_bits_[1] |= 0x00200000u;
if (permute_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::PermuteParameter>(GetArenaForAllocation());
permute_param_ = p;
}
return permute_param_;
}
inline ::caffe::PermuteParameter* LayerParameter::mutable_permute_param() {
::caffe::PermuteParameter* _msg = _internal_mutable_permute_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.permute_param)
return _msg;
}
inline void LayerParameter::set_allocated_permute_param(::caffe::PermuteParameter* permute_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete permute_param_;
}
if (permute_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::PermuteParameter>::GetOwningArena(permute_param);
if (message_arena != submessage_arena) {
permute_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, permute_param, submessage_arena);
}
_has_bits_[1] |= 0x00200000u;
} else {
_has_bits_[1] &= ~0x00200000u;
}
permute_param_ = permute_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.permute_param)
}
// optional .caffe.PoolingParameter pooling_param = 121;
inline bool LayerParameter::_internal_has_pooling_param() const {
bool value = (_has_bits_[0] & 0x00800000u) != 0;
PROTOBUF_ASSUME(!value || pooling_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_pooling_param() const {
return _internal_has_pooling_param();
}
inline void LayerParameter::clear_pooling_param() {
if (pooling_param_ != nullptr) pooling_param_->Clear();
_has_bits_[0] &= ~0x00800000u;
}
inline const ::caffe::PoolingParameter& LayerParameter::_internal_pooling_param() const {
const ::caffe::PoolingParameter* p = pooling_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::PoolingParameter&>(
::caffe::_PoolingParameter_default_instance_);
}
inline const ::caffe::PoolingParameter& LayerParameter::pooling_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.pooling_param)
return _internal_pooling_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_pooling_param(
::caffe::PoolingParameter* pooling_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pooling_param_);
}
pooling_param_ = pooling_param;
if (pooling_param) {
_has_bits_[0] |= 0x00800000u;
} else {
_has_bits_[0] &= ~0x00800000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.pooling_param)
}
inline ::caffe::PoolingParameter* LayerParameter::release_pooling_param() {
_has_bits_[0] &= ~0x00800000u;
::caffe::PoolingParameter* temp = pooling_param_;
pooling_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::PoolingParameter* LayerParameter::unsafe_arena_release_pooling_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.pooling_param)
_has_bits_[0] &= ~0x00800000u;
::caffe::PoolingParameter* temp = pooling_param_;
pooling_param_ = nullptr;
return temp;
}
inline ::caffe::PoolingParameter* LayerParameter::_internal_mutable_pooling_param() {
_has_bits_[0] |= 0x00800000u;
if (pooling_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::PoolingParameter>(GetArenaForAllocation());
pooling_param_ = p;
}
return pooling_param_;
}
inline ::caffe::PoolingParameter* LayerParameter::mutable_pooling_param() {
::caffe::PoolingParameter* _msg = _internal_mutable_pooling_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.pooling_param)
return _msg;
}
inline void LayerParameter::set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete pooling_param_;
}
if (pooling_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::PoolingParameter>::GetOwningArena(pooling_param);
if (message_arena != submessage_arena) {
pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, pooling_param, submessage_arena);
}
_has_bits_[0] |= 0x00800000u;
} else {
_has_bits_[0] &= ~0x00800000u;
}
pooling_param_ = pooling_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.pooling_param)
}
// optional .caffe.Pooling3DParameter pooling3d_param = 148;
inline bool LayerParameter::_internal_has_pooling3d_param() const {
bool value = (_has_bits_[1] & 0x00040000u) != 0;
PROTOBUF_ASSUME(!value || pooling3d_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_pooling3d_param() const {
return _internal_has_pooling3d_param();
}
inline void LayerParameter::clear_pooling3d_param() {
if (pooling3d_param_ != nullptr) pooling3d_param_->Clear();
_has_bits_[1] &= ~0x00040000u;
}
inline const ::caffe::Pooling3DParameter& LayerParameter::_internal_pooling3d_param() const {
const ::caffe::Pooling3DParameter* p = pooling3d_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::Pooling3DParameter&>(
::caffe::_Pooling3DParameter_default_instance_);
}
inline const ::caffe::Pooling3DParameter& LayerParameter::pooling3d_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.pooling3d_param)
return _internal_pooling3d_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_pooling3d_param(
::caffe::Pooling3DParameter* pooling3d_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pooling3d_param_);
}
pooling3d_param_ = pooling3d_param;
if (pooling3d_param) {
_has_bits_[1] |= 0x00040000u;
} else {
_has_bits_[1] &= ~0x00040000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.pooling3d_param)
}
inline ::caffe::Pooling3DParameter* LayerParameter::release_pooling3d_param() {
_has_bits_[1] &= ~0x00040000u;
::caffe::Pooling3DParameter* temp = pooling3d_param_;
pooling3d_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::Pooling3DParameter* LayerParameter::unsafe_arena_release_pooling3d_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.pooling3d_param)
_has_bits_[1] &= ~0x00040000u;
::caffe::Pooling3DParameter* temp = pooling3d_param_;
pooling3d_param_ = nullptr;
return temp;
}
inline ::caffe::Pooling3DParameter* LayerParameter::_internal_mutable_pooling3d_param() {
_has_bits_[1] |= 0x00040000u;
if (pooling3d_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::Pooling3DParameter>(GetArenaForAllocation());
pooling3d_param_ = p;
}
return pooling3d_param_;
}
inline ::caffe::Pooling3DParameter* LayerParameter::mutable_pooling3d_param() {
::caffe::Pooling3DParameter* _msg = _internal_mutable_pooling3d_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.pooling3d_param)
return _msg;
}
inline void LayerParameter::set_allocated_pooling3d_param(::caffe::Pooling3DParameter* pooling3d_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete pooling3d_param_;
}
if (pooling3d_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::Pooling3DParameter>::GetOwningArena(pooling3d_param);
if (message_arena != submessage_arena) {
pooling3d_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, pooling3d_param, submessage_arena);
}
_has_bits_[1] |= 0x00040000u;
} else {
_has_bits_[1] &= ~0x00040000u;
}
pooling3d_param_ = pooling3d_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.pooling3d_param)
}
// optional .caffe.PowerParameter power_param = 122;
inline bool LayerParameter::_internal_has_power_param() const {
bool value = (_has_bits_[0] & 0x01000000u) != 0;
PROTOBUF_ASSUME(!value || power_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_power_param() const {
return _internal_has_power_param();
}
inline void LayerParameter::clear_power_param() {
if (power_param_ != nullptr) power_param_->Clear();
_has_bits_[0] &= ~0x01000000u;
}
inline const ::caffe::PowerParameter& LayerParameter::_internal_power_param() const {
const ::caffe::PowerParameter* p = power_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::PowerParameter&>(
::caffe::_PowerParameter_default_instance_);
}
inline const ::caffe::PowerParameter& LayerParameter::power_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.power_param)
return _internal_power_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_power_param(
::caffe::PowerParameter* power_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(power_param_);
}
power_param_ = power_param;
if (power_param) {
_has_bits_[0] |= 0x01000000u;
} else {
_has_bits_[0] &= ~0x01000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.power_param)
}
inline ::caffe::PowerParameter* LayerParameter::release_power_param() {
_has_bits_[0] &= ~0x01000000u;
::caffe::PowerParameter* temp = power_param_;
power_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::PowerParameter* LayerParameter::unsafe_arena_release_power_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.power_param)
_has_bits_[0] &= ~0x01000000u;
::caffe::PowerParameter* temp = power_param_;
power_param_ = nullptr;
return temp;
}
inline ::caffe::PowerParameter* LayerParameter::_internal_mutable_power_param() {
_has_bits_[0] |= 0x01000000u;
if (power_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::PowerParameter>(GetArenaForAllocation());
power_param_ = p;
}
return power_param_;
}
inline ::caffe::PowerParameter* LayerParameter::mutable_power_param() {
::caffe::PowerParameter* _msg = _internal_mutable_power_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.power_param)
return _msg;
}
inline void LayerParameter::set_allocated_power_param(::caffe::PowerParameter* power_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete power_param_;
}
if (power_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::PowerParameter>::GetOwningArena(power_param);
if (message_arena != submessage_arena) {
power_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, power_param, submessage_arena);
}
_has_bits_[0] |= 0x01000000u;
} else {
_has_bits_[0] &= ~0x01000000u;
}
power_param_ = power_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.power_param)
}
// optional .caffe.PReLUParameter prelu_param = 131;
inline bool LayerParameter::_internal_has_prelu_param() const {
bool value = (_has_bits_[1] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || prelu_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_prelu_param() const {
return _internal_has_prelu_param();
}
inline void LayerParameter::clear_prelu_param() {
if (prelu_param_ != nullptr) prelu_param_->Clear();
_has_bits_[1] &= ~0x00000002u;
}
inline const ::caffe::PReLUParameter& LayerParameter::_internal_prelu_param() const {
const ::caffe::PReLUParameter* p = prelu_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::PReLUParameter&>(
::caffe::_PReLUParameter_default_instance_);
}
inline const ::caffe::PReLUParameter& LayerParameter::prelu_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.prelu_param)
return _internal_prelu_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_prelu_param(
::caffe::PReLUParameter* prelu_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(prelu_param_);
}
prelu_param_ = prelu_param;
if (prelu_param) {
_has_bits_[1] |= 0x00000002u;
} else {
_has_bits_[1] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.prelu_param)
}
inline ::caffe::PReLUParameter* LayerParameter::release_prelu_param() {
_has_bits_[1] &= ~0x00000002u;
::caffe::PReLUParameter* temp = prelu_param_;
prelu_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::PReLUParameter* LayerParameter::unsafe_arena_release_prelu_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.prelu_param)
_has_bits_[1] &= ~0x00000002u;
::caffe::PReLUParameter* temp = prelu_param_;
prelu_param_ = nullptr;
return temp;
}
inline ::caffe::PReLUParameter* LayerParameter::_internal_mutable_prelu_param() {
_has_bits_[1] |= 0x00000002u;
if (prelu_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::PReLUParameter>(GetArenaForAllocation());
prelu_param_ = p;
}
return prelu_param_;
}
inline ::caffe::PReLUParameter* LayerParameter::mutable_prelu_param() {
::caffe::PReLUParameter* _msg = _internal_mutable_prelu_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.prelu_param)
return _msg;
}
inline void LayerParameter::set_allocated_prelu_param(::caffe::PReLUParameter* prelu_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete prelu_param_;
}
if (prelu_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::PReLUParameter>::GetOwningArena(prelu_param);
if (message_arena != submessage_arena) {
prelu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, prelu_param, submessage_arena);
}
_has_bits_[1] |= 0x00000002u;
} else {
_has_bits_[1] &= ~0x00000002u;
}
prelu_param_ = prelu_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.prelu_param)
}
// optional .caffe.PriorBoxParameter prior_box_param = 203;
inline bool LayerParameter::_internal_has_prior_box_param() const {
bool value = (_has_bits_[1] & 0x00400000u) != 0;
PROTOBUF_ASSUME(!value || prior_box_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_prior_box_param() const {
return _internal_has_prior_box_param();
}
inline void LayerParameter::clear_prior_box_param() {
if (prior_box_param_ != nullptr) prior_box_param_->Clear();
_has_bits_[1] &= ~0x00400000u;
}
inline const ::caffe::PriorBoxParameter& LayerParameter::_internal_prior_box_param() const {
const ::caffe::PriorBoxParameter* p = prior_box_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::PriorBoxParameter&>(
::caffe::_PriorBoxParameter_default_instance_);
}
inline const ::caffe::PriorBoxParameter& LayerParameter::prior_box_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.prior_box_param)
return _internal_prior_box_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_prior_box_param(
::caffe::PriorBoxParameter* prior_box_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(prior_box_param_);
}
prior_box_param_ = prior_box_param;
if (prior_box_param) {
_has_bits_[1] |= 0x00400000u;
} else {
_has_bits_[1] &= ~0x00400000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.prior_box_param)
}
inline ::caffe::PriorBoxParameter* LayerParameter::release_prior_box_param() {
_has_bits_[1] &= ~0x00400000u;
::caffe::PriorBoxParameter* temp = prior_box_param_;
prior_box_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::PriorBoxParameter* LayerParameter::unsafe_arena_release_prior_box_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.prior_box_param)
_has_bits_[1] &= ~0x00400000u;
::caffe::PriorBoxParameter* temp = prior_box_param_;
prior_box_param_ = nullptr;
return temp;
}
inline ::caffe::PriorBoxParameter* LayerParameter::_internal_mutable_prior_box_param() {
_has_bits_[1] |= 0x00400000u;
if (prior_box_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::PriorBoxParameter>(GetArenaForAllocation());
prior_box_param_ = p;
}
return prior_box_param_;
}
inline ::caffe::PriorBoxParameter* LayerParameter::mutable_prior_box_param() {
::caffe::PriorBoxParameter* _msg = _internal_mutable_prior_box_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.prior_box_param)
return _msg;
}
inline void LayerParameter::set_allocated_prior_box_param(::caffe::PriorBoxParameter* prior_box_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete prior_box_param_;
}
if (prior_box_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::PriorBoxParameter>::GetOwningArena(prior_box_param);
if (message_arena != submessage_arena) {
prior_box_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, prior_box_param, submessage_arena);
}
_has_bits_[1] |= 0x00400000u;
} else {
_has_bits_[1] &= ~0x00400000u;
}
prior_box_param_ = prior_box_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.prior_box_param)
}
// optional .caffe.PythonParameter python_param = 130;
inline bool LayerParameter::_internal_has_python_param() const {
bool value = (_has_bits_[1] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || python_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_python_param() const {
return _internal_has_python_param();
}
inline void LayerParameter::clear_python_param() {
if (python_param_ != nullptr) python_param_->Clear();
_has_bits_[1] &= ~0x00000001u;
}
inline const ::caffe::PythonParameter& LayerParameter::_internal_python_param() const {
const ::caffe::PythonParameter* p = python_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::PythonParameter&>(
::caffe::_PythonParameter_default_instance_);
}
inline const ::caffe::PythonParameter& LayerParameter::python_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.python_param)
return _internal_python_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_python_param(
::caffe::PythonParameter* python_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(python_param_);
}
python_param_ = python_param;
if (python_param) {
_has_bits_[1] |= 0x00000001u;
} else {
_has_bits_[1] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.python_param)
}
inline ::caffe::PythonParameter* LayerParameter::release_python_param() {
_has_bits_[1] &= ~0x00000001u;
::caffe::PythonParameter* temp = python_param_;
python_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::PythonParameter* LayerParameter::unsafe_arena_release_python_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.python_param)
_has_bits_[1] &= ~0x00000001u;
::caffe::PythonParameter* temp = python_param_;
python_param_ = nullptr;
return temp;
}
inline ::caffe::PythonParameter* LayerParameter::_internal_mutable_python_param() {
_has_bits_[1] |= 0x00000001u;
if (python_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::PythonParameter>(GetArenaForAllocation());
python_param_ = p;
}
return python_param_;
}
inline ::caffe::PythonParameter* LayerParameter::mutable_python_param() {
::caffe::PythonParameter* _msg = _internal_mutable_python_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.python_param)
return _msg;
}
inline void LayerParameter::set_allocated_python_param(::caffe::PythonParameter* python_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete python_param_;
}
if (python_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::PythonParameter>::GetOwningArena(python_param);
if (message_arena != submessage_arena) {
python_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, python_param, submessage_arena);
}
_has_bits_[1] |= 0x00000001u;
} else {
_has_bits_[1] &= ~0x00000001u;
}
python_param_ = python_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.python_param)
}
// optional .caffe.RecurrentParameter recurrent_param = 146;
inline bool LayerParameter::_internal_has_recurrent_param() const {
bool value = (_has_bits_[1] & 0x00010000u) != 0;
PROTOBUF_ASSUME(!value || recurrent_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_recurrent_param() const {
return _internal_has_recurrent_param();
}
inline void LayerParameter::clear_recurrent_param() {
if (recurrent_param_ != nullptr) recurrent_param_->Clear();
_has_bits_[1] &= ~0x00010000u;
}
inline const ::caffe::RecurrentParameter& LayerParameter::_internal_recurrent_param() const {
const ::caffe::RecurrentParameter* p = recurrent_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::RecurrentParameter&>(
::caffe::_RecurrentParameter_default_instance_);
}
inline const ::caffe::RecurrentParameter& LayerParameter::recurrent_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.recurrent_param)
return _internal_recurrent_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_recurrent_param(
::caffe::RecurrentParameter* recurrent_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(recurrent_param_);
}
recurrent_param_ = recurrent_param;
if (recurrent_param) {
_has_bits_[1] |= 0x00010000u;
} else {
_has_bits_[1] &= ~0x00010000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.recurrent_param)
}
inline ::caffe::RecurrentParameter* LayerParameter::release_recurrent_param() {
_has_bits_[1] &= ~0x00010000u;
::caffe::RecurrentParameter* temp = recurrent_param_;
recurrent_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::RecurrentParameter* LayerParameter::unsafe_arena_release_recurrent_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.recurrent_param)
_has_bits_[1] &= ~0x00010000u;
::caffe::RecurrentParameter* temp = recurrent_param_;
recurrent_param_ = nullptr;
return temp;
}
inline ::caffe::RecurrentParameter* LayerParameter::_internal_mutable_recurrent_param() {
_has_bits_[1] |= 0x00010000u;
if (recurrent_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::RecurrentParameter>(GetArenaForAllocation());
recurrent_param_ = p;
}
return recurrent_param_;
}
inline ::caffe::RecurrentParameter* LayerParameter::mutable_recurrent_param() {
::caffe::RecurrentParameter* _msg = _internal_mutable_recurrent_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.recurrent_param)
return _msg;
}
inline void LayerParameter::set_allocated_recurrent_param(::caffe::RecurrentParameter* recurrent_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete recurrent_param_;
}
if (recurrent_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::RecurrentParameter>::GetOwningArena(recurrent_param);
if (message_arena != submessage_arena) {
recurrent_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, recurrent_param, submessage_arena);
}
_has_bits_[1] |= 0x00010000u;
} else {
_has_bits_[1] &= ~0x00010000u;
}
recurrent_param_ = recurrent_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.recurrent_param)
}
// optional .caffe.ReductionParameter reduction_param = 136;
inline bool LayerParameter::_internal_has_reduction_param() const {
bool value = (_has_bits_[1] & 0x00000040u) != 0;
PROTOBUF_ASSUME(!value || reduction_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_reduction_param() const {
return _internal_has_reduction_param();
}
inline void LayerParameter::clear_reduction_param() {
if (reduction_param_ != nullptr) reduction_param_->Clear();
_has_bits_[1] &= ~0x00000040u;
}
inline const ::caffe::ReductionParameter& LayerParameter::_internal_reduction_param() const {
const ::caffe::ReductionParameter* p = reduction_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ReductionParameter&>(
::caffe::_ReductionParameter_default_instance_);
}
inline const ::caffe::ReductionParameter& LayerParameter::reduction_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.reduction_param)
return _internal_reduction_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_reduction_param(
::caffe::ReductionParameter* reduction_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reduction_param_);
}
reduction_param_ = reduction_param;
if (reduction_param) {
_has_bits_[1] |= 0x00000040u;
} else {
_has_bits_[1] &= ~0x00000040u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.reduction_param)
}
inline ::caffe::ReductionParameter* LayerParameter::release_reduction_param() {
_has_bits_[1] &= ~0x00000040u;
::caffe::ReductionParameter* temp = reduction_param_;
reduction_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ReductionParameter* LayerParameter::unsafe_arena_release_reduction_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.reduction_param)
_has_bits_[1] &= ~0x00000040u;
::caffe::ReductionParameter* temp = reduction_param_;
reduction_param_ = nullptr;
return temp;
}
inline ::caffe::ReductionParameter* LayerParameter::_internal_mutable_reduction_param() {
_has_bits_[1] |= 0x00000040u;
if (reduction_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ReductionParameter>(GetArenaForAllocation());
reduction_param_ = p;
}
return reduction_param_;
}
inline ::caffe::ReductionParameter* LayerParameter::mutable_reduction_param() {
::caffe::ReductionParameter* _msg = _internal_mutable_reduction_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.reduction_param)
return _msg;
}
inline void LayerParameter::set_allocated_reduction_param(::caffe::ReductionParameter* reduction_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reduction_param_;
}
if (reduction_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ReductionParameter>::GetOwningArena(reduction_param);
if (message_arena != submessage_arena) {
reduction_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, reduction_param, submessage_arena);
}
_has_bits_[1] |= 0x00000040u;
} else {
_has_bits_[1] &= ~0x00000040u;
}
reduction_param_ = reduction_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.reduction_param)
}
// optional .caffe.ReLUParameter relu_param = 123;
inline bool LayerParameter::_internal_has_relu_param() const {
bool value = (_has_bits_[0] & 0x02000000u) != 0;
PROTOBUF_ASSUME(!value || relu_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_relu_param() const {
return _internal_has_relu_param();
}
inline void LayerParameter::clear_relu_param() {
if (relu_param_ != nullptr) relu_param_->Clear();
_has_bits_[0] &= ~0x02000000u;
}
inline const ::caffe::ReLUParameter& LayerParameter::_internal_relu_param() const {
const ::caffe::ReLUParameter* p = relu_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ReLUParameter&>(
::caffe::_ReLUParameter_default_instance_);
}
inline const ::caffe::ReLUParameter& LayerParameter::relu_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.relu_param)
return _internal_relu_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_relu_param(
::caffe::ReLUParameter* relu_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relu_param_);
}
relu_param_ = relu_param;
if (relu_param) {
_has_bits_[0] |= 0x02000000u;
} else {
_has_bits_[0] &= ~0x02000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.relu_param)
}
inline ::caffe::ReLUParameter* LayerParameter::release_relu_param() {
_has_bits_[0] &= ~0x02000000u;
::caffe::ReLUParameter* temp = relu_param_;
relu_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ReLUParameter* LayerParameter::unsafe_arena_release_relu_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.relu_param)
_has_bits_[0] &= ~0x02000000u;
::caffe::ReLUParameter* temp = relu_param_;
relu_param_ = nullptr;
return temp;
}
inline ::caffe::ReLUParameter* LayerParameter::_internal_mutable_relu_param() {
_has_bits_[0] |= 0x02000000u;
if (relu_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ReLUParameter>(GetArenaForAllocation());
relu_param_ = p;
}
return relu_param_;
}
inline ::caffe::ReLUParameter* LayerParameter::mutable_relu_param() {
::caffe::ReLUParameter* _msg = _internal_mutable_relu_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.relu_param)
return _msg;
}
inline void LayerParameter::set_allocated_relu_param(::caffe::ReLUParameter* relu_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete relu_param_;
}
if (relu_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ReLUParameter>::GetOwningArena(relu_param);
if (message_arena != submessage_arena) {
relu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, relu_param, submessage_arena);
}
_has_bits_[0] |= 0x02000000u;
} else {
_has_bits_[0] &= ~0x02000000u;
}
relu_param_ = relu_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.relu_param)
}
// optional .caffe.ReshapeParameter reshape_param = 133;
inline bool LayerParameter::_internal_has_reshape_param() const {
bool value = (_has_bits_[1] & 0x00000008u) != 0;
PROTOBUF_ASSUME(!value || reshape_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_reshape_param() const {
return _internal_has_reshape_param();
}
inline void LayerParameter::clear_reshape_param() {
if (reshape_param_ != nullptr) reshape_param_->Clear();
_has_bits_[1] &= ~0x00000008u;
}
inline const ::caffe::ReshapeParameter& LayerParameter::_internal_reshape_param() const {
const ::caffe::ReshapeParameter* p = reshape_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ReshapeParameter&>(
::caffe::_ReshapeParameter_default_instance_);
}
inline const ::caffe::ReshapeParameter& LayerParameter::reshape_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.reshape_param)
return _internal_reshape_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_reshape_param(
::caffe::ReshapeParameter* reshape_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reshape_param_);
}
reshape_param_ = reshape_param;
if (reshape_param) {
_has_bits_[1] |= 0x00000008u;
} else {
_has_bits_[1] &= ~0x00000008u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.reshape_param)
}
inline ::caffe::ReshapeParameter* LayerParameter::release_reshape_param() {
_has_bits_[1] &= ~0x00000008u;
::caffe::ReshapeParameter* temp = reshape_param_;
reshape_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ReshapeParameter* LayerParameter::unsafe_arena_release_reshape_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.reshape_param)
_has_bits_[1] &= ~0x00000008u;
::caffe::ReshapeParameter* temp = reshape_param_;
reshape_param_ = nullptr;
return temp;
}
inline ::caffe::ReshapeParameter* LayerParameter::_internal_mutable_reshape_param() {
_has_bits_[1] |= 0x00000008u;
if (reshape_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ReshapeParameter>(GetArenaForAllocation());
reshape_param_ = p;
}
return reshape_param_;
}
inline ::caffe::ReshapeParameter* LayerParameter::mutable_reshape_param() {
::caffe::ReshapeParameter* _msg = _internal_mutable_reshape_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.reshape_param)
return _msg;
}
inline void LayerParameter::set_allocated_reshape_param(::caffe::ReshapeParameter* reshape_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reshape_param_;
}
if (reshape_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ReshapeParameter>::GetOwningArena(reshape_param);
if (message_arena != submessage_arena) {
reshape_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, reshape_param, submessage_arena);
}
_has_bits_[1] |= 0x00000008u;
} else {
_has_bits_[1] &= ~0x00000008u;
}
reshape_param_ = reshape_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.reshape_param)
}
// optional .caffe.ScaleParameter scale_param = 142;
inline bool LayerParameter::_internal_has_scale_param() const {
bool value = (_has_bits_[1] & 0x00001000u) != 0;
PROTOBUF_ASSUME(!value || scale_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_scale_param() const {
return _internal_has_scale_param();
}
inline void LayerParameter::clear_scale_param() {
if (scale_param_ != nullptr) scale_param_->Clear();
_has_bits_[1] &= ~0x00001000u;
}
inline const ::caffe::ScaleParameter& LayerParameter::_internal_scale_param() const {
const ::caffe::ScaleParameter* p = scale_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ScaleParameter&>(
::caffe::_ScaleParameter_default_instance_);
}
inline const ::caffe::ScaleParameter& LayerParameter::scale_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.scale_param)
return _internal_scale_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_scale_param(
::caffe::ScaleParameter* scale_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_param_);
}
scale_param_ = scale_param;
if (scale_param) {
_has_bits_[1] |= 0x00001000u;
} else {
_has_bits_[1] &= ~0x00001000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.scale_param)
}
inline ::caffe::ScaleParameter* LayerParameter::release_scale_param() {
_has_bits_[1] &= ~0x00001000u;
::caffe::ScaleParameter* temp = scale_param_;
scale_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ScaleParameter* LayerParameter::unsafe_arena_release_scale_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.scale_param)
_has_bits_[1] &= ~0x00001000u;
::caffe::ScaleParameter* temp = scale_param_;
scale_param_ = nullptr;
return temp;
}
inline ::caffe::ScaleParameter* LayerParameter::_internal_mutable_scale_param() {
_has_bits_[1] |= 0x00001000u;
if (scale_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ScaleParameter>(GetArenaForAllocation());
scale_param_ = p;
}
return scale_param_;
}
inline ::caffe::ScaleParameter* LayerParameter::mutable_scale_param() {
::caffe::ScaleParameter* _msg = _internal_mutable_scale_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.scale_param)
return _msg;
}
inline void LayerParameter::set_allocated_scale_param(::caffe::ScaleParameter* scale_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete scale_param_;
}
if (scale_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ScaleParameter>::GetOwningArena(scale_param);
if (message_arena != submessage_arena) {
scale_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, scale_param, submessage_arena);
}
_has_bits_[1] |= 0x00001000u;
} else {
_has_bits_[1] &= ~0x00001000u;
}
scale_param_ = scale_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.scale_param)
}
// optional .caffe.SigmoidParameter sigmoid_param = 124;
inline bool LayerParameter::_internal_has_sigmoid_param() const {
bool value = (_has_bits_[0] & 0x04000000u) != 0;
PROTOBUF_ASSUME(!value || sigmoid_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_sigmoid_param() const {
return _internal_has_sigmoid_param();
}
inline void LayerParameter::clear_sigmoid_param() {
if (sigmoid_param_ != nullptr) sigmoid_param_->Clear();
_has_bits_[0] &= ~0x04000000u;
}
inline const ::caffe::SigmoidParameter& LayerParameter::_internal_sigmoid_param() const {
const ::caffe::SigmoidParameter* p = sigmoid_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SigmoidParameter&>(
::caffe::_SigmoidParameter_default_instance_);
}
inline const ::caffe::SigmoidParameter& LayerParameter::sigmoid_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.sigmoid_param)
return _internal_sigmoid_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_sigmoid_param(
::caffe::SigmoidParameter* sigmoid_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sigmoid_param_);
}
sigmoid_param_ = sigmoid_param;
if (sigmoid_param) {
_has_bits_[0] |= 0x04000000u;
} else {
_has_bits_[0] &= ~0x04000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.sigmoid_param)
}
inline ::caffe::SigmoidParameter* LayerParameter::release_sigmoid_param() {
_has_bits_[0] &= ~0x04000000u;
::caffe::SigmoidParameter* temp = sigmoid_param_;
sigmoid_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SigmoidParameter* LayerParameter::unsafe_arena_release_sigmoid_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.sigmoid_param)
_has_bits_[0] &= ~0x04000000u;
::caffe::SigmoidParameter* temp = sigmoid_param_;
sigmoid_param_ = nullptr;
return temp;
}
inline ::caffe::SigmoidParameter* LayerParameter::_internal_mutable_sigmoid_param() {
_has_bits_[0] |= 0x04000000u;
if (sigmoid_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SigmoidParameter>(GetArenaForAllocation());
sigmoid_param_ = p;
}
return sigmoid_param_;
}
inline ::caffe::SigmoidParameter* LayerParameter::mutable_sigmoid_param() {
::caffe::SigmoidParameter* _msg = _internal_mutable_sigmoid_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.sigmoid_param)
return _msg;
}
inline void LayerParameter::set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete sigmoid_param_;
}
if (sigmoid_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SigmoidParameter>::GetOwningArena(sigmoid_param);
if (message_arena != submessage_arena) {
sigmoid_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, sigmoid_param, submessage_arena);
}
_has_bits_[0] |= 0x04000000u;
} else {
_has_bits_[0] &= ~0x04000000u;
}
sigmoid_param_ = sigmoid_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.sigmoid_param)
}
// optional .caffe.SoftmaxParameter softmax_param = 125;
inline bool LayerParameter::_internal_has_softmax_param() const {
bool value = (_has_bits_[0] & 0x08000000u) != 0;
PROTOBUF_ASSUME(!value || softmax_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_softmax_param() const {
return _internal_has_softmax_param();
}
inline void LayerParameter::clear_softmax_param() {
if (softmax_param_ != nullptr) softmax_param_->Clear();
_has_bits_[0] &= ~0x08000000u;
}
inline const ::caffe::SoftmaxParameter& LayerParameter::_internal_softmax_param() const {
const ::caffe::SoftmaxParameter* p = softmax_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SoftmaxParameter&>(
::caffe::_SoftmaxParameter_default_instance_);
}
inline const ::caffe::SoftmaxParameter& LayerParameter::softmax_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.softmax_param)
return _internal_softmax_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_softmax_param(
::caffe::SoftmaxParameter* softmax_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(softmax_param_);
}
softmax_param_ = softmax_param;
if (softmax_param) {
_has_bits_[0] |= 0x08000000u;
} else {
_has_bits_[0] &= ~0x08000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.softmax_param)
}
inline ::caffe::SoftmaxParameter* LayerParameter::release_softmax_param() {
_has_bits_[0] &= ~0x08000000u;
::caffe::SoftmaxParameter* temp = softmax_param_;
softmax_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SoftmaxParameter* LayerParameter::unsafe_arena_release_softmax_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.softmax_param)
_has_bits_[0] &= ~0x08000000u;
::caffe::SoftmaxParameter* temp = softmax_param_;
softmax_param_ = nullptr;
return temp;
}
inline ::caffe::SoftmaxParameter* LayerParameter::_internal_mutable_softmax_param() {
_has_bits_[0] |= 0x08000000u;
if (softmax_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SoftmaxParameter>(GetArenaForAllocation());
softmax_param_ = p;
}
return softmax_param_;
}
inline ::caffe::SoftmaxParameter* LayerParameter::mutable_softmax_param() {
::caffe::SoftmaxParameter* _msg = _internal_mutable_softmax_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.softmax_param)
return _msg;
}
inline void LayerParameter::set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete softmax_param_;
}
if (softmax_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SoftmaxParameter>::GetOwningArena(softmax_param);
if (message_arena != submessage_arena) {
softmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, softmax_param, submessage_arena);
}
_has_bits_[0] |= 0x08000000u;
} else {
_has_bits_[0] &= ~0x08000000u;
}
softmax_param_ = softmax_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.softmax_param)
}
// optional .caffe.SPPParameter spp_param = 132;
inline bool LayerParameter::_internal_has_spp_param() const {
bool value = (_has_bits_[1] & 0x00000004u) != 0;
PROTOBUF_ASSUME(!value || spp_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_spp_param() const {
return _internal_has_spp_param();
}
inline void LayerParameter::clear_spp_param() {
if (spp_param_ != nullptr) spp_param_->Clear();
_has_bits_[1] &= ~0x00000004u;
}
inline const ::caffe::SPPParameter& LayerParameter::_internal_spp_param() const {
const ::caffe::SPPParameter* p = spp_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SPPParameter&>(
::caffe::_SPPParameter_default_instance_);
}
inline const ::caffe::SPPParameter& LayerParameter::spp_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.spp_param)
return _internal_spp_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_spp_param(
::caffe::SPPParameter* spp_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(spp_param_);
}
spp_param_ = spp_param;
if (spp_param) {
_has_bits_[1] |= 0x00000004u;
} else {
_has_bits_[1] &= ~0x00000004u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.spp_param)
}
inline ::caffe::SPPParameter* LayerParameter::release_spp_param() {
_has_bits_[1] &= ~0x00000004u;
::caffe::SPPParameter* temp = spp_param_;
spp_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SPPParameter* LayerParameter::unsafe_arena_release_spp_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.spp_param)
_has_bits_[1] &= ~0x00000004u;
::caffe::SPPParameter* temp = spp_param_;
spp_param_ = nullptr;
return temp;
}
inline ::caffe::SPPParameter* LayerParameter::_internal_mutable_spp_param() {
_has_bits_[1] |= 0x00000004u;
if (spp_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SPPParameter>(GetArenaForAllocation());
spp_param_ = p;
}
return spp_param_;
}
inline ::caffe::SPPParameter* LayerParameter::mutable_spp_param() {
::caffe::SPPParameter* _msg = _internal_mutable_spp_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.spp_param)
return _msg;
}
inline void LayerParameter::set_allocated_spp_param(::caffe::SPPParameter* spp_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete spp_param_;
}
if (spp_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SPPParameter>::GetOwningArena(spp_param);
if (message_arena != submessage_arena) {
spp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, spp_param, submessage_arena);
}
_has_bits_[1] |= 0x00000004u;
} else {
_has_bits_[1] &= ~0x00000004u;
}
spp_param_ = spp_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.spp_param)
}
// optional .caffe.SliceParameter slice_param = 126;
inline bool LayerParameter::_internal_has_slice_param() const {
bool value = (_has_bits_[0] & 0x10000000u) != 0;
PROTOBUF_ASSUME(!value || slice_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_slice_param() const {
return _internal_has_slice_param();
}
inline void LayerParameter::clear_slice_param() {
if (slice_param_ != nullptr) slice_param_->Clear();
_has_bits_[0] &= ~0x10000000u;
}
inline const ::caffe::SliceParameter& LayerParameter::_internal_slice_param() const {
const ::caffe::SliceParameter* p = slice_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SliceParameter&>(
::caffe::_SliceParameter_default_instance_);
}
inline const ::caffe::SliceParameter& LayerParameter::slice_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.slice_param)
return _internal_slice_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_slice_param(
::caffe::SliceParameter* slice_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(slice_param_);
}
slice_param_ = slice_param;
if (slice_param) {
_has_bits_[0] |= 0x10000000u;
} else {
_has_bits_[0] &= ~0x10000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.slice_param)
}
inline ::caffe::SliceParameter* LayerParameter::release_slice_param() {
_has_bits_[0] &= ~0x10000000u;
::caffe::SliceParameter* temp = slice_param_;
slice_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SliceParameter* LayerParameter::unsafe_arena_release_slice_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.slice_param)
_has_bits_[0] &= ~0x10000000u;
::caffe::SliceParameter* temp = slice_param_;
slice_param_ = nullptr;
return temp;
}
inline ::caffe::SliceParameter* LayerParameter::_internal_mutable_slice_param() {
_has_bits_[0] |= 0x10000000u;
if (slice_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SliceParameter>(GetArenaForAllocation());
slice_param_ = p;
}
return slice_param_;
}
inline ::caffe::SliceParameter* LayerParameter::mutable_slice_param() {
::caffe::SliceParameter* _msg = _internal_mutable_slice_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.slice_param)
return _msg;
}
inline void LayerParameter::set_allocated_slice_param(::caffe::SliceParameter* slice_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete slice_param_;
}
if (slice_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SliceParameter>::GetOwningArena(slice_param);
if (message_arena != submessage_arena) {
slice_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, slice_param, submessage_arena);
}
_has_bits_[0] |= 0x10000000u;
} else {
_has_bits_[0] &= ~0x10000000u;
}
slice_param_ = slice_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.slice_param)
}
// optional .caffe.TanHParameter tanh_param = 127;
inline bool LayerParameter::_internal_has_tanh_param() const {
bool value = (_has_bits_[0] & 0x20000000u) != 0;
PROTOBUF_ASSUME(!value || tanh_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_tanh_param() const {
return _internal_has_tanh_param();
}
inline void LayerParameter::clear_tanh_param() {
if (tanh_param_ != nullptr) tanh_param_->Clear();
_has_bits_[0] &= ~0x20000000u;
}
inline const ::caffe::TanHParameter& LayerParameter::_internal_tanh_param() const {
const ::caffe::TanHParameter* p = tanh_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::TanHParameter&>(
::caffe::_TanHParameter_default_instance_);
}
inline const ::caffe::TanHParameter& LayerParameter::tanh_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.tanh_param)
return _internal_tanh_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_tanh_param(
::caffe::TanHParameter* tanh_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tanh_param_);
}
tanh_param_ = tanh_param;
if (tanh_param) {
_has_bits_[0] |= 0x20000000u;
} else {
_has_bits_[0] &= ~0x20000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.tanh_param)
}
inline ::caffe::TanHParameter* LayerParameter::release_tanh_param() {
_has_bits_[0] &= ~0x20000000u;
::caffe::TanHParameter* temp = tanh_param_;
tanh_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::TanHParameter* LayerParameter::unsafe_arena_release_tanh_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.tanh_param)
_has_bits_[0] &= ~0x20000000u;
::caffe::TanHParameter* temp = tanh_param_;
tanh_param_ = nullptr;
return temp;
}
inline ::caffe::TanHParameter* LayerParameter::_internal_mutable_tanh_param() {
_has_bits_[0] |= 0x20000000u;
if (tanh_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::TanHParameter>(GetArenaForAllocation());
tanh_param_ = p;
}
return tanh_param_;
}
inline ::caffe::TanHParameter* LayerParameter::mutable_tanh_param() {
::caffe::TanHParameter* _msg = _internal_mutable_tanh_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.tanh_param)
return _msg;
}
inline void LayerParameter::set_allocated_tanh_param(::caffe::TanHParameter* tanh_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete tanh_param_;
}
if (tanh_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::TanHParameter>::GetOwningArena(tanh_param);
if (message_arena != submessage_arena) {
tanh_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, tanh_param, submessage_arena);
}
_has_bits_[0] |= 0x20000000u;
} else {
_has_bits_[0] &= ~0x20000000u;
}
tanh_param_ = tanh_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.tanh_param)
}
// optional .caffe.ThresholdParameter threshold_param = 128;
inline bool LayerParameter::_internal_has_threshold_param() const {
bool value = (_has_bits_[0] & 0x40000000u) != 0;
PROTOBUF_ASSUME(!value || threshold_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_threshold_param() const {
return _internal_has_threshold_param();
}
inline void LayerParameter::clear_threshold_param() {
if (threshold_param_ != nullptr) threshold_param_->Clear();
_has_bits_[0] &= ~0x40000000u;
}
inline const ::caffe::ThresholdParameter& LayerParameter::_internal_threshold_param() const {
const ::caffe::ThresholdParameter* p = threshold_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ThresholdParameter&>(
::caffe::_ThresholdParameter_default_instance_);
}
inline const ::caffe::ThresholdParameter& LayerParameter::threshold_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.threshold_param)
return _internal_threshold_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_threshold_param(
::caffe::ThresholdParameter* threshold_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(threshold_param_);
}
threshold_param_ = threshold_param;
if (threshold_param) {
_has_bits_[0] |= 0x40000000u;
} else {
_has_bits_[0] &= ~0x40000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.threshold_param)
}
inline ::caffe::ThresholdParameter* LayerParameter::release_threshold_param() {
_has_bits_[0] &= ~0x40000000u;
::caffe::ThresholdParameter* temp = threshold_param_;
threshold_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ThresholdParameter* LayerParameter::unsafe_arena_release_threshold_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.threshold_param)
_has_bits_[0] &= ~0x40000000u;
::caffe::ThresholdParameter* temp = threshold_param_;
threshold_param_ = nullptr;
return temp;
}
inline ::caffe::ThresholdParameter* LayerParameter::_internal_mutable_threshold_param() {
_has_bits_[0] |= 0x40000000u;
if (threshold_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ThresholdParameter>(GetArenaForAllocation());
threshold_param_ = p;
}
return threshold_param_;
}
inline ::caffe::ThresholdParameter* LayerParameter::mutable_threshold_param() {
::caffe::ThresholdParameter* _msg = _internal_mutable_threshold_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.threshold_param)
return _msg;
}
inline void LayerParameter::set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete threshold_param_;
}
if (threshold_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ThresholdParameter>::GetOwningArena(threshold_param);
if (message_arena != submessage_arena) {
threshold_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, threshold_param, submessage_arena);
}
_has_bits_[0] |= 0x40000000u;
} else {
_has_bits_[0] &= ~0x40000000u;
}
threshold_param_ = threshold_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.threshold_param)
}
// optional .caffe.TileParameter tile_param = 138;
inline bool LayerParameter::_internal_has_tile_param() const {
bool value = (_has_bits_[1] & 0x00000100u) != 0;
PROTOBUF_ASSUME(!value || tile_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_tile_param() const {
return _internal_has_tile_param();
}
inline void LayerParameter::clear_tile_param() {
if (tile_param_ != nullptr) tile_param_->Clear();
_has_bits_[1] &= ~0x00000100u;
}
inline const ::caffe::TileParameter& LayerParameter::_internal_tile_param() const {
const ::caffe::TileParameter* p = tile_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::TileParameter&>(
::caffe::_TileParameter_default_instance_);
}
inline const ::caffe::TileParameter& LayerParameter::tile_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.tile_param)
return _internal_tile_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_tile_param(
::caffe::TileParameter* tile_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tile_param_);
}
tile_param_ = tile_param;
if (tile_param) {
_has_bits_[1] |= 0x00000100u;
} else {
_has_bits_[1] &= ~0x00000100u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.tile_param)
}
inline ::caffe::TileParameter* LayerParameter::release_tile_param() {
_has_bits_[1] &= ~0x00000100u;
::caffe::TileParameter* temp = tile_param_;
tile_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::TileParameter* LayerParameter::unsafe_arena_release_tile_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.tile_param)
_has_bits_[1] &= ~0x00000100u;
::caffe::TileParameter* temp = tile_param_;
tile_param_ = nullptr;
return temp;
}
inline ::caffe::TileParameter* LayerParameter::_internal_mutable_tile_param() {
_has_bits_[1] |= 0x00000100u;
if (tile_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::TileParameter>(GetArenaForAllocation());
tile_param_ = p;
}
return tile_param_;
}
inline ::caffe::TileParameter* LayerParameter::mutable_tile_param() {
::caffe::TileParameter* _msg = _internal_mutable_tile_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.tile_param)
return _msg;
}
inline void LayerParameter::set_allocated_tile_param(::caffe::TileParameter* tile_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete tile_param_;
}
if (tile_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::TileParameter>::GetOwningArena(tile_param);
if (message_arena != submessage_arena) {
tile_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, tile_param, submessage_arena);
}
_has_bits_[1] |= 0x00000100u;
} else {
_has_bits_[1] &= ~0x00000100u;
}
tile_param_ = tile_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.tile_param)
}
// optional .caffe.WindowDataParameter window_data_param = 129;
inline bool LayerParameter::_internal_has_window_data_param() const {
bool value = (_has_bits_[0] & 0x80000000u) != 0;
PROTOBUF_ASSUME(!value || window_data_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_window_data_param() const {
return _internal_has_window_data_param();
}
inline void LayerParameter::clear_window_data_param() {
if (window_data_param_ != nullptr) window_data_param_->Clear();
_has_bits_[0] &= ~0x80000000u;
}
inline const ::caffe::WindowDataParameter& LayerParameter::_internal_window_data_param() const {
const ::caffe::WindowDataParameter* p = window_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::WindowDataParameter&>(
::caffe::_WindowDataParameter_default_instance_);
}
inline const ::caffe::WindowDataParameter& LayerParameter::window_data_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.window_data_param)
return _internal_window_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_window_data_param(
::caffe::WindowDataParameter* window_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(window_data_param_);
}
window_data_param_ = window_data_param;
if (window_data_param) {
_has_bits_[0] |= 0x80000000u;
} else {
_has_bits_[0] &= ~0x80000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.window_data_param)
}
inline ::caffe::WindowDataParameter* LayerParameter::release_window_data_param() {
_has_bits_[0] &= ~0x80000000u;
::caffe::WindowDataParameter* temp = window_data_param_;
window_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::WindowDataParameter* LayerParameter::unsafe_arena_release_window_data_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.window_data_param)
_has_bits_[0] &= ~0x80000000u;
::caffe::WindowDataParameter* temp = window_data_param_;
window_data_param_ = nullptr;
return temp;
}
inline ::caffe::WindowDataParameter* LayerParameter::_internal_mutable_window_data_param() {
_has_bits_[0] |= 0x80000000u;
if (window_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::WindowDataParameter>(GetArenaForAllocation());
window_data_param_ = p;
}
return window_data_param_;
}
inline ::caffe::WindowDataParameter* LayerParameter::mutable_window_data_param() {
::caffe::WindowDataParameter* _msg = _internal_mutable_window_data_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.window_data_param)
return _msg;
}
inline void LayerParameter::set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete window_data_param_;
}
if (window_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::WindowDataParameter>::GetOwningArena(window_data_param);
if (message_arena != submessage_arena) {
window_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, window_data_param, submessage_arena);
}
_has_bits_[0] |= 0x80000000u;
} else {
_has_bits_[0] &= ~0x80000000u;
}
window_data_param_ = window_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.window_data_param)
}
// optional .caffe.CenterLossParameter center_loss_param = 211;
inline bool LayerParameter::_internal_has_center_loss_param() const {
bool value = (_has_bits_[1] & 0x40000000u) != 0;
PROTOBUF_ASSUME(!value || center_loss_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_center_loss_param() const {
return _internal_has_center_loss_param();
}
inline void LayerParameter::clear_center_loss_param() {
if (center_loss_param_ != nullptr) center_loss_param_->Clear();
_has_bits_[1] &= ~0x40000000u;
}
inline const ::caffe::CenterLossParameter& LayerParameter::_internal_center_loss_param() const {
const ::caffe::CenterLossParameter* p = center_loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::CenterLossParameter&>(
::caffe::_CenterLossParameter_default_instance_);
}
inline const ::caffe::CenterLossParameter& LayerParameter::center_loss_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.center_loss_param)
return _internal_center_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_center_loss_param(
::caffe::CenterLossParameter* center_loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(center_loss_param_);
}
center_loss_param_ = center_loss_param;
if (center_loss_param) {
_has_bits_[1] |= 0x40000000u;
} else {
_has_bits_[1] &= ~0x40000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.center_loss_param)
}
inline ::caffe::CenterLossParameter* LayerParameter::release_center_loss_param() {
_has_bits_[1] &= ~0x40000000u;
::caffe::CenterLossParameter* temp = center_loss_param_;
center_loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::CenterLossParameter* LayerParameter::unsafe_arena_release_center_loss_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.center_loss_param)
_has_bits_[1] &= ~0x40000000u;
::caffe::CenterLossParameter* temp = center_loss_param_;
center_loss_param_ = nullptr;
return temp;
}
inline ::caffe::CenterLossParameter* LayerParameter::_internal_mutable_center_loss_param() {
_has_bits_[1] |= 0x40000000u;
if (center_loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::CenterLossParameter>(GetArenaForAllocation());
center_loss_param_ = p;
}
return center_loss_param_;
}
inline ::caffe::CenterLossParameter* LayerParameter::mutable_center_loss_param() {
::caffe::CenterLossParameter* _msg = _internal_mutable_center_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.center_loss_param)
return _msg;
}
inline void LayerParameter::set_allocated_center_loss_param(::caffe::CenterLossParameter* center_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete center_loss_param_;
}
if (center_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::CenterLossParameter>::GetOwningArena(center_loss_param);
if (message_arena != submessage_arena) {
center_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, center_loss_param, submessage_arena);
}
_has_bits_[1] |= 0x40000000u;
} else {
_has_bits_[1] &= ~0x40000000u;
}
center_loss_param_ = center_loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.center_loss_param)
}
// optional .caffe.ShuffleChannelParameter shuffle_channel_param = 212;
inline bool LayerParameter::_internal_has_shuffle_channel_param() const {
bool value = (_has_bits_[1] & 0x80000000u) != 0;
PROTOBUF_ASSUME(!value || shuffle_channel_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_shuffle_channel_param() const {
return _internal_has_shuffle_channel_param();
}
inline void LayerParameter::clear_shuffle_channel_param() {
if (shuffle_channel_param_ != nullptr) shuffle_channel_param_->Clear();
_has_bits_[1] &= ~0x80000000u;
}
inline const ::caffe::ShuffleChannelParameter& LayerParameter::_internal_shuffle_channel_param() const {
const ::caffe::ShuffleChannelParameter* p = shuffle_channel_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ShuffleChannelParameter&>(
::caffe::_ShuffleChannelParameter_default_instance_);
}
inline const ::caffe::ShuffleChannelParameter& LayerParameter::shuffle_channel_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.shuffle_channel_param)
return _internal_shuffle_channel_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_shuffle_channel_param(
::caffe::ShuffleChannelParameter* shuffle_channel_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shuffle_channel_param_);
}
shuffle_channel_param_ = shuffle_channel_param;
if (shuffle_channel_param) {
_has_bits_[1] |= 0x80000000u;
} else {
_has_bits_[1] &= ~0x80000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.shuffle_channel_param)
}
inline ::caffe::ShuffleChannelParameter* LayerParameter::release_shuffle_channel_param() {
_has_bits_[1] &= ~0x80000000u;
::caffe::ShuffleChannelParameter* temp = shuffle_channel_param_;
shuffle_channel_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ShuffleChannelParameter* LayerParameter::unsafe_arena_release_shuffle_channel_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.shuffle_channel_param)
_has_bits_[1] &= ~0x80000000u;
::caffe::ShuffleChannelParameter* temp = shuffle_channel_param_;
shuffle_channel_param_ = nullptr;
return temp;
}
inline ::caffe::ShuffleChannelParameter* LayerParameter::_internal_mutable_shuffle_channel_param() {
_has_bits_[1] |= 0x80000000u;
if (shuffle_channel_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ShuffleChannelParameter>(GetArenaForAllocation());
shuffle_channel_param_ = p;
}
return shuffle_channel_param_;
}
inline ::caffe::ShuffleChannelParameter* LayerParameter::mutable_shuffle_channel_param() {
::caffe::ShuffleChannelParameter* _msg = _internal_mutable_shuffle_channel_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.shuffle_channel_param)
return _msg;
}
inline void LayerParameter::set_allocated_shuffle_channel_param(::caffe::ShuffleChannelParameter* shuffle_channel_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete shuffle_channel_param_;
}
if (shuffle_channel_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ShuffleChannelParameter>::GetOwningArena(shuffle_channel_param);
if (message_arena != submessage_arena) {
shuffle_channel_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, shuffle_channel_param, submessage_arena);
}
_has_bits_[1] |= 0x80000000u;
} else {
_has_bits_[1] &= ~0x80000000u;
}
shuffle_channel_param_ = shuffle_channel_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.shuffle_channel_param)
}
// optional .caffe.InterpParameter interp_param = 2210;
inline bool LayerParameter::_internal_has_interp_param() const {
bool value = (_has_bits_[2] & 0x00000008u) != 0;
PROTOBUF_ASSUME(!value || interp_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_interp_param() const {
return _internal_has_interp_param();
}
inline void LayerParameter::clear_interp_param() {
if (interp_param_ != nullptr) interp_param_->Clear();
_has_bits_[2] &= ~0x00000008u;
}
inline const ::caffe::InterpParameter& LayerParameter::_internal_interp_param() const {
const ::caffe::InterpParameter* p = interp_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::InterpParameter&>(
::caffe::_InterpParameter_default_instance_);
}
inline const ::caffe::InterpParameter& LayerParameter::interp_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.interp_param)
return _internal_interp_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_interp_param(
::caffe::InterpParameter* interp_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interp_param_);
}
interp_param_ = interp_param;
if (interp_param) {
_has_bits_[2] |= 0x00000008u;
} else {
_has_bits_[2] &= ~0x00000008u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.interp_param)
}
inline ::caffe::InterpParameter* LayerParameter::release_interp_param() {
_has_bits_[2] &= ~0x00000008u;
::caffe::InterpParameter* temp = interp_param_;
interp_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::InterpParameter* LayerParameter::unsafe_arena_release_interp_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.interp_param)
_has_bits_[2] &= ~0x00000008u;
::caffe::InterpParameter* temp = interp_param_;
interp_param_ = nullptr;
return temp;
}
inline ::caffe::InterpParameter* LayerParameter::_internal_mutable_interp_param() {
_has_bits_[2] |= 0x00000008u;
if (interp_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::InterpParameter>(GetArenaForAllocation());
interp_param_ = p;
}
return interp_param_;
}
inline ::caffe::InterpParameter* LayerParameter::mutable_interp_param() {
::caffe::InterpParameter* _msg = _internal_mutable_interp_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.interp_param)
return _msg;
}
inline void LayerParameter::set_allocated_interp_param(::caffe::InterpParameter* interp_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete interp_param_;
}
if (interp_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::InterpParameter>::GetOwningArena(interp_param);
if (message_arena != submessage_arena) {
interp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, interp_param, submessage_arena);
}
_has_bits_[2] |= 0x00000008u;
} else {
_has_bits_[2] &= ~0x00000008u;
}
interp_param_ = interp_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.interp_param)
}
// optional .caffe.ROIPoolingParameter roi_pooling_param = 2201;
inline bool LayerParameter::_internal_has_roi_pooling_param() const {
bool value = (_has_bits_[2] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || roi_pooling_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_roi_pooling_param() const {
return _internal_has_roi_pooling_param();
}
inline void LayerParameter::clear_roi_pooling_param() {
if (roi_pooling_param_ != nullptr) roi_pooling_param_->Clear();
_has_bits_[2] &= ~0x00000001u;
}
inline const ::caffe::ROIPoolingParameter& LayerParameter::_internal_roi_pooling_param() const {
const ::caffe::ROIPoolingParameter* p = roi_pooling_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ROIPoolingParameter&>(
::caffe::_ROIPoolingParameter_default_instance_);
}
inline const ::caffe::ROIPoolingParameter& LayerParameter::roi_pooling_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.roi_pooling_param)
return _internal_roi_pooling_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_roi_pooling_param(
::caffe::ROIPoolingParameter* roi_pooling_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(roi_pooling_param_);
}
roi_pooling_param_ = roi_pooling_param;
if (roi_pooling_param) {
_has_bits_[2] |= 0x00000001u;
} else {
_has_bits_[2] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.roi_pooling_param)
}
inline ::caffe::ROIPoolingParameter* LayerParameter::release_roi_pooling_param() {
_has_bits_[2] &= ~0x00000001u;
::caffe::ROIPoolingParameter* temp = roi_pooling_param_;
roi_pooling_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ROIPoolingParameter* LayerParameter::unsafe_arena_release_roi_pooling_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.roi_pooling_param)
_has_bits_[2] &= ~0x00000001u;
::caffe::ROIPoolingParameter* temp = roi_pooling_param_;
roi_pooling_param_ = nullptr;
return temp;
}
inline ::caffe::ROIPoolingParameter* LayerParameter::_internal_mutable_roi_pooling_param() {
_has_bits_[2] |= 0x00000001u;
if (roi_pooling_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ROIPoolingParameter>(GetArenaForAllocation());
roi_pooling_param_ = p;
}
return roi_pooling_param_;
}
inline ::caffe::ROIPoolingParameter* LayerParameter::mutable_roi_pooling_param() {
::caffe::ROIPoolingParameter* _msg = _internal_mutable_roi_pooling_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.roi_pooling_param)
return _msg;
}
inline void LayerParameter::set_allocated_roi_pooling_param(::caffe::ROIPoolingParameter* roi_pooling_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete roi_pooling_param_;
}
if (roi_pooling_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ROIPoolingParameter>::GetOwningArena(roi_pooling_param);
if (message_arena != submessage_arena) {
roi_pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, roi_pooling_param, submessage_arena);
}
_has_bits_[2] |= 0x00000001u;
} else {
_has_bits_[2] &= ~0x00000001u;
}
roi_pooling_param_ = roi_pooling_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.roi_pooling_param)
}
// optional .caffe.ClipParameter clip_param = 2202;
inline bool LayerParameter::_internal_has_clip_param() const {
bool value = (_has_bits_[2] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || clip_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_clip_param() const {
return _internal_has_clip_param();
}
inline void LayerParameter::clear_clip_param() {
if (clip_param_ != nullptr) clip_param_->Clear();
_has_bits_[2] &= ~0x00000002u;
}
inline const ::caffe::ClipParameter& LayerParameter::_internal_clip_param() const {
const ::caffe::ClipParameter* p = clip_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ClipParameter&>(
::caffe::_ClipParameter_default_instance_);
}
inline const ::caffe::ClipParameter& LayerParameter::clip_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.clip_param)
return _internal_clip_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_clip_param(
::caffe::ClipParameter* clip_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(clip_param_);
}
clip_param_ = clip_param;
if (clip_param) {
_has_bits_[2] |= 0x00000002u;
} else {
_has_bits_[2] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.clip_param)
}
inline ::caffe::ClipParameter* LayerParameter::release_clip_param() {
_has_bits_[2] &= ~0x00000002u;
::caffe::ClipParameter* temp = clip_param_;
clip_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ClipParameter* LayerParameter::unsafe_arena_release_clip_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.clip_param)
_has_bits_[2] &= ~0x00000002u;
::caffe::ClipParameter* temp = clip_param_;
clip_param_ = nullptr;
return temp;
}
inline ::caffe::ClipParameter* LayerParameter::_internal_mutable_clip_param() {
_has_bits_[2] |= 0x00000002u;
if (clip_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ClipParameter>(GetArenaForAllocation());
clip_param_ = p;
}
return clip_param_;
}
inline ::caffe::ClipParameter* LayerParameter::mutable_clip_param() {
::caffe::ClipParameter* _msg = _internal_mutable_clip_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.clip_param)
return _msg;
}
inline void LayerParameter::set_allocated_clip_param(::caffe::ClipParameter* clip_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete clip_param_;
}
if (clip_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ClipParameter>::GetOwningArena(clip_param);
if (message_arena != submessage_arena) {
clip_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, clip_param, submessage_arena);
}
_has_bits_[2] |= 0x00000002u;
} else {
_has_bits_[2] &= ~0x00000002u;
}
clip_param_ = clip_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.clip_param)
}
// optional .caffe.UpsampleParameter upsample_param = 2203;
inline bool LayerParameter::_internal_has_upsample_param() const {
bool value = (_has_bits_[2] & 0x00000004u) != 0;
PROTOBUF_ASSUME(!value || upsample_param_ != nullptr);
return value;
}
inline bool LayerParameter::has_upsample_param() const {
return _internal_has_upsample_param();
}
inline void LayerParameter::clear_upsample_param() {
if (upsample_param_ != nullptr) upsample_param_->Clear();
_has_bits_[2] &= ~0x00000004u;
}
inline const ::caffe::UpsampleParameter& LayerParameter::_internal_upsample_param() const {
const ::caffe::UpsampleParameter* p = upsample_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::UpsampleParameter&>(
::caffe::_UpsampleParameter_default_instance_);
}
inline const ::caffe::UpsampleParameter& LayerParameter::upsample_param() const {
// @@protoc_insertion_point(field_get:caffe.LayerParameter.upsample_param)
return _internal_upsample_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_upsample_param(
::caffe::UpsampleParameter* upsample_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upsample_param_);
}
upsample_param_ = upsample_param;
if (upsample_param) {
_has_bits_[2] |= 0x00000004u;
} else {
_has_bits_[2] &= ~0x00000004u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LayerParameter.upsample_param)
}
inline ::caffe::UpsampleParameter* LayerParameter::release_upsample_param() {
_has_bits_[2] &= ~0x00000004u;
::caffe::UpsampleParameter* temp = upsample_param_;
upsample_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::UpsampleParameter* LayerParameter::unsafe_arena_release_upsample_param() {
// @@protoc_insertion_point(field_release:caffe.LayerParameter.upsample_param)
_has_bits_[2] &= ~0x00000004u;
::caffe::UpsampleParameter* temp = upsample_param_;
upsample_param_ = nullptr;
return temp;
}
inline ::caffe::UpsampleParameter* LayerParameter::_internal_mutable_upsample_param() {
_has_bits_[2] |= 0x00000004u;
if (upsample_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::UpsampleParameter>(GetArenaForAllocation());
upsample_param_ = p;
}
return upsample_param_;
}
inline ::caffe::UpsampleParameter* LayerParameter::mutable_upsample_param() {
::caffe::UpsampleParameter* _msg = _internal_mutable_upsample_param();
// @@protoc_insertion_point(field_mutable:caffe.LayerParameter.upsample_param)
return _msg;
}
inline void LayerParameter::set_allocated_upsample_param(::caffe::UpsampleParameter* upsample_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete upsample_param_;
}
if (upsample_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::UpsampleParameter>::GetOwningArena(upsample_param);
if (message_arena != submessage_arena) {
upsample_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, upsample_param, submessage_arena);
}
_has_bits_[2] |= 0x00000004u;
} else {
_has_bits_[2] &= ~0x00000004u;
}
upsample_param_ = upsample_param;
// @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.upsample_param)
}
// -------------------------------------------------------------------
// ClipParameter
// required float min = 1;
inline bool ClipParameter::_internal_has_min() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ClipParameter::has_min() const {
return _internal_has_min();
}
inline void ClipParameter::clear_min() {
min_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float ClipParameter::_internal_min() const {
return min_;
}
inline float ClipParameter::min() const {
// @@protoc_insertion_point(field_get:caffe.ClipParameter.min)
return _internal_min();
}
inline void ClipParameter::_internal_set_min(float value) {
_has_bits_[0] |= 0x00000001u;
min_ = value;
}
inline void ClipParameter::set_min(float value) {
_internal_set_min(value);
// @@protoc_insertion_point(field_set:caffe.ClipParameter.min)
}
// required float max = 2;
inline bool ClipParameter::_internal_has_max() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ClipParameter::has_max() const {
return _internal_has_max();
}
inline void ClipParameter::clear_max() {
max_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline float ClipParameter::_internal_max() const {
return max_;
}
inline float ClipParameter::max() const {
// @@protoc_insertion_point(field_get:caffe.ClipParameter.max)
return _internal_max();
}
inline void ClipParameter::_internal_set_max(float value) {
_has_bits_[0] |= 0x00000002u;
max_ = value;
}
inline void ClipParameter::set_max(float value) {
_internal_set_max(value);
// @@protoc_insertion_point(field_set:caffe.ClipParameter.max)
}
// -------------------------------------------------------------------
// ROIPoolingParameter
// optional uint32 pooled_h = 1 [default = 0];
inline bool ROIPoolingParameter::_internal_has_pooled_h() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ROIPoolingParameter::has_pooled_h() const {
return _internal_has_pooled_h();
}
inline void ROIPoolingParameter::clear_pooled_h() {
pooled_h_ = 0u;
_has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ROIPoolingParameter::_internal_pooled_h() const {
return pooled_h_;
}
inline uint32_t ROIPoolingParameter::pooled_h() const {
// @@protoc_insertion_point(field_get:caffe.ROIPoolingParameter.pooled_h)
return _internal_pooled_h();
}
inline void ROIPoolingParameter::_internal_set_pooled_h(uint32_t value) {
_has_bits_[0] |= 0x00000001u;
pooled_h_ = value;
}
inline void ROIPoolingParameter::set_pooled_h(uint32_t value) {
_internal_set_pooled_h(value);
// @@protoc_insertion_point(field_set:caffe.ROIPoolingParameter.pooled_h)
}
// optional uint32 pooled_w = 2 [default = 0];
inline bool ROIPoolingParameter::_internal_has_pooled_w() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ROIPoolingParameter::has_pooled_w() const {
return _internal_has_pooled_w();
}
inline void ROIPoolingParameter::clear_pooled_w() {
pooled_w_ = 0u;
_has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ROIPoolingParameter::_internal_pooled_w() const {
return pooled_w_;
}
inline uint32_t ROIPoolingParameter::pooled_w() const {
// @@protoc_insertion_point(field_get:caffe.ROIPoolingParameter.pooled_w)
return _internal_pooled_w();
}
inline void ROIPoolingParameter::_internal_set_pooled_w(uint32_t value) {
_has_bits_[0] |= 0x00000002u;
pooled_w_ = value;
}
inline void ROIPoolingParameter::set_pooled_w(uint32_t value) {
_internal_set_pooled_w(value);
// @@protoc_insertion_point(field_set:caffe.ROIPoolingParameter.pooled_w)
}
// optional float spatial_scale = 3 [default = 1];
inline bool ROIPoolingParameter::_internal_has_spatial_scale() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ROIPoolingParameter::has_spatial_scale() const {
return _internal_has_spatial_scale();
}
inline void ROIPoolingParameter::clear_spatial_scale() {
spatial_scale_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline float ROIPoolingParameter::_internal_spatial_scale() const {
return spatial_scale_;
}
inline float ROIPoolingParameter::spatial_scale() const {
// @@protoc_insertion_point(field_get:caffe.ROIPoolingParameter.spatial_scale)
return _internal_spatial_scale();
}
inline void ROIPoolingParameter::_internal_set_spatial_scale(float value) {
_has_bits_[0] |= 0x00000004u;
spatial_scale_ = value;
}
inline void ROIPoolingParameter::set_spatial_scale(float value) {
_internal_set_spatial_scale(value);
// @@protoc_insertion_point(field_set:caffe.ROIPoolingParameter.spatial_scale)
}
// -------------------------------------------------------------------
// InterpParameter
// optional int32 height = 1 [default = 0];
inline bool InterpParameter::_internal_has_height() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool InterpParameter::has_height() const {
return _internal_has_height();
}
inline void InterpParameter::clear_height() {
height_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t InterpParameter::_internal_height() const {
return height_;
}
inline int32_t InterpParameter::height() const {
// @@protoc_insertion_point(field_get:caffe.InterpParameter.height)
return _internal_height();
}
inline void InterpParameter::_internal_set_height(int32_t value) {
_has_bits_[0] |= 0x00000001u;
height_ = value;
}
inline void InterpParameter::set_height(int32_t value) {
_internal_set_height(value);
// @@protoc_insertion_point(field_set:caffe.InterpParameter.height)
}
// optional int32 width = 2 [default = 0];
inline bool InterpParameter::_internal_has_width() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool InterpParameter::has_width() const {
return _internal_has_width();
}
inline void InterpParameter::clear_width() {
width_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t InterpParameter::_internal_width() const {
return width_;
}
inline int32_t InterpParameter::width() const {
// @@protoc_insertion_point(field_get:caffe.InterpParameter.width)
return _internal_width();
}
inline void InterpParameter::_internal_set_width(int32_t value) {
_has_bits_[0] |= 0x00000002u;
width_ = value;
}
inline void InterpParameter::set_width(int32_t value) {
_internal_set_width(value);
// @@protoc_insertion_point(field_set:caffe.InterpParameter.width)
}
// optional int32 zoom_factor = 3 [default = 1];
inline bool InterpParameter::_internal_has_zoom_factor() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool InterpParameter::has_zoom_factor() const {
return _internal_has_zoom_factor();
}
inline void InterpParameter::clear_zoom_factor() {
zoom_factor_ = 1;
_has_bits_[0] &= ~0x00000010u;
}
inline int32_t InterpParameter::_internal_zoom_factor() const {
return zoom_factor_;
}
inline int32_t InterpParameter::zoom_factor() const {
// @@protoc_insertion_point(field_get:caffe.InterpParameter.zoom_factor)
return _internal_zoom_factor();
}
inline void InterpParameter::_internal_set_zoom_factor(int32_t value) {
_has_bits_[0] |= 0x00000010u;
zoom_factor_ = value;
}
inline void InterpParameter::set_zoom_factor(int32_t value) {
_internal_set_zoom_factor(value);
// @@protoc_insertion_point(field_set:caffe.InterpParameter.zoom_factor)
}
// optional int32 shrink_factor = 4 [default = 1];
inline bool InterpParameter::_internal_has_shrink_factor() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool InterpParameter::has_shrink_factor() const {
return _internal_has_shrink_factor();
}
inline void InterpParameter::clear_shrink_factor() {
shrink_factor_ = 1;
_has_bits_[0] &= ~0x00000020u;
}
inline int32_t InterpParameter::_internal_shrink_factor() const {
return shrink_factor_;
}
inline int32_t InterpParameter::shrink_factor() const {
// @@protoc_insertion_point(field_get:caffe.InterpParameter.shrink_factor)
return _internal_shrink_factor();
}
inline void InterpParameter::_internal_set_shrink_factor(int32_t value) {
_has_bits_[0] |= 0x00000020u;
shrink_factor_ = value;
}
inline void InterpParameter::set_shrink_factor(int32_t value) {
_internal_set_shrink_factor(value);
// @@protoc_insertion_point(field_set:caffe.InterpParameter.shrink_factor)
}
// optional int32 pad_beg = 5 [default = 0];
inline bool InterpParameter::_internal_has_pad_beg() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool InterpParameter::has_pad_beg() const {
return _internal_has_pad_beg();
}
inline void InterpParameter::clear_pad_beg() {
pad_beg_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t InterpParameter::_internal_pad_beg() const {
return pad_beg_;
}
inline int32_t InterpParameter::pad_beg() const {
// @@protoc_insertion_point(field_get:caffe.InterpParameter.pad_beg)
return _internal_pad_beg();
}
inline void InterpParameter::_internal_set_pad_beg(int32_t value) {
_has_bits_[0] |= 0x00000004u;
pad_beg_ = value;
}
inline void InterpParameter::set_pad_beg(int32_t value) {
_internal_set_pad_beg(value);
// @@protoc_insertion_point(field_set:caffe.InterpParameter.pad_beg)
}
// optional int32 pad_end = 6 [default = 0];
inline bool InterpParameter::_internal_has_pad_end() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool InterpParameter::has_pad_end() const {
return _internal_has_pad_end();
}
inline void InterpParameter::clear_pad_end() {
pad_end_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline int32_t InterpParameter::_internal_pad_end() const {
return pad_end_;
}
inline int32_t InterpParameter::pad_end() const {
// @@protoc_insertion_point(field_get:caffe.InterpParameter.pad_end)
return _internal_pad_end();
}
inline void InterpParameter::_internal_set_pad_end(int32_t value) {
_has_bits_[0] |= 0x00000008u;
pad_end_ = value;
}
inline void InterpParameter::set_pad_end(int32_t value) {
_internal_set_pad_end(value);
// @@protoc_insertion_point(field_set:caffe.InterpParameter.pad_end)
}
// -------------------------------------------------------------------
// LSTMParameter
// optional uint32 num_output = 1;
inline bool LSTMParameter::_internal_has_num_output() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool LSTMParameter::has_num_output() const {
return _internal_has_num_output();
}
inline void LSTMParameter::clear_num_output() {
num_output_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t LSTMParameter::_internal_num_output() const {
return num_output_;
}
inline uint32_t LSTMParameter::num_output() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.num_output)
return _internal_num_output();
}
inline void LSTMParameter::_internal_set_num_output(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
num_output_ = value;
}
inline void LSTMParameter::set_num_output(uint32_t value) {
_internal_set_num_output(value);
// @@protoc_insertion_point(field_set:caffe.LSTMParameter.num_output)
}
// optional float clipping_threshold = 2 [default = 0];
inline bool LSTMParameter::_internal_has_clipping_threshold() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool LSTMParameter::has_clipping_threshold() const {
return _internal_has_clipping_threshold();
}
inline void LSTMParameter::clear_clipping_threshold() {
clipping_threshold_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline float LSTMParameter::_internal_clipping_threshold() const {
return clipping_threshold_;
}
inline float LSTMParameter::clipping_threshold() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.clipping_threshold)
return _internal_clipping_threshold();
}
inline void LSTMParameter::_internal_set_clipping_threshold(float value) {
_has_bits_[0] |= 0x00000008u;
clipping_threshold_ = value;
}
inline void LSTMParameter::set_clipping_threshold(float value) {
_internal_set_clipping_threshold(value);
// @@protoc_insertion_point(field_set:caffe.LSTMParameter.clipping_threshold)
}
// optional .caffe.FillerParameter weight_filler = 3;
inline bool LSTMParameter::_internal_has_weight_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || weight_filler_ != nullptr);
return value;
}
inline bool LSTMParameter::has_weight_filler() const {
return _internal_has_weight_filler();
}
inline void LSTMParameter::clear_weight_filler() {
if (weight_filler_ != nullptr) weight_filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& LSTMParameter::_internal_weight_filler() const {
const ::caffe::FillerParameter* p = weight_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& LSTMParameter::weight_filler() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.weight_filler)
return _internal_weight_filler();
}
inline void LSTMParameter::unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_);
}
weight_filler_ = weight_filler;
if (weight_filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LSTMParameter.weight_filler)
}
inline ::caffe::FillerParameter* LSTMParameter::release_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* LSTMParameter::unsafe_arena_release_weight_filler() {
// @@protoc_insertion_point(field_release:caffe.LSTMParameter.weight_filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* LSTMParameter::_internal_mutable_weight_filler() {
_has_bits_[0] |= 0x00000001u;
if (weight_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
weight_filler_ = p;
}
return weight_filler_;
}
inline ::caffe::FillerParameter* LSTMParameter::mutable_weight_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
// @@protoc_insertion_point(field_mutable:caffe.LSTMParameter.weight_filler)
return _msg;
}
inline void LSTMParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete weight_filler_;
}
if (weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(weight_filler);
if (message_arena != submessage_arena) {
weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.LSTMParameter.weight_filler)
}
// optional .caffe.FillerParameter bias_filler = 4;
inline bool LSTMParameter::_internal_has_bias_filler() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || bias_filler_ != nullptr);
return value;
}
inline bool LSTMParameter::has_bias_filler() const {
return _internal_has_bias_filler();
}
inline void LSTMParameter::clear_bias_filler() {
if (bias_filler_ != nullptr) bias_filler_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::FillerParameter& LSTMParameter::_internal_bias_filler() const {
const ::caffe::FillerParameter* p = bias_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& LSTMParameter::bias_filler() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.bias_filler)
return _internal_bias_filler();
}
inline void LSTMParameter::unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_);
}
bias_filler_ = bias_filler;
if (bias_filler) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.LSTMParameter.bias_filler)
}
inline ::caffe::FillerParameter* LSTMParameter::release_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* LSTMParameter::unsafe_arena_release_bias_filler() {
// @@protoc_insertion_point(field_release:caffe.LSTMParameter.bias_filler)
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* LSTMParameter::_internal_mutable_bias_filler() {
_has_bits_[0] |= 0x00000002u;
if (bias_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
bias_filler_ = p;
}
return bias_filler_;
}
inline ::caffe::FillerParameter* LSTMParameter::mutable_bias_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
// @@protoc_insertion_point(field_mutable:caffe.LSTMParameter.bias_filler)
return _msg;
}
inline void LSTMParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_filler_;
}
if (bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(bias_filler);
if (message_arena != submessage_arena) {
bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.LSTMParameter.bias_filler)
}
// optional uint32 batch_size = 5 [default = 1];
inline bool LSTMParameter::_internal_has_batch_size() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool LSTMParameter::has_batch_size() const {
return _internal_has_batch_size();
}
inline void LSTMParameter::clear_batch_size() {
batch_size_ = 1u;
_has_bits_[0] &= ~0x00000100u;
}
inline uint32_t LSTMParameter::_internal_batch_size() const {
return batch_size_;
}
inline uint32_t LSTMParameter::batch_size() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.batch_size)
return _internal_batch_size();
}
inline void LSTMParameter::_internal_set_batch_size(uint32_t value) {
_has_bits_[0] |= 0x00000100u;
batch_size_ = value;
}
inline void LSTMParameter::set_batch_size(uint32_t value) {
_internal_set_batch_size(value);
// @@protoc_insertion_point(field_set:caffe.LSTMParameter.batch_size)
}
// optional uint32 paramq = 6;
inline bool LSTMParameter::_internal_has_paramq() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool LSTMParameter::has_paramq() const {
return _internal_has_paramq();
}
inline void LSTMParameter::clear_paramq() {
paramq_ = 0u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t LSTMParameter::_internal_paramq() const {
return paramq_;
}
inline uint32_t LSTMParameter::paramq() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.paramq)
return _internal_paramq();
}
inline void LSTMParameter::_internal_set_paramq(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
paramq_ = value;
}
inline void LSTMParameter::set_paramq(uint32_t value) {
_internal_set_paramq(value);
// @@protoc_insertion_point(field_set:caffe.LSTMParameter.paramq)
}
// optional float scale_in = 7;
inline bool LSTMParameter::_internal_has_scale_in() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool LSTMParameter::has_scale_in() const {
return _internal_has_scale_in();
}
inline void LSTMParameter::clear_scale_in() {
scale_in_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline float LSTMParameter::_internal_scale_in() const {
return scale_in_;
}
inline float LSTMParameter::scale_in() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.scale_in)
return _internal_scale_in();
}
inline void LSTMParameter::_internal_set_scale_in(float value) {
_has_bits_[0] |= 0x00000020u;
scale_in_ = value;
}
inline void LSTMParameter::set_scale_in(float value) {
_internal_set_scale_in(value);
// @@protoc_insertion_point(field_set:caffe.LSTMParameter.scale_in)
}
// optional float scale_out = 8;
inline bool LSTMParameter::_internal_has_scale_out() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool LSTMParameter::has_scale_out() const {
return _internal_has_scale_out();
}
inline void LSTMParameter::clear_scale_out() {
scale_out_ = 0;
_has_bits_[0] &= ~0x00000040u;
}
inline float LSTMParameter::_internal_scale_out() const {
return scale_out_;
}
inline float LSTMParameter::scale_out() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.scale_out)
return _internal_scale_out();
}
inline void LSTMParameter::_internal_set_scale_out(float value) {
_has_bits_[0] |= 0x00000040u;
scale_out_ = value;
}
inline void LSTMParameter::set_scale_out(float value) {
_internal_set_scale_out(value);
// @@protoc_insertion_point(field_set:caffe.LSTMParameter.scale_out)
}
// optional int32 a_min = 9 [default = -128];
inline bool LSTMParameter::_internal_has_a_min() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool LSTMParameter::has_a_min() const {
return _internal_has_a_min();
}
inline void LSTMParameter::clear_a_min() {
a_min_ = -128;
_has_bits_[0] &= ~0x00000200u;
}
inline int32_t LSTMParameter::_internal_a_min() const {
return a_min_;
}
inline int32_t LSTMParameter::a_min() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.a_min)
return _internal_a_min();
}
inline void LSTMParameter::_internal_set_a_min(int32_t value) {
_has_bits_[0] |= 0x00000200u;
a_min_ = value;
}
inline void LSTMParameter::set_a_min(int32_t value) {
_internal_set_a_min(value);
// @@protoc_insertion_point(field_set:caffe.LSTMParameter.a_min)
}
// optional int32 a_max = 10 [default = 127];
inline bool LSTMParameter::_internal_has_a_max() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool LSTMParameter::has_a_max() const {
return _internal_has_a_max();
}
inline void LSTMParameter::clear_a_max() {
a_max_ = 127;
_has_bits_[0] &= ~0x00000080u;
}
inline int32_t LSTMParameter::_internal_a_max() const {
return a_max_;
}
inline int32_t LSTMParameter::a_max() const {
// @@protoc_insertion_point(field_get:caffe.LSTMParameter.a_max)
return _internal_a_max();
}
inline void LSTMParameter::_internal_set_a_max(int32_t value) {
_has_bits_[0] |= 0x00000080u;
a_max_ = value;
}
inline void LSTMParameter::set_a_max(int32_t value) {
_internal_set_a_max(value);
// @@protoc_insertion_point(field_set:caffe.LSTMParameter.a_max)
}
// -------------------------------------------------------------------
// Im2seqParameter
// optional .caffe.Im2seqParameter.Direction direction = 1 [default = FORWARD];
inline bool Im2seqParameter::_internal_has_direction() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool Im2seqParameter::has_direction() const {
return _internal_has_direction();
}
inline void Im2seqParameter::clear_direction() {
direction_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::Im2seqParameter_Direction Im2seqParameter::_internal_direction() const {
return static_cast< ::caffe::Im2seqParameter_Direction >(direction_);
}
inline ::caffe::Im2seqParameter_Direction Im2seqParameter::direction() const {
// @@protoc_insertion_point(field_get:caffe.Im2seqParameter.direction)
return _internal_direction();
}
inline void Im2seqParameter::_internal_set_direction(::caffe::Im2seqParameter_Direction value) {
assert(::caffe::Im2seqParameter_Direction_IsValid(value));
_has_bits_[0] |= 0x00000001u;
direction_ = value;
}
inline void Im2seqParameter::set_direction(::caffe::Im2seqParameter_Direction value) {
_internal_set_direction(value);
// @@protoc_insertion_point(field_set:caffe.Im2seqParameter.direction)
}
// optional uint32 size = 2 [default = 1];
inline bool Im2seqParameter::_internal_has_size() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool Im2seqParameter::has_size() const {
return _internal_has_size();
}
inline void Im2seqParameter::clear_size() {
size_ = 1u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t Im2seqParameter::_internal_size() const {
return size_;
}
inline uint32_t Im2seqParameter::size() const {
// @@protoc_insertion_point(field_get:caffe.Im2seqParameter.size)
return _internal_size();
}
inline void Im2seqParameter::_internal_set_size(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
size_ = value;
}
inline void Im2seqParameter::set_size(uint32_t value) {
_internal_set_size(value);
// @@protoc_insertion_point(field_set:caffe.Im2seqParameter.size)
}
// optional uint32 stride = 3 [default = 1];
inline bool Im2seqParameter::_internal_has_stride() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool Im2seqParameter::has_stride() const {
return _internal_has_stride();
}
inline void Im2seqParameter::clear_stride() {
stride_ = 1u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Im2seqParameter::_internal_stride() const {
return stride_;
}
inline uint32_t Im2seqParameter::stride() const {
// @@protoc_insertion_point(field_get:caffe.Im2seqParameter.stride)
return _internal_stride();
}
inline void Im2seqParameter::_internal_set_stride(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
stride_ = value;
}
inline void Im2seqParameter::set_stride(uint32_t value) {
_internal_set_stride(value);
// @@protoc_insertion_point(field_set:caffe.Im2seqParameter.stride)
}
// optional bool line2time_loss = 4 [default = false];
inline bool Im2seqParameter::_internal_has_line2time_loss() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool Im2seqParameter::has_line2time_loss() const {
return _internal_has_line2time_loss();
}
inline void Im2seqParameter::clear_line2time_loss() {
line2time_loss_ = false;
_has_bits_[0] &= ~0x00000002u;
}
inline bool Im2seqParameter::_internal_line2time_loss() const {
return line2time_loss_;
}
inline bool Im2seqParameter::line2time_loss() const {
// @@protoc_insertion_point(field_get:caffe.Im2seqParameter.line2time_loss)
return _internal_line2time_loss();
}
inline void Im2seqParameter::_internal_set_line2time_loss(bool value) {
_has_bits_[0] |= 0x00000002u;
line2time_loss_ = value;
}
inline void Im2seqParameter::set_line2time_loss(bool value) {
_internal_set_line2time_loss(value);
// @@protoc_insertion_point(field_set:caffe.Im2seqParameter.line2time_loss)
}
// -------------------------------------------------------------------
// CenterLossParameter
// optional uint32 num_output = 1;
inline bool CenterLossParameter::_internal_has_num_output() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool CenterLossParameter::has_num_output() const {
return _internal_has_num_output();
}
inline void CenterLossParameter::clear_num_output() {
num_output_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CenterLossParameter::_internal_num_output() const {
return num_output_;
}
inline uint32_t CenterLossParameter::num_output() const {
// @@protoc_insertion_point(field_get:caffe.CenterLossParameter.num_output)
return _internal_num_output();
}
inline void CenterLossParameter::_internal_set_num_output(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
num_output_ = value;
}
inline void CenterLossParameter::set_num_output(uint32_t value) {
_internal_set_num_output(value);
// @@protoc_insertion_point(field_set:caffe.CenterLossParameter.num_output)
}
// optional .caffe.FillerParameter center_filler = 2;
inline bool CenterLossParameter::_internal_has_center_filler() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || center_filler_ != nullptr);
return value;
}
inline bool CenterLossParameter::has_center_filler() const {
return _internal_has_center_filler();
}
inline void CenterLossParameter::clear_center_filler() {
if (center_filler_ != nullptr) center_filler_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::FillerParameter& CenterLossParameter::_internal_center_filler() const {
const ::caffe::FillerParameter* p = center_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& CenterLossParameter::center_filler() const {
// @@protoc_insertion_point(field_get:caffe.CenterLossParameter.center_filler)
return _internal_center_filler();
}
inline void CenterLossParameter::unsafe_arena_set_allocated_center_filler(
::caffe::FillerParameter* center_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(center_filler_);
}
center_filler_ = center_filler;
if (center_filler) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.CenterLossParameter.center_filler)
}
inline ::caffe::FillerParameter* CenterLossParameter::release_center_filler() {
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = center_filler_;
center_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* CenterLossParameter::unsafe_arena_release_center_filler() {
// @@protoc_insertion_point(field_release:caffe.CenterLossParameter.center_filler)
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = center_filler_;
center_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* CenterLossParameter::_internal_mutable_center_filler() {
_has_bits_[0] |= 0x00000002u;
if (center_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
center_filler_ = p;
}
return center_filler_;
}
inline ::caffe::FillerParameter* CenterLossParameter::mutable_center_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_center_filler();
// @@protoc_insertion_point(field_mutable:caffe.CenterLossParameter.center_filler)
return _msg;
}
inline void CenterLossParameter::set_allocated_center_filler(::caffe::FillerParameter* center_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete center_filler_;
}
if (center_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(center_filler);
if (message_arena != submessage_arena) {
center_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, center_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
center_filler_ = center_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.CenterLossParameter.center_filler)
}
// optional int32 axis = 3 [default = 1];
inline bool CenterLossParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool CenterLossParameter::has_axis() const {
return _internal_has_axis();
}
inline void CenterLossParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000008u;
}
inline int32_t CenterLossParameter::_internal_axis() const {
return axis_;
}
inline int32_t CenterLossParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.CenterLossParameter.axis)
return _internal_axis();
}
inline void CenterLossParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000008u;
axis_ = value;
}
inline void CenterLossParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.CenterLossParameter.axis)
}
// optional string distance_type = 29 [default = "L2"];
inline bool CenterLossParameter::_internal_has_distance_type() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool CenterLossParameter::has_distance_type() const {
return _internal_has_distance_type();
}
inline void CenterLossParameter::clear_distance_type() {
distance_type_.ClearToDefault(::caffe::CenterLossParameter::_i_give_permission_to_break_this_code_default_distance_type_, GetArenaForAllocation());
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CenterLossParameter::distance_type() const {
// @@protoc_insertion_point(field_get:caffe.CenterLossParameter.distance_type)
if (distance_type_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_distance_type_.get();
return _internal_distance_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CenterLossParameter::set_distance_type(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
distance_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.CenterLossParameter.distance_type)
}
inline std::string* CenterLossParameter::mutable_distance_type() {
std::string* _s = _internal_mutable_distance_type();
// @@protoc_insertion_point(field_mutable:caffe.CenterLossParameter.distance_type)
return _s;
}
inline const std::string& CenterLossParameter::_internal_distance_type() const {
return distance_type_.Get();
}
inline void CenterLossParameter::_internal_set_distance_type(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
distance_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CenterLossParameter::_internal_mutable_distance_type() {
_has_bits_[0] |= 0x00000001u;
return distance_type_.Mutable(::caffe::CenterLossParameter::_i_give_permission_to_break_this_code_default_distance_type_, GetArenaForAllocation());
}
inline std::string* CenterLossParameter::release_distance_type() {
// @@protoc_insertion_point(field_release:caffe.CenterLossParameter.distance_type)
if (!_internal_has_distance_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = distance_type_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
return p;
}
inline void CenterLossParameter::set_allocated_distance_type(std::string* distance_type) {
if (distance_type != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
distance_type_.SetAllocated(nullptr, distance_type,
GetArenaForAllocation());
// @@protoc_insertion_point(field_set_allocated:caffe.CenterLossParameter.distance_type)
}
// -------------------------------------------------------------------
// Seq2outParameter
// -------------------------------------------------------------------
// ImgSizeParameter
// optional float x_scaling = 1 [default = 1];
inline bool ImgSizeParameter::_internal_has_x_scaling() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool ImgSizeParameter::has_x_scaling() const {
return _internal_has_x_scaling();
}
inline void ImgSizeParameter::clear_x_scaling() {
x_scaling_ = 1;
_has_bits_[0] &= ~0x00000008u;
}
inline float ImgSizeParameter::_internal_x_scaling() const {
return x_scaling_;
}
inline float ImgSizeParameter::x_scaling() const {
// @@protoc_insertion_point(field_get:caffe.ImgSizeParameter.x_scaling)
return _internal_x_scaling();
}
inline void ImgSizeParameter::_internal_set_x_scaling(float value) {
_has_bits_[0] |= 0x00000008u;
x_scaling_ = value;
}
inline void ImgSizeParameter::set_x_scaling(float value) {
_internal_set_x_scaling(value);
// @@protoc_insertion_point(field_set:caffe.ImgSizeParameter.x_scaling)
}
// optional float y_scaling = 2 [default = 1];
inline bool ImgSizeParameter::_internal_has_y_scaling() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool ImgSizeParameter::has_y_scaling() const {
return _internal_has_y_scaling();
}
inline void ImgSizeParameter::clear_y_scaling() {
y_scaling_ = 1;
_has_bits_[0] &= ~0x00000010u;
}
inline float ImgSizeParameter::_internal_y_scaling() const {
return y_scaling_;
}
inline float ImgSizeParameter::y_scaling() const {
// @@protoc_insertion_point(field_get:caffe.ImgSizeParameter.y_scaling)
return _internal_y_scaling();
}
inline void ImgSizeParameter::_internal_set_y_scaling(float value) {
_has_bits_[0] |= 0x00000010u;
y_scaling_ = value;
}
inline void ImgSizeParameter::set_y_scaling(float value) {
_internal_set_y_scaling(value);
// @@protoc_insertion_point(field_set:caffe.ImgSizeParameter.y_scaling)
}
// optional string pretrained_file = 500;
inline bool ImgSizeParameter::_internal_has_pretrained_file() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ImgSizeParameter::has_pretrained_file() const {
return _internal_has_pretrained_file();
}
inline void ImgSizeParameter::clear_pretrained_file() {
pretrained_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ImgSizeParameter::pretrained_file() const {
// @@protoc_insertion_point(field_get:caffe.ImgSizeParameter.pretrained_file)
return _internal_pretrained_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ImgSizeParameter::set_pretrained_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
pretrained_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.ImgSizeParameter.pretrained_file)
}
inline std::string* ImgSizeParameter::mutable_pretrained_file() {
std::string* _s = _internal_mutable_pretrained_file();
// @@protoc_insertion_point(field_mutable:caffe.ImgSizeParameter.pretrained_file)
return _s;
}
inline const std::string& ImgSizeParameter::_internal_pretrained_file() const {
return pretrained_file_.Get();
}
inline void ImgSizeParameter::_internal_set_pretrained_file(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
pretrained_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ImgSizeParameter::_internal_mutable_pretrained_file() {
_has_bits_[0] |= 0x00000001u;
return pretrained_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ImgSizeParameter::release_pretrained_file() {
// @@protoc_insertion_point(field_release:caffe.ImgSizeParameter.pretrained_file)
if (!_internal_has_pretrained_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = pretrained_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (pretrained_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
pretrained_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ImgSizeParameter::set_allocated_pretrained_file(std::string* pretrained_file) {
if (pretrained_file != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
pretrained_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pretrained_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (pretrained_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
pretrained_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.ImgSizeParameter.pretrained_file)
}
// optional string pretrained_layer_name = 501;
inline bool ImgSizeParameter::_internal_has_pretrained_layer_name() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ImgSizeParameter::has_pretrained_layer_name() const {
return _internal_has_pretrained_layer_name();
}
inline void ImgSizeParameter::clear_pretrained_layer_name() {
pretrained_layer_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ImgSizeParameter::pretrained_layer_name() const {
// @@protoc_insertion_point(field_get:caffe.ImgSizeParameter.pretrained_layer_name)
return _internal_pretrained_layer_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ImgSizeParameter::set_pretrained_layer_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
pretrained_layer_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.ImgSizeParameter.pretrained_layer_name)
}
inline std::string* ImgSizeParameter::mutable_pretrained_layer_name() {
std::string* _s = _internal_mutable_pretrained_layer_name();
// @@protoc_insertion_point(field_mutable:caffe.ImgSizeParameter.pretrained_layer_name)
return _s;
}
inline const std::string& ImgSizeParameter::_internal_pretrained_layer_name() const {
return pretrained_layer_name_.Get();
}
inline void ImgSizeParameter::_internal_set_pretrained_layer_name(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
pretrained_layer_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ImgSizeParameter::_internal_mutable_pretrained_layer_name() {
_has_bits_[0] |= 0x00000002u;
return pretrained_layer_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ImgSizeParameter::release_pretrained_layer_name() {
// @@protoc_insertion_point(field_release:caffe.ImgSizeParameter.pretrained_layer_name)
if (!_internal_has_pretrained_layer_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = pretrained_layer_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (pretrained_layer_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
pretrained_layer_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ImgSizeParameter::set_allocated_pretrained_layer_name(std::string* pretrained_layer_name) {
if (pretrained_layer_name != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
pretrained_layer_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pretrained_layer_name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (pretrained_layer_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
pretrained_layer_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.ImgSizeParameter.pretrained_layer_name)
}
// optional string pretrained_layer_bin = 502;
inline bool ImgSizeParameter::_internal_has_pretrained_layer_bin() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ImgSizeParameter::has_pretrained_layer_bin() const {
return _internal_has_pretrained_layer_bin();
}
inline void ImgSizeParameter::clear_pretrained_layer_bin() {
pretrained_layer_bin_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ImgSizeParameter::pretrained_layer_bin() const {
// @@protoc_insertion_point(field_get:caffe.ImgSizeParameter.pretrained_layer_bin)
return _internal_pretrained_layer_bin();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ImgSizeParameter::set_pretrained_layer_bin(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
pretrained_layer_bin_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.ImgSizeParameter.pretrained_layer_bin)
}
inline std::string* ImgSizeParameter::mutable_pretrained_layer_bin() {
std::string* _s = _internal_mutable_pretrained_layer_bin();
// @@protoc_insertion_point(field_mutable:caffe.ImgSizeParameter.pretrained_layer_bin)
return _s;
}
inline const std::string& ImgSizeParameter::_internal_pretrained_layer_bin() const {
return pretrained_layer_bin_.Get();
}
inline void ImgSizeParameter::_internal_set_pretrained_layer_bin(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
pretrained_layer_bin_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ImgSizeParameter::_internal_mutable_pretrained_layer_bin() {
_has_bits_[0] |= 0x00000004u;
return pretrained_layer_bin_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ImgSizeParameter::release_pretrained_layer_bin() {
// @@protoc_insertion_point(field_release:caffe.ImgSizeParameter.pretrained_layer_bin)
if (!_internal_has_pretrained_layer_bin()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = pretrained_layer_bin_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (pretrained_layer_bin_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
pretrained_layer_bin_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ImgSizeParameter::set_allocated_pretrained_layer_bin(std::string* pretrained_layer_bin) {
if (pretrained_layer_bin != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
pretrained_layer_bin_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pretrained_layer_bin,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (pretrained_layer_bin_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
pretrained_layer_bin_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.ImgSizeParameter.pretrained_layer_bin)
}
// -------------------------------------------------------------------
// TransformationParameter
// optional float scale = 1 [default = 1];
inline bool TransformationParameter::_internal_has_scale() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool TransformationParameter::has_scale() const {
return _internal_has_scale();
}
inline void TransformationParameter::clear_scale() {
scale_ = 1;
_has_bits_[0] &= ~0x00001000u;
}
inline float TransformationParameter::_internal_scale() const {
return scale_;
}
inline float TransformationParameter::scale() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.scale)
return _internal_scale();
}
inline void TransformationParameter::_internal_set_scale(float value) {
_has_bits_[0] |= 0x00001000u;
scale_ = value;
}
inline void TransformationParameter::set_scale(float value) {
_internal_set_scale(value);
// @@protoc_insertion_point(field_set:caffe.TransformationParameter.scale)
}
// optional bool mirror = 2 [default = false];
inline bool TransformationParameter::_internal_has_mirror() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool TransformationParameter::has_mirror() const {
return _internal_has_mirror();
}
inline void TransformationParameter::clear_mirror() {
mirror_ = false;
_has_bits_[0] &= ~0x00000080u;
}
inline bool TransformationParameter::_internal_mirror() const {
return mirror_;
}
inline bool TransformationParameter::mirror() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.mirror)
return _internal_mirror();
}
inline void TransformationParameter::_internal_set_mirror(bool value) {
_has_bits_[0] |= 0x00000080u;
mirror_ = value;
}
inline void TransformationParameter::set_mirror(bool value) {
_internal_set_mirror(value);
// @@protoc_insertion_point(field_set:caffe.TransformationParameter.mirror)
}
// optional uint32 crop_size = 3 [default = 0];
inline bool TransformationParameter::_internal_has_crop_size() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool TransformationParameter::has_crop_size() const {
return _internal_has_crop_size();
}
inline void TransformationParameter::clear_crop_size() {
crop_size_ = 0u;
_has_bits_[0] &= ~0x00000040u;
}
inline uint32_t TransformationParameter::_internal_crop_size() const {
return crop_size_;
}
inline uint32_t TransformationParameter::crop_size() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.crop_size)
return _internal_crop_size();
}
inline void TransformationParameter::_internal_set_crop_size(uint32_t value) {
_has_bits_[0] |= 0x00000040u;
crop_size_ = value;
}
inline void TransformationParameter::set_crop_size(uint32_t value) {
_internal_set_crop_size(value);
// @@protoc_insertion_point(field_set:caffe.TransformationParameter.crop_size)
}
// optional uint32 crop_h = 11 [default = 0];
inline bool TransformationParameter::_internal_has_crop_h() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool TransformationParameter::has_crop_h() const {
return _internal_has_crop_h();
}
inline void TransformationParameter::clear_crop_h() {
crop_h_ = 0u;
_has_bits_[0] &= ~0x00000400u;
}
inline uint32_t TransformationParameter::_internal_crop_h() const {
return crop_h_;
}
inline uint32_t TransformationParameter::crop_h() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.crop_h)
return _internal_crop_h();
}
inline void TransformationParameter::_internal_set_crop_h(uint32_t value) {
_has_bits_[0] |= 0x00000400u;
crop_h_ = value;
}
inline void TransformationParameter::set_crop_h(uint32_t value) {
_internal_set_crop_h(value);
// @@protoc_insertion_point(field_set:caffe.TransformationParameter.crop_h)
}
// optional uint32 crop_w = 12 [default = 0];
inline bool TransformationParameter::_internal_has_crop_w() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool TransformationParameter::has_crop_w() const {
return _internal_has_crop_w();
}
inline void TransformationParameter::clear_crop_w() {
crop_w_ = 0u;
_has_bits_[0] &= ~0x00000800u;
}
inline uint32_t TransformationParameter::_internal_crop_w() const {
return crop_w_;
}
inline uint32_t TransformationParameter::crop_w() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.crop_w)
return _internal_crop_w();
}
inline void TransformationParameter::_internal_set_crop_w(uint32_t value) {
_has_bits_[0] |= 0x00000800u;
crop_w_ = value;
}
inline void TransformationParameter::set_crop_w(uint32_t value) {
_internal_set_crop_w(value);
// @@protoc_insertion_point(field_set:caffe.TransformationParameter.crop_w)
}
// optional string mean_file = 4;
inline bool TransformationParameter::_internal_has_mean_file() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool TransformationParameter::has_mean_file() const {
return _internal_has_mean_file();
}
inline void TransformationParameter::clear_mean_file() {
mean_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TransformationParameter::mean_file() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.mean_file)
return _internal_mean_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TransformationParameter::set_mean_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.TransformationParameter.mean_file)
}
inline std::string* TransformationParameter::mutable_mean_file() {
std::string* _s = _internal_mutable_mean_file();
// @@protoc_insertion_point(field_mutable:caffe.TransformationParameter.mean_file)
return _s;
}
inline const std::string& TransformationParameter::_internal_mean_file() const {
return mean_file_.Get();
}
inline void TransformationParameter::_internal_set_mean_file(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TransformationParameter::_internal_mutable_mean_file() {
_has_bits_[0] |= 0x00000001u;
return mean_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TransformationParameter::release_mean_file() {
// @@protoc_insertion_point(field_release:caffe.TransformationParameter.mean_file)
if (!_internal_has_mean_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = mean_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void TransformationParameter::set_allocated_mean_file(std::string* mean_file) {
if (mean_file != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
mean_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mean_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.TransformationParameter.mean_file)
}
// repeated float mean_value = 5;
inline int TransformationParameter::_internal_mean_value_size() const {
return mean_value_.size();
}
inline int TransformationParameter::mean_value_size() const {
return _internal_mean_value_size();
}
inline void TransformationParameter::clear_mean_value() {
mean_value_.Clear();
}
inline float TransformationParameter::_internal_mean_value(int index) const {
return mean_value_.Get(index);
}
inline float TransformationParameter::mean_value(int index) const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.mean_value)
return _internal_mean_value(index);
}
inline void TransformationParameter::set_mean_value(int index, float value) {
mean_value_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.TransformationParameter.mean_value)
}
inline void TransformationParameter::_internal_add_mean_value(float value) {
mean_value_.Add(value);
}
inline void TransformationParameter::add_mean_value(float value) {
_internal_add_mean_value(value);
// @@protoc_insertion_point(field_add:caffe.TransformationParameter.mean_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
TransformationParameter::_internal_mean_value() const {
return mean_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
TransformationParameter::mean_value() const {
// @@protoc_insertion_point(field_list:caffe.TransformationParameter.mean_value)
return _internal_mean_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
TransformationParameter::_internal_mutable_mean_value() {
return &mean_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
TransformationParameter::mutable_mean_value() {
// @@protoc_insertion_point(field_mutable_list:caffe.TransformationParameter.mean_value)
return _internal_mutable_mean_value();
}
// optional bool force_color = 6 [default = false];
inline bool TransformationParameter::_internal_has_force_color() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool TransformationParameter::has_force_color() const {
return _internal_has_force_color();
}
inline void TransformationParameter::clear_force_color() {
force_color_ = false;
_has_bits_[0] &= ~0x00000100u;
}
inline bool TransformationParameter::_internal_force_color() const {
return force_color_;
}
inline bool TransformationParameter::force_color() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.force_color)
return _internal_force_color();
}
inline void TransformationParameter::_internal_set_force_color(bool value) {
_has_bits_[0] |= 0x00000100u;
force_color_ = value;
}
inline void TransformationParameter::set_force_color(bool value) {
_internal_set_force_color(value);
// @@protoc_insertion_point(field_set:caffe.TransformationParameter.force_color)
}
// optional bool force_gray = 7 [default = false];
inline bool TransformationParameter::_internal_has_force_gray() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool TransformationParameter::has_force_gray() const {
return _internal_has_force_gray();
}
inline void TransformationParameter::clear_force_gray() {
force_gray_ = false;
_has_bits_[0] &= ~0x00000200u;
}
inline bool TransformationParameter::_internal_force_gray() const {
return force_gray_;
}
inline bool TransformationParameter::force_gray() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.force_gray)
return _internal_force_gray();
}
inline void TransformationParameter::_internal_set_force_gray(bool value) {
_has_bits_[0] |= 0x00000200u;
force_gray_ = value;
}
inline void TransformationParameter::set_force_gray(bool value) {
_internal_set_force_gray(value);
// @@protoc_insertion_point(field_set:caffe.TransformationParameter.force_gray)
}
// optional .caffe.ResizeParameter resize_param = 8;
inline bool TransformationParameter::_internal_has_resize_param() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || resize_param_ != nullptr);
return value;
}
inline bool TransformationParameter::has_resize_param() const {
return _internal_has_resize_param();
}
inline void TransformationParameter::clear_resize_param() {
if (resize_param_ != nullptr) resize_param_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::ResizeParameter& TransformationParameter::_internal_resize_param() const {
const ::caffe::ResizeParameter* p = resize_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ResizeParameter&>(
::caffe::_ResizeParameter_default_instance_);
}
inline const ::caffe::ResizeParameter& TransformationParameter::resize_param() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.resize_param)
return _internal_resize_param();
}
inline void TransformationParameter::unsafe_arena_set_allocated_resize_param(
::caffe::ResizeParameter* resize_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(resize_param_);
}
resize_param_ = resize_param;
if (resize_param) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.TransformationParameter.resize_param)
}
inline ::caffe::ResizeParameter* TransformationParameter::release_resize_param() {
_has_bits_[0] &= ~0x00000002u;
::caffe::ResizeParameter* temp = resize_param_;
resize_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ResizeParameter* TransformationParameter::unsafe_arena_release_resize_param() {
// @@protoc_insertion_point(field_release:caffe.TransformationParameter.resize_param)
_has_bits_[0] &= ~0x00000002u;
::caffe::ResizeParameter* temp = resize_param_;
resize_param_ = nullptr;
return temp;
}
inline ::caffe::ResizeParameter* TransformationParameter::_internal_mutable_resize_param() {
_has_bits_[0] |= 0x00000002u;
if (resize_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ResizeParameter>(GetArenaForAllocation());
resize_param_ = p;
}
return resize_param_;
}
inline ::caffe::ResizeParameter* TransformationParameter::mutable_resize_param() {
::caffe::ResizeParameter* _msg = _internal_mutable_resize_param();
// @@protoc_insertion_point(field_mutable:caffe.TransformationParameter.resize_param)
return _msg;
}
inline void TransformationParameter::set_allocated_resize_param(::caffe::ResizeParameter* resize_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete resize_param_;
}
if (resize_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ResizeParameter>::GetOwningArena(resize_param);
if (message_arena != submessage_arena) {
resize_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, resize_param, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
resize_param_ = resize_param;
// @@protoc_insertion_point(field_set_allocated:caffe.TransformationParameter.resize_param)
}
// optional .caffe.NoiseParameter noise_param = 9;
inline bool TransformationParameter::_internal_has_noise_param() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
PROTOBUF_ASSUME(!value || noise_param_ != nullptr);
return value;
}
inline bool TransformationParameter::has_noise_param() const {
return _internal_has_noise_param();
}
inline void TransformationParameter::clear_noise_param() {
if (noise_param_ != nullptr) noise_param_->Clear();
_has_bits_[0] &= ~0x00000004u;
}
inline const ::caffe::NoiseParameter& TransformationParameter::_internal_noise_param() const {
const ::caffe::NoiseParameter* p = noise_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::NoiseParameter&>(
::caffe::_NoiseParameter_default_instance_);
}
inline const ::caffe::NoiseParameter& TransformationParameter::noise_param() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.noise_param)
return _internal_noise_param();
}
inline void TransformationParameter::unsafe_arena_set_allocated_noise_param(
::caffe::NoiseParameter* noise_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(noise_param_);
}
noise_param_ = noise_param;
if (noise_param) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.TransformationParameter.noise_param)
}
inline ::caffe::NoiseParameter* TransformationParameter::release_noise_param() {
_has_bits_[0] &= ~0x00000004u;
::caffe::NoiseParameter* temp = noise_param_;
noise_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::NoiseParameter* TransformationParameter::unsafe_arena_release_noise_param() {
// @@protoc_insertion_point(field_release:caffe.TransformationParameter.noise_param)
_has_bits_[0] &= ~0x00000004u;
::caffe::NoiseParameter* temp = noise_param_;
noise_param_ = nullptr;
return temp;
}
inline ::caffe::NoiseParameter* TransformationParameter::_internal_mutable_noise_param() {
_has_bits_[0] |= 0x00000004u;
if (noise_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::NoiseParameter>(GetArenaForAllocation());
noise_param_ = p;
}
return noise_param_;
}
inline ::caffe::NoiseParameter* TransformationParameter::mutable_noise_param() {
::caffe::NoiseParameter* _msg = _internal_mutable_noise_param();
// @@protoc_insertion_point(field_mutable:caffe.TransformationParameter.noise_param)
return _msg;
}
inline void TransformationParameter::set_allocated_noise_param(::caffe::NoiseParameter* noise_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete noise_param_;
}
if (noise_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::NoiseParameter>::GetOwningArena(noise_param);
if (message_arena != submessage_arena) {
noise_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, noise_param, submessage_arena);
}
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
noise_param_ = noise_param;
// @@protoc_insertion_point(field_set_allocated:caffe.TransformationParameter.noise_param)
}
// optional .caffe.DistortionParameter distort_param = 13;
inline bool TransformationParameter::_internal_has_distort_param() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
PROTOBUF_ASSUME(!value || distort_param_ != nullptr);
return value;
}
inline bool TransformationParameter::has_distort_param() const {
return _internal_has_distort_param();
}
inline void TransformationParameter::clear_distort_param() {
if (distort_param_ != nullptr) distort_param_->Clear();
_has_bits_[0] &= ~0x00000010u;
}
inline const ::caffe::DistortionParameter& TransformationParameter::_internal_distort_param() const {
const ::caffe::DistortionParameter* p = distort_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::DistortionParameter&>(
::caffe::_DistortionParameter_default_instance_);
}
inline const ::caffe::DistortionParameter& TransformationParameter::distort_param() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.distort_param)
return _internal_distort_param();
}
inline void TransformationParameter::unsafe_arena_set_allocated_distort_param(
::caffe::DistortionParameter* distort_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(distort_param_);
}
distort_param_ = distort_param;
if (distort_param) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.TransformationParameter.distort_param)
}
inline ::caffe::DistortionParameter* TransformationParameter::release_distort_param() {
_has_bits_[0] &= ~0x00000010u;
::caffe::DistortionParameter* temp = distort_param_;
distort_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::DistortionParameter* TransformationParameter::unsafe_arena_release_distort_param() {
// @@protoc_insertion_point(field_release:caffe.TransformationParameter.distort_param)
_has_bits_[0] &= ~0x00000010u;
::caffe::DistortionParameter* temp = distort_param_;
distort_param_ = nullptr;
return temp;
}
inline ::caffe::DistortionParameter* TransformationParameter::_internal_mutable_distort_param() {
_has_bits_[0] |= 0x00000010u;
if (distort_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::DistortionParameter>(GetArenaForAllocation());
distort_param_ = p;
}
return distort_param_;
}
inline ::caffe::DistortionParameter* TransformationParameter::mutable_distort_param() {
::caffe::DistortionParameter* _msg = _internal_mutable_distort_param();
// @@protoc_insertion_point(field_mutable:caffe.TransformationParameter.distort_param)
return _msg;
}
inline void TransformationParameter::set_allocated_distort_param(::caffe::DistortionParameter* distort_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete distort_param_;
}
if (distort_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::DistortionParameter>::GetOwningArena(distort_param);
if (message_arena != submessage_arena) {
distort_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, distort_param, submessage_arena);
}
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
distort_param_ = distort_param;
// @@protoc_insertion_point(field_set_allocated:caffe.TransformationParameter.distort_param)
}
// optional .caffe.ExpansionParameter expand_param = 14;
inline bool TransformationParameter::_internal_has_expand_param() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
PROTOBUF_ASSUME(!value || expand_param_ != nullptr);
return value;
}
inline bool TransformationParameter::has_expand_param() const {
return _internal_has_expand_param();
}
inline void TransformationParameter::clear_expand_param() {
if (expand_param_ != nullptr) expand_param_->Clear();
_has_bits_[0] &= ~0x00000020u;
}
inline const ::caffe::ExpansionParameter& TransformationParameter::_internal_expand_param() const {
const ::caffe::ExpansionParameter* p = expand_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ExpansionParameter&>(
::caffe::_ExpansionParameter_default_instance_);
}
inline const ::caffe::ExpansionParameter& TransformationParameter::expand_param() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.expand_param)
return _internal_expand_param();
}
inline void TransformationParameter::unsafe_arena_set_allocated_expand_param(
::caffe::ExpansionParameter* expand_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expand_param_);
}
expand_param_ = expand_param;
if (expand_param) {
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.TransformationParameter.expand_param)
}
inline ::caffe::ExpansionParameter* TransformationParameter::release_expand_param() {
_has_bits_[0] &= ~0x00000020u;
::caffe::ExpansionParameter* temp = expand_param_;
expand_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ExpansionParameter* TransformationParameter::unsafe_arena_release_expand_param() {
// @@protoc_insertion_point(field_release:caffe.TransformationParameter.expand_param)
_has_bits_[0] &= ~0x00000020u;
::caffe::ExpansionParameter* temp = expand_param_;
expand_param_ = nullptr;
return temp;
}
inline ::caffe::ExpansionParameter* TransformationParameter::_internal_mutable_expand_param() {
_has_bits_[0] |= 0x00000020u;
if (expand_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ExpansionParameter>(GetArenaForAllocation());
expand_param_ = p;
}
return expand_param_;
}
inline ::caffe::ExpansionParameter* TransformationParameter::mutable_expand_param() {
::caffe::ExpansionParameter* _msg = _internal_mutable_expand_param();
// @@protoc_insertion_point(field_mutable:caffe.TransformationParameter.expand_param)
return _msg;
}
inline void TransformationParameter::set_allocated_expand_param(::caffe::ExpansionParameter* expand_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete expand_param_;
}
if (expand_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ExpansionParameter>::GetOwningArena(expand_param);
if (message_arena != submessage_arena) {
expand_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, expand_param, submessage_arena);
}
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
expand_param_ = expand_param;
// @@protoc_insertion_point(field_set_allocated:caffe.TransformationParameter.expand_param)
}
// optional .caffe.EmitConstraint emit_constraint = 10;
inline bool TransformationParameter::_internal_has_emit_constraint() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
PROTOBUF_ASSUME(!value || emit_constraint_ != nullptr);
return value;
}
inline bool TransformationParameter::has_emit_constraint() const {
return _internal_has_emit_constraint();
}
inline void TransformationParameter::clear_emit_constraint() {
if (emit_constraint_ != nullptr) emit_constraint_->Clear();
_has_bits_[0] &= ~0x00000008u;
}
inline const ::caffe::EmitConstraint& TransformationParameter::_internal_emit_constraint() const {
const ::caffe::EmitConstraint* p = emit_constraint_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::EmitConstraint&>(
::caffe::_EmitConstraint_default_instance_);
}
inline const ::caffe::EmitConstraint& TransformationParameter::emit_constraint() const {
// @@protoc_insertion_point(field_get:caffe.TransformationParameter.emit_constraint)
return _internal_emit_constraint();
}
inline void TransformationParameter::unsafe_arena_set_allocated_emit_constraint(
::caffe::EmitConstraint* emit_constraint) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(emit_constraint_);
}
emit_constraint_ = emit_constraint;
if (emit_constraint) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.TransformationParameter.emit_constraint)
}
inline ::caffe::EmitConstraint* TransformationParameter::release_emit_constraint() {
_has_bits_[0] &= ~0x00000008u;
::caffe::EmitConstraint* temp = emit_constraint_;
emit_constraint_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::EmitConstraint* TransformationParameter::unsafe_arena_release_emit_constraint() {
// @@protoc_insertion_point(field_release:caffe.TransformationParameter.emit_constraint)
_has_bits_[0] &= ~0x00000008u;
::caffe::EmitConstraint* temp = emit_constraint_;
emit_constraint_ = nullptr;
return temp;
}
inline ::caffe::EmitConstraint* TransformationParameter::_internal_mutable_emit_constraint() {
_has_bits_[0] |= 0x00000008u;
if (emit_constraint_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::EmitConstraint>(GetArenaForAllocation());
emit_constraint_ = p;
}
return emit_constraint_;
}
inline ::caffe::EmitConstraint* TransformationParameter::mutable_emit_constraint() {
::caffe::EmitConstraint* _msg = _internal_mutable_emit_constraint();
// @@protoc_insertion_point(field_mutable:caffe.TransformationParameter.emit_constraint)
return _msg;
}
inline void TransformationParameter::set_allocated_emit_constraint(::caffe::EmitConstraint* emit_constraint) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete emit_constraint_;
}
if (emit_constraint) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::EmitConstraint>::GetOwningArena(emit_constraint);
if (message_arena != submessage_arena) {
emit_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, emit_constraint, submessage_arena);
}
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
emit_constraint_ = emit_constraint;
// @@protoc_insertion_point(field_set_allocated:caffe.TransformationParameter.emit_constraint)
}
// -------------------------------------------------------------------
// ResizeParameter
// optional float prob = 1 [default = 1];
inline bool ResizeParameter::_internal_has_prob() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool ResizeParameter::has_prob() const {
return _internal_has_prob();
}
inline void ResizeParameter::clear_prob() {
prob_ = 1;
_has_bits_[0] &= ~0x00000020u;
}
inline float ResizeParameter::_internal_prob() const {
return prob_;
}
inline float ResizeParameter::prob() const {
// @@protoc_insertion_point(field_get:caffe.ResizeParameter.prob)
return _internal_prob();
}
inline void ResizeParameter::_internal_set_prob(float value) {
_has_bits_[0] |= 0x00000020u;
prob_ = value;
}
inline void ResizeParameter::set_prob(float value) {
_internal_set_prob(value);
// @@protoc_insertion_point(field_set:caffe.ResizeParameter.prob)
}
// optional .caffe.ResizeParameter.Resize_mode resize_mode = 2 [default = WARP];
inline bool ResizeParameter::_internal_has_resize_mode() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool ResizeParameter::has_resize_mode() const {
return _internal_has_resize_mode();
}
inline void ResizeParameter::clear_resize_mode() {
resize_mode_ = 1;
_has_bits_[0] &= ~0x00000040u;
}
inline ::caffe::ResizeParameter_Resize_mode ResizeParameter::_internal_resize_mode() const {
return static_cast< ::caffe::ResizeParameter_Resize_mode >(resize_mode_);
}
inline ::caffe::ResizeParameter_Resize_mode ResizeParameter::resize_mode() const {
// @@protoc_insertion_point(field_get:caffe.ResizeParameter.resize_mode)
return _internal_resize_mode();
}
inline void ResizeParameter::_internal_set_resize_mode(::caffe::ResizeParameter_Resize_mode value) {
assert(::caffe::ResizeParameter_Resize_mode_IsValid(value));
_has_bits_[0] |= 0x00000040u;
resize_mode_ = value;
}
inline void ResizeParameter::set_resize_mode(::caffe::ResizeParameter_Resize_mode value) {
_internal_set_resize_mode(value);
// @@protoc_insertion_point(field_set:caffe.ResizeParameter.resize_mode)
}
// optional uint32 height = 3 [default = 0];
inline bool ResizeParameter::_internal_has_height() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ResizeParameter::has_height() const {
return _internal_has_height();
}
inline void ResizeParameter::clear_height() {
height_ = 0u;
_has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ResizeParameter::_internal_height() const {
return height_;
}
inline uint32_t ResizeParameter::height() const {
// @@protoc_insertion_point(field_get:caffe.ResizeParameter.height)
return _internal_height();
}
inline void ResizeParameter::_internal_set_height(uint32_t value) {
_has_bits_[0] |= 0x00000001u;
height_ = value;
}
inline void ResizeParameter::set_height(uint32_t value) {
_internal_set_height(value);
// @@protoc_insertion_point(field_set:caffe.ResizeParameter.height)
}
// optional uint32 width = 4 [default = 0];
inline bool ResizeParameter::_internal_has_width() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ResizeParameter::has_width() const {
return _internal_has_width();
}
inline void ResizeParameter::clear_width() {
width_ = 0u;
_has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ResizeParameter::_internal_width() const {
return width_;
}
inline uint32_t ResizeParameter::width() const {
// @@protoc_insertion_point(field_get:caffe.ResizeParameter.width)
return _internal_width();
}
inline void ResizeParameter::_internal_set_width(uint32_t value) {
_has_bits_[0] |= 0x00000002u;
width_ = value;
}
inline void ResizeParameter::set_width(uint32_t value) {
_internal_set_width(value);
// @@protoc_insertion_point(field_set:caffe.ResizeParameter.width)
}
// optional uint32 height_scale = 8 [default = 0];
inline bool ResizeParameter::_internal_has_height_scale() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ResizeParameter::has_height_scale() const {
return _internal_has_height_scale();
}
inline void ResizeParameter::clear_height_scale() {
height_scale_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ResizeParameter::_internal_height_scale() const {
return height_scale_;
}
inline uint32_t ResizeParameter::height_scale() const {
// @@protoc_insertion_point(field_get:caffe.ResizeParameter.height_scale)
return _internal_height_scale();
}
inline void ResizeParameter::_internal_set_height_scale(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
height_scale_ = value;
}
inline void ResizeParameter::set_height_scale(uint32_t value) {
_internal_set_height_scale(value);
// @@protoc_insertion_point(field_set:caffe.ResizeParameter.height_scale)
}
// optional uint32 width_scale = 9 [default = 0];
inline bool ResizeParameter::_internal_has_width_scale() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool ResizeParameter::has_width_scale() const {
return _internal_has_width_scale();
}
inline void ResizeParameter::clear_width_scale() {
width_scale_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t ResizeParameter::_internal_width_scale() const {
return width_scale_;
}
inline uint32_t ResizeParameter::width_scale() const {
// @@protoc_insertion_point(field_get:caffe.ResizeParameter.width_scale)
return _internal_width_scale();
}
inline void ResizeParameter::_internal_set_width_scale(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
width_scale_ = value;
}
inline void ResizeParameter::set_width_scale(uint32_t value) {
_internal_set_width_scale(value);
// @@protoc_insertion_point(field_set:caffe.ResizeParameter.width_scale)
}
// optional .caffe.ResizeParameter.Pad_mode pad_mode = 5 [default = CONSTANT];
inline bool ResizeParameter::_internal_has_pad_mode() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool ResizeParameter::has_pad_mode() const {
return _internal_has_pad_mode();
}
inline void ResizeParameter::clear_pad_mode() {
pad_mode_ = 1;
_has_bits_[0] &= ~0x00000010u;
}
inline ::caffe::ResizeParameter_Pad_mode ResizeParameter::_internal_pad_mode() const {
return static_cast< ::caffe::ResizeParameter_Pad_mode >(pad_mode_);
}
inline ::caffe::ResizeParameter_Pad_mode ResizeParameter::pad_mode() const {
// @@protoc_insertion_point(field_get:caffe.ResizeParameter.pad_mode)
return _internal_pad_mode();
}
inline void ResizeParameter::_internal_set_pad_mode(::caffe::ResizeParameter_Pad_mode value) {
assert(::caffe::ResizeParameter_Pad_mode_IsValid(value));
_has_bits_[0] |= 0x00000010u;
pad_mode_ = value;
}
inline void ResizeParameter::set_pad_mode(::caffe::ResizeParameter_Pad_mode value) {
_internal_set_pad_mode(value);
// @@protoc_insertion_point(field_set:caffe.ResizeParameter.pad_mode)
}
// repeated float pad_value = 6;
inline int ResizeParameter::_internal_pad_value_size() const {
return pad_value_.size();
}
inline int ResizeParameter::pad_value_size() const {
return _internal_pad_value_size();
}
inline void ResizeParameter::clear_pad_value() {
pad_value_.Clear();
}
inline float ResizeParameter::_internal_pad_value(int index) const {
return pad_value_.Get(index);
}
inline float ResizeParameter::pad_value(int index) const {
// @@protoc_insertion_point(field_get:caffe.ResizeParameter.pad_value)
return _internal_pad_value(index);
}
inline void ResizeParameter::set_pad_value(int index, float value) {
pad_value_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.ResizeParameter.pad_value)
}
inline void ResizeParameter::_internal_add_pad_value(float value) {
pad_value_.Add(value);
}
inline void ResizeParameter::add_pad_value(float value) {
_internal_add_pad_value(value);
// @@protoc_insertion_point(field_add:caffe.ResizeParameter.pad_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
ResizeParameter::_internal_pad_value() const {
return pad_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
ResizeParameter::pad_value() const {
// @@protoc_insertion_point(field_list:caffe.ResizeParameter.pad_value)
return _internal_pad_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
ResizeParameter::_internal_mutable_pad_value() {
return &pad_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
ResizeParameter::mutable_pad_value() {
// @@protoc_insertion_point(field_mutable_list:caffe.ResizeParameter.pad_value)
return _internal_mutable_pad_value();
}
// repeated .caffe.ResizeParameter.Interp_mode interp_mode = 7;
inline int ResizeParameter::_internal_interp_mode_size() const {
return interp_mode_.size();
}
inline int ResizeParameter::interp_mode_size() const {
return _internal_interp_mode_size();
}
inline void ResizeParameter::clear_interp_mode() {
interp_mode_.Clear();
}
inline ::caffe::ResizeParameter_Interp_mode ResizeParameter::_internal_interp_mode(int index) const {
return static_cast< ::caffe::ResizeParameter_Interp_mode >(interp_mode_.Get(index));
}
inline ::caffe::ResizeParameter_Interp_mode ResizeParameter::interp_mode(int index) const {
// @@protoc_insertion_point(field_get:caffe.ResizeParameter.interp_mode)
return _internal_interp_mode(index);
}
inline void ResizeParameter::set_interp_mode(int index, ::caffe::ResizeParameter_Interp_mode value) {
assert(::caffe::ResizeParameter_Interp_mode_IsValid(value));
interp_mode_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.ResizeParameter.interp_mode)
}
inline void ResizeParameter::_internal_add_interp_mode(::caffe::ResizeParameter_Interp_mode value) {
assert(::caffe::ResizeParameter_Interp_mode_IsValid(value));
interp_mode_.Add(value);
}
inline void ResizeParameter::add_interp_mode(::caffe::ResizeParameter_Interp_mode value) {
_internal_add_interp_mode(value);
// @@protoc_insertion_point(field_add:caffe.ResizeParameter.interp_mode)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
ResizeParameter::interp_mode() const {
// @@protoc_insertion_point(field_list:caffe.ResizeParameter.interp_mode)
return interp_mode_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
ResizeParameter::_internal_mutable_interp_mode() {
return &interp_mode_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
ResizeParameter::mutable_interp_mode() {
// @@protoc_insertion_point(field_mutable_list:caffe.ResizeParameter.interp_mode)
return _internal_mutable_interp_mode();
}
// -------------------------------------------------------------------
// SaltPepperParameter
// optional float fraction = 1 [default = 0];
inline bool SaltPepperParameter::_internal_has_fraction() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SaltPepperParameter::has_fraction() const {
return _internal_has_fraction();
}
inline void SaltPepperParameter::clear_fraction() {
fraction_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float SaltPepperParameter::_internal_fraction() const {
return fraction_;
}
inline float SaltPepperParameter::fraction() const {
// @@protoc_insertion_point(field_get:caffe.SaltPepperParameter.fraction)
return _internal_fraction();
}
inline void SaltPepperParameter::_internal_set_fraction(float value) {
_has_bits_[0] |= 0x00000001u;
fraction_ = value;
}
inline void SaltPepperParameter::set_fraction(float value) {
_internal_set_fraction(value);
// @@protoc_insertion_point(field_set:caffe.SaltPepperParameter.fraction)
}
// repeated float value = 2;
inline int SaltPepperParameter::_internal_value_size() const {
return value_.size();
}
inline int SaltPepperParameter::value_size() const {
return _internal_value_size();
}
inline void SaltPepperParameter::clear_value() {
value_.Clear();
}
inline float SaltPepperParameter::_internal_value(int index) const {
return value_.Get(index);
}
inline float SaltPepperParameter::value(int index) const {
// @@protoc_insertion_point(field_get:caffe.SaltPepperParameter.value)
return _internal_value(index);
}
inline void SaltPepperParameter::set_value(int index, float value) {
value_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.SaltPepperParameter.value)
}
inline void SaltPepperParameter::_internal_add_value(float value) {
value_.Add(value);
}
inline void SaltPepperParameter::add_value(float value) {
_internal_add_value(value);
// @@protoc_insertion_point(field_add:caffe.SaltPepperParameter.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SaltPepperParameter::_internal_value() const {
return value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SaltPepperParameter::value() const {
// @@protoc_insertion_point(field_list:caffe.SaltPepperParameter.value)
return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SaltPepperParameter::_internal_mutable_value() {
return &value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SaltPepperParameter::mutable_value() {
// @@protoc_insertion_point(field_mutable_list:caffe.SaltPepperParameter.value)
return _internal_mutable_value();
}
// -------------------------------------------------------------------
// NoiseParameter
// optional float prob = 1 [default = 0];
inline bool NoiseParameter::_internal_has_prob() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool NoiseParameter::has_prob() const {
return _internal_has_prob();
}
inline void NoiseParameter::clear_prob() {
prob_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline float NoiseParameter::_internal_prob() const {
return prob_;
}
inline float NoiseParameter::prob() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.prob)
return _internal_prob();
}
inline void NoiseParameter::_internal_set_prob(float value) {
_has_bits_[0] |= 0x00000002u;
prob_ = value;
}
inline void NoiseParameter::set_prob(float value) {
_internal_set_prob(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.prob)
}
// optional bool hist_eq = 2 [default = false];
inline bool NoiseParameter::_internal_has_hist_eq() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool NoiseParameter::has_hist_eq() const {
return _internal_has_hist_eq();
}
inline void NoiseParameter::clear_hist_eq() {
hist_eq_ = false;
_has_bits_[0] &= ~0x00000004u;
}
inline bool NoiseParameter::_internal_hist_eq() const {
return hist_eq_;
}
inline bool NoiseParameter::hist_eq() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.hist_eq)
return _internal_hist_eq();
}
inline void NoiseParameter::_internal_set_hist_eq(bool value) {
_has_bits_[0] |= 0x00000004u;
hist_eq_ = value;
}
inline void NoiseParameter::set_hist_eq(bool value) {
_internal_set_hist_eq(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.hist_eq)
}
// optional bool inverse = 3 [default = false];
inline bool NoiseParameter::_internal_has_inverse() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool NoiseParameter::has_inverse() const {
return _internal_has_inverse();
}
inline void NoiseParameter::clear_inverse() {
inverse_ = false;
_has_bits_[0] &= ~0x00000008u;
}
inline bool NoiseParameter::_internal_inverse() const {
return inverse_;
}
inline bool NoiseParameter::inverse() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.inverse)
return _internal_inverse();
}
inline void NoiseParameter::_internal_set_inverse(bool value) {
_has_bits_[0] |= 0x00000008u;
inverse_ = value;
}
inline void NoiseParameter::set_inverse(bool value) {
_internal_set_inverse(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.inverse)
}
// optional bool decolorize = 4 [default = false];
inline bool NoiseParameter::_internal_has_decolorize() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool NoiseParameter::has_decolorize() const {
return _internal_has_decolorize();
}
inline void NoiseParameter::clear_decolorize() {
decolorize_ = false;
_has_bits_[0] &= ~0x00000010u;
}
inline bool NoiseParameter::_internal_decolorize() const {
return decolorize_;
}
inline bool NoiseParameter::decolorize() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.decolorize)
return _internal_decolorize();
}
inline void NoiseParameter::_internal_set_decolorize(bool value) {
_has_bits_[0] |= 0x00000010u;
decolorize_ = value;
}
inline void NoiseParameter::set_decolorize(bool value) {
_internal_set_decolorize(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.decolorize)
}
// optional bool gauss_blur = 5 [default = false];
inline bool NoiseParameter::_internal_has_gauss_blur() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool NoiseParameter::has_gauss_blur() const {
return _internal_has_gauss_blur();
}
inline void NoiseParameter::clear_gauss_blur() {
gauss_blur_ = false;
_has_bits_[0] &= ~0x00000020u;
}
inline bool NoiseParameter::_internal_gauss_blur() const {
return gauss_blur_;
}
inline bool NoiseParameter::gauss_blur() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.gauss_blur)
return _internal_gauss_blur();
}
inline void NoiseParameter::_internal_set_gauss_blur(bool value) {
_has_bits_[0] |= 0x00000020u;
gauss_blur_ = value;
}
inline void NoiseParameter::set_gauss_blur(bool value) {
_internal_set_gauss_blur(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.gauss_blur)
}
// optional float jpeg = 6 [default = -1];
inline bool NoiseParameter::_internal_has_jpeg() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool NoiseParameter::has_jpeg() const {
return _internal_has_jpeg();
}
inline void NoiseParameter::clear_jpeg() {
jpeg_ = -1;
_has_bits_[0] &= ~0x00001000u;
}
inline float NoiseParameter::_internal_jpeg() const {
return jpeg_;
}
inline float NoiseParameter::jpeg() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.jpeg)
return _internal_jpeg();
}
inline void NoiseParameter::_internal_set_jpeg(float value) {
_has_bits_[0] |= 0x00001000u;
jpeg_ = value;
}
inline void NoiseParameter::set_jpeg(float value) {
_internal_set_jpeg(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.jpeg)
}
// optional bool posterize = 7 [default = false];
inline bool NoiseParameter::_internal_has_posterize() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool NoiseParameter::has_posterize() const {
return _internal_has_posterize();
}
inline void NoiseParameter::clear_posterize() {
posterize_ = false;
_has_bits_[0] &= ~0x00000040u;
}
inline bool NoiseParameter::_internal_posterize() const {
return posterize_;
}
inline bool NoiseParameter::posterize() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.posterize)
return _internal_posterize();
}
inline void NoiseParameter::_internal_set_posterize(bool value) {
_has_bits_[0] |= 0x00000040u;
posterize_ = value;
}
inline void NoiseParameter::set_posterize(bool value) {
_internal_set_posterize(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.posterize)
}
// optional bool erode = 8 [default = false];
inline bool NoiseParameter::_internal_has_erode() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool NoiseParameter::has_erode() const {
return _internal_has_erode();
}
inline void NoiseParameter::clear_erode() {
erode_ = false;
_has_bits_[0] &= ~0x00000080u;
}
inline bool NoiseParameter::_internal_erode() const {
return erode_;
}
inline bool NoiseParameter::erode() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.erode)
return _internal_erode();
}
inline void NoiseParameter::_internal_set_erode(bool value) {
_has_bits_[0] |= 0x00000080u;
erode_ = value;
}
inline void NoiseParameter::set_erode(bool value) {
_internal_set_erode(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.erode)
}
// optional bool saltpepper = 9 [default = false];
inline bool NoiseParameter::_internal_has_saltpepper() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool NoiseParameter::has_saltpepper() const {
return _internal_has_saltpepper();
}
inline void NoiseParameter::clear_saltpepper() {
saltpepper_ = false;
_has_bits_[0] &= ~0x00000100u;
}
inline bool NoiseParameter::_internal_saltpepper() const {
return saltpepper_;
}
inline bool NoiseParameter::saltpepper() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.saltpepper)
return _internal_saltpepper();
}
inline void NoiseParameter::_internal_set_saltpepper(bool value) {
_has_bits_[0] |= 0x00000100u;
saltpepper_ = value;
}
inline void NoiseParameter::set_saltpepper(bool value) {
_internal_set_saltpepper(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.saltpepper)
}
// optional .caffe.SaltPepperParameter saltpepper_param = 10;
inline bool NoiseParameter::_internal_has_saltpepper_param() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || saltpepper_param_ != nullptr);
return value;
}
inline bool NoiseParameter::has_saltpepper_param() const {
return _internal_has_saltpepper_param();
}
inline void NoiseParameter::clear_saltpepper_param() {
if (saltpepper_param_ != nullptr) saltpepper_param_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::SaltPepperParameter& NoiseParameter::_internal_saltpepper_param() const {
const ::caffe::SaltPepperParameter* p = saltpepper_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SaltPepperParameter&>(
::caffe::_SaltPepperParameter_default_instance_);
}
inline const ::caffe::SaltPepperParameter& NoiseParameter::saltpepper_param() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.saltpepper_param)
return _internal_saltpepper_param();
}
inline void NoiseParameter::unsafe_arena_set_allocated_saltpepper_param(
::caffe::SaltPepperParameter* saltpepper_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(saltpepper_param_);
}
saltpepper_param_ = saltpepper_param;
if (saltpepper_param) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.NoiseParameter.saltpepper_param)
}
inline ::caffe::SaltPepperParameter* NoiseParameter::release_saltpepper_param() {
_has_bits_[0] &= ~0x00000001u;
::caffe::SaltPepperParameter* temp = saltpepper_param_;
saltpepper_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SaltPepperParameter* NoiseParameter::unsafe_arena_release_saltpepper_param() {
// @@protoc_insertion_point(field_release:caffe.NoiseParameter.saltpepper_param)
_has_bits_[0] &= ~0x00000001u;
::caffe::SaltPepperParameter* temp = saltpepper_param_;
saltpepper_param_ = nullptr;
return temp;
}
inline ::caffe::SaltPepperParameter* NoiseParameter::_internal_mutable_saltpepper_param() {
_has_bits_[0] |= 0x00000001u;
if (saltpepper_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SaltPepperParameter>(GetArenaForAllocation());
saltpepper_param_ = p;
}
return saltpepper_param_;
}
inline ::caffe::SaltPepperParameter* NoiseParameter::mutable_saltpepper_param() {
::caffe::SaltPepperParameter* _msg = _internal_mutable_saltpepper_param();
// @@protoc_insertion_point(field_mutable:caffe.NoiseParameter.saltpepper_param)
return _msg;
}
inline void NoiseParameter::set_allocated_saltpepper_param(::caffe::SaltPepperParameter* saltpepper_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete saltpepper_param_;
}
if (saltpepper_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SaltPepperParameter>::GetOwningArena(saltpepper_param);
if (message_arena != submessage_arena) {
saltpepper_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, saltpepper_param, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
saltpepper_param_ = saltpepper_param;
// @@protoc_insertion_point(field_set_allocated:caffe.NoiseParameter.saltpepper_param)
}
// optional bool clahe = 11 [default = false];
inline bool NoiseParameter::_internal_has_clahe() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool NoiseParameter::has_clahe() const {
return _internal_has_clahe();
}
inline void NoiseParameter::clear_clahe() {
clahe_ = false;
_has_bits_[0] &= ~0x00000200u;
}
inline bool NoiseParameter::_internal_clahe() const {
return clahe_;
}
inline bool NoiseParameter::clahe() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.clahe)
return _internal_clahe();
}
inline void NoiseParameter::_internal_set_clahe(bool value) {
_has_bits_[0] |= 0x00000200u;
clahe_ = value;
}
inline void NoiseParameter::set_clahe(bool value) {
_internal_set_clahe(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.clahe)
}
// optional bool convert_to_hsv = 12 [default = false];
inline bool NoiseParameter::_internal_has_convert_to_hsv() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool NoiseParameter::has_convert_to_hsv() const {
return _internal_has_convert_to_hsv();
}
inline void NoiseParameter::clear_convert_to_hsv() {
convert_to_hsv_ = false;
_has_bits_[0] &= ~0x00000400u;
}
inline bool NoiseParameter::_internal_convert_to_hsv() const {
return convert_to_hsv_;
}
inline bool NoiseParameter::convert_to_hsv() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.convert_to_hsv)
return _internal_convert_to_hsv();
}
inline void NoiseParameter::_internal_set_convert_to_hsv(bool value) {
_has_bits_[0] |= 0x00000400u;
convert_to_hsv_ = value;
}
inline void NoiseParameter::set_convert_to_hsv(bool value) {
_internal_set_convert_to_hsv(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.convert_to_hsv)
}
// optional bool convert_to_lab = 13 [default = false];
inline bool NoiseParameter::_internal_has_convert_to_lab() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool NoiseParameter::has_convert_to_lab() const {
return _internal_has_convert_to_lab();
}
inline void NoiseParameter::clear_convert_to_lab() {
convert_to_lab_ = false;
_has_bits_[0] &= ~0x00000800u;
}
inline bool NoiseParameter::_internal_convert_to_lab() const {
return convert_to_lab_;
}
inline bool NoiseParameter::convert_to_lab() const {
// @@protoc_insertion_point(field_get:caffe.NoiseParameter.convert_to_lab)
return _internal_convert_to_lab();
}
inline void NoiseParameter::_internal_set_convert_to_lab(bool value) {
_has_bits_[0] |= 0x00000800u;
convert_to_lab_ = value;
}
inline void NoiseParameter::set_convert_to_lab(bool value) {
_internal_set_convert_to_lab(value);
// @@protoc_insertion_point(field_set:caffe.NoiseParameter.convert_to_lab)
}
// -------------------------------------------------------------------
// DistortionParameter
// optional float brightness_prob = 1 [default = 0];
inline bool DistortionParameter::_internal_has_brightness_prob() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool DistortionParameter::has_brightness_prob() const {
return _internal_has_brightness_prob();
}
inline void DistortionParameter::clear_brightness_prob() {
brightness_prob_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float DistortionParameter::_internal_brightness_prob() const {
return brightness_prob_;
}
inline float DistortionParameter::brightness_prob() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.brightness_prob)
return _internal_brightness_prob();
}
inline void DistortionParameter::_internal_set_brightness_prob(float value) {
_has_bits_[0] |= 0x00000001u;
brightness_prob_ = value;
}
inline void DistortionParameter::set_brightness_prob(float value) {
_internal_set_brightness_prob(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.brightness_prob)
}
// optional float brightness_delta = 2 [default = 0];
inline bool DistortionParameter::_internal_has_brightness_delta() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool DistortionParameter::has_brightness_delta() const {
return _internal_has_brightness_delta();
}
inline void DistortionParameter::clear_brightness_delta() {
brightness_delta_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline float DistortionParameter::_internal_brightness_delta() const {
return brightness_delta_;
}
inline float DistortionParameter::brightness_delta() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.brightness_delta)
return _internal_brightness_delta();
}
inline void DistortionParameter::_internal_set_brightness_delta(float value) {
_has_bits_[0] |= 0x00000002u;
brightness_delta_ = value;
}
inline void DistortionParameter::set_brightness_delta(float value) {
_internal_set_brightness_delta(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.brightness_delta)
}
// optional float contrast_prob = 3 [default = 0];
inline bool DistortionParameter::_internal_has_contrast_prob() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool DistortionParameter::has_contrast_prob() const {
return _internal_has_contrast_prob();
}
inline void DistortionParameter::clear_contrast_prob() {
contrast_prob_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline float DistortionParameter::_internal_contrast_prob() const {
return contrast_prob_;
}
inline float DistortionParameter::contrast_prob() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.contrast_prob)
return _internal_contrast_prob();
}
inline void DistortionParameter::_internal_set_contrast_prob(float value) {
_has_bits_[0] |= 0x00000004u;
contrast_prob_ = value;
}
inline void DistortionParameter::set_contrast_prob(float value) {
_internal_set_contrast_prob(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.contrast_prob)
}
// optional float contrast_lower = 4 [default = 0];
inline bool DistortionParameter::_internal_has_contrast_lower() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool DistortionParameter::has_contrast_lower() const {
return _internal_has_contrast_lower();
}
inline void DistortionParameter::clear_contrast_lower() {
contrast_lower_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline float DistortionParameter::_internal_contrast_lower() const {
return contrast_lower_;
}
inline float DistortionParameter::contrast_lower() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.contrast_lower)
return _internal_contrast_lower();
}
inline void DistortionParameter::_internal_set_contrast_lower(float value) {
_has_bits_[0] |= 0x00000008u;
contrast_lower_ = value;
}
inline void DistortionParameter::set_contrast_lower(float value) {
_internal_set_contrast_lower(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.contrast_lower)
}
// optional float contrast_upper = 5 [default = 0];
inline bool DistortionParameter::_internal_has_contrast_upper() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool DistortionParameter::has_contrast_upper() const {
return _internal_has_contrast_upper();
}
inline void DistortionParameter::clear_contrast_upper() {
contrast_upper_ = 0;
_has_bits_[0] &= ~0x00000010u;
}
inline float DistortionParameter::_internal_contrast_upper() const {
return contrast_upper_;
}
inline float DistortionParameter::contrast_upper() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.contrast_upper)
return _internal_contrast_upper();
}
inline void DistortionParameter::_internal_set_contrast_upper(float value) {
_has_bits_[0] |= 0x00000010u;
contrast_upper_ = value;
}
inline void DistortionParameter::set_contrast_upper(float value) {
_internal_set_contrast_upper(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.contrast_upper)
}
// optional float hue_prob = 6 [default = 0];
inline bool DistortionParameter::_internal_has_hue_prob() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool DistortionParameter::has_hue_prob() const {
return _internal_has_hue_prob();
}
inline void DistortionParameter::clear_hue_prob() {
hue_prob_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline float DistortionParameter::_internal_hue_prob() const {
return hue_prob_;
}
inline float DistortionParameter::hue_prob() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.hue_prob)
return _internal_hue_prob();
}
inline void DistortionParameter::_internal_set_hue_prob(float value) {
_has_bits_[0] |= 0x00000020u;
hue_prob_ = value;
}
inline void DistortionParameter::set_hue_prob(float value) {
_internal_set_hue_prob(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.hue_prob)
}
// optional float hue_delta = 7 [default = 0];
inline bool DistortionParameter::_internal_has_hue_delta() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool DistortionParameter::has_hue_delta() const {
return _internal_has_hue_delta();
}
inline void DistortionParameter::clear_hue_delta() {
hue_delta_ = 0;
_has_bits_[0] &= ~0x00000040u;
}
inline float DistortionParameter::_internal_hue_delta() const {
return hue_delta_;
}
inline float DistortionParameter::hue_delta() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.hue_delta)
return _internal_hue_delta();
}
inline void DistortionParameter::_internal_set_hue_delta(float value) {
_has_bits_[0] |= 0x00000040u;
hue_delta_ = value;
}
inline void DistortionParameter::set_hue_delta(float value) {
_internal_set_hue_delta(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.hue_delta)
}
// optional float saturation_prob = 8 [default = 0];
inline bool DistortionParameter::_internal_has_saturation_prob() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool DistortionParameter::has_saturation_prob() const {
return _internal_has_saturation_prob();
}
inline void DistortionParameter::clear_saturation_prob() {
saturation_prob_ = 0;
_has_bits_[0] &= ~0x00000080u;
}
inline float DistortionParameter::_internal_saturation_prob() const {
return saturation_prob_;
}
inline float DistortionParameter::saturation_prob() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.saturation_prob)
return _internal_saturation_prob();
}
inline void DistortionParameter::_internal_set_saturation_prob(float value) {
_has_bits_[0] |= 0x00000080u;
saturation_prob_ = value;
}
inline void DistortionParameter::set_saturation_prob(float value) {
_internal_set_saturation_prob(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.saturation_prob)
}
// optional float saturation_lower = 9 [default = 0];
inline bool DistortionParameter::_internal_has_saturation_lower() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool DistortionParameter::has_saturation_lower() const {
return _internal_has_saturation_lower();
}
inline void DistortionParameter::clear_saturation_lower() {
saturation_lower_ = 0;
_has_bits_[0] &= ~0x00000100u;
}
inline float DistortionParameter::_internal_saturation_lower() const {
return saturation_lower_;
}
inline float DistortionParameter::saturation_lower() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.saturation_lower)
return _internal_saturation_lower();
}
inline void DistortionParameter::_internal_set_saturation_lower(float value) {
_has_bits_[0] |= 0x00000100u;
saturation_lower_ = value;
}
inline void DistortionParameter::set_saturation_lower(float value) {
_internal_set_saturation_lower(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.saturation_lower)
}
// optional float saturation_upper = 10 [default = 0];
inline bool DistortionParameter::_internal_has_saturation_upper() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool DistortionParameter::has_saturation_upper() const {
return _internal_has_saturation_upper();
}
inline void DistortionParameter::clear_saturation_upper() {
saturation_upper_ = 0;
_has_bits_[0] &= ~0x00000200u;
}
inline float DistortionParameter::_internal_saturation_upper() const {
return saturation_upper_;
}
inline float DistortionParameter::saturation_upper() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.saturation_upper)
return _internal_saturation_upper();
}
inline void DistortionParameter::_internal_set_saturation_upper(float value) {
_has_bits_[0] |= 0x00000200u;
saturation_upper_ = value;
}
inline void DistortionParameter::set_saturation_upper(float value) {
_internal_set_saturation_upper(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.saturation_upper)
}
// optional float random_order_prob = 11 [default = 0];
inline bool DistortionParameter::_internal_has_random_order_prob() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool DistortionParameter::has_random_order_prob() const {
return _internal_has_random_order_prob();
}
inline void DistortionParameter::clear_random_order_prob() {
random_order_prob_ = 0;
_has_bits_[0] &= ~0x00000400u;
}
inline float DistortionParameter::_internal_random_order_prob() const {
return random_order_prob_;
}
inline float DistortionParameter::random_order_prob() const {
// @@protoc_insertion_point(field_get:caffe.DistortionParameter.random_order_prob)
return _internal_random_order_prob();
}
inline void DistortionParameter::_internal_set_random_order_prob(float value) {
_has_bits_[0] |= 0x00000400u;
random_order_prob_ = value;
}
inline void DistortionParameter::set_random_order_prob(float value) {
_internal_set_random_order_prob(value);
// @@protoc_insertion_point(field_set:caffe.DistortionParameter.random_order_prob)
}
// -------------------------------------------------------------------
// ExpansionParameter
// optional float prob = 1 [default = 1];
inline bool ExpansionParameter::_internal_has_prob() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ExpansionParameter::has_prob() const {
return _internal_has_prob();
}
inline void ExpansionParameter::clear_prob() {
prob_ = 1;
_has_bits_[0] &= ~0x00000001u;
}
inline float ExpansionParameter::_internal_prob() const {
return prob_;
}
inline float ExpansionParameter::prob() const {
// @@protoc_insertion_point(field_get:caffe.ExpansionParameter.prob)
return _internal_prob();
}
inline void ExpansionParameter::_internal_set_prob(float value) {
_has_bits_[0] |= 0x00000001u;
prob_ = value;
}
inline void ExpansionParameter::set_prob(float value) {
_internal_set_prob(value);
// @@protoc_insertion_point(field_set:caffe.ExpansionParameter.prob)
}
// optional float max_expand_ratio = 2 [default = 1];
inline bool ExpansionParameter::_internal_has_max_expand_ratio() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ExpansionParameter::has_max_expand_ratio() const {
return _internal_has_max_expand_ratio();
}
inline void ExpansionParameter::clear_max_expand_ratio() {
max_expand_ratio_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline float ExpansionParameter::_internal_max_expand_ratio() const {
return max_expand_ratio_;
}
inline float ExpansionParameter::max_expand_ratio() const {
// @@protoc_insertion_point(field_get:caffe.ExpansionParameter.max_expand_ratio)
return _internal_max_expand_ratio();
}
inline void ExpansionParameter::_internal_set_max_expand_ratio(float value) {
_has_bits_[0] |= 0x00000002u;
max_expand_ratio_ = value;
}
inline void ExpansionParameter::set_max_expand_ratio(float value) {
_internal_set_max_expand_ratio(value);
// @@protoc_insertion_point(field_set:caffe.ExpansionParameter.max_expand_ratio)
}
// -------------------------------------------------------------------
// LossParameter
// optional int32 ignore_label = 1;
inline bool LossParameter::_internal_has_ignore_label() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool LossParameter::has_ignore_label() const {
return _internal_has_ignore_label();
}
inline void LossParameter::clear_ignore_label() {
ignore_label_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t LossParameter::_internal_ignore_label() const {
return ignore_label_;
}
inline int32_t LossParameter::ignore_label() const {
// @@protoc_insertion_point(field_get:caffe.LossParameter.ignore_label)
return _internal_ignore_label();
}
inline void LossParameter::_internal_set_ignore_label(int32_t value) {
_has_bits_[0] |= 0x00000001u;
ignore_label_ = value;
}
inline void LossParameter::set_ignore_label(int32_t value) {
_internal_set_ignore_label(value);
// @@protoc_insertion_point(field_set:caffe.LossParameter.ignore_label)
}
// optional .caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
inline bool LossParameter::_internal_has_normalization() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool LossParameter::has_normalization() const {
return _internal_has_normalization();
}
inline void LossParameter::clear_normalization() {
normalization_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline ::caffe::LossParameter_NormalizationMode LossParameter::_internal_normalization() const {
return static_cast< ::caffe::LossParameter_NormalizationMode >(normalization_);
}
inline ::caffe::LossParameter_NormalizationMode LossParameter::normalization() const {
// @@protoc_insertion_point(field_get:caffe.LossParameter.normalization)
return _internal_normalization();
}
inline void LossParameter::_internal_set_normalization(::caffe::LossParameter_NormalizationMode value) {
assert(::caffe::LossParameter_NormalizationMode_IsValid(value));
_has_bits_[0] |= 0x00000004u;
normalization_ = value;
}
inline void LossParameter::set_normalization(::caffe::LossParameter_NormalizationMode value) {
_internal_set_normalization(value);
// @@protoc_insertion_point(field_set:caffe.LossParameter.normalization)
}
// optional bool normalize = 2;
inline bool LossParameter::_internal_has_normalize() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool LossParameter::has_normalize() const {
return _internal_has_normalize();
}
inline void LossParameter::clear_normalize() {
normalize_ = false;
_has_bits_[0] &= ~0x00000002u;
}
inline bool LossParameter::_internal_normalize() const {
return normalize_;
}
inline bool LossParameter::normalize() const {
// @@protoc_insertion_point(field_get:caffe.LossParameter.normalize)
return _internal_normalize();
}
inline void LossParameter::_internal_set_normalize(bool value) {
_has_bits_[0] |= 0x00000002u;
normalize_ = value;
}
inline void LossParameter::set_normalize(bool value) {
_internal_set_normalize(value);
// @@protoc_insertion_point(field_set:caffe.LossParameter.normalize)
}
// optional bool is_num_scale = 4 [default = true];
inline bool LossParameter::_internal_has_is_num_scale() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool LossParameter::has_is_num_scale() const {
return _internal_has_is_num_scale();
}
inline void LossParameter::clear_is_num_scale() {
is_num_scale_ = true;
_has_bits_[0] &= ~0x00000008u;
}
inline bool LossParameter::_internal_is_num_scale() const {
return is_num_scale_;
}
inline bool LossParameter::is_num_scale() const {
// @@protoc_insertion_point(field_get:caffe.LossParameter.is_num_scale)
return _internal_is_num_scale();
}
inline void LossParameter::_internal_set_is_num_scale(bool value) {
_has_bits_[0] |= 0x00000008u;
is_num_scale_ = value;
}
inline void LossParameter::set_is_num_scale(bool value) {
_internal_set_is_num_scale(value);
// @@protoc_insertion_point(field_set:caffe.LossParameter.is_num_scale)
}
// -------------------------------------------------------------------
// AccuracyParameter
// optional uint32 top_k = 1 [default = 1];
inline bool AccuracyParameter::_internal_has_top_k() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool AccuracyParameter::has_top_k() const {
return _internal_has_top_k();
}
inline void AccuracyParameter::clear_top_k() {
top_k_ = 1u;
_has_bits_[0] &= ~0x00000002u;
}
inline uint32_t AccuracyParameter::_internal_top_k() const {
return top_k_;
}
inline uint32_t AccuracyParameter::top_k() const {
// @@protoc_insertion_point(field_get:caffe.AccuracyParameter.top_k)
return _internal_top_k();
}
inline void AccuracyParameter::_internal_set_top_k(uint32_t value) {
_has_bits_[0] |= 0x00000002u;
top_k_ = value;
}
inline void AccuracyParameter::set_top_k(uint32_t value) {
_internal_set_top_k(value);
// @@protoc_insertion_point(field_set:caffe.AccuracyParameter.top_k)
}
// optional int32 axis = 2 [default = 1];
inline bool AccuracyParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool AccuracyParameter::has_axis() const {
return _internal_has_axis();
}
inline void AccuracyParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t AccuracyParameter::_internal_axis() const {
return axis_;
}
inline int32_t AccuracyParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.AccuracyParameter.axis)
return _internal_axis();
}
inline void AccuracyParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000004u;
axis_ = value;
}
inline void AccuracyParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.AccuracyParameter.axis)
}
// optional int32 ignore_label = 3;
inline bool AccuracyParameter::_internal_has_ignore_label() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool AccuracyParameter::has_ignore_label() const {
return _internal_has_ignore_label();
}
inline void AccuracyParameter::clear_ignore_label() {
ignore_label_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t AccuracyParameter::_internal_ignore_label() const {
return ignore_label_;
}
inline int32_t AccuracyParameter::ignore_label() const {
// @@protoc_insertion_point(field_get:caffe.AccuracyParameter.ignore_label)
return _internal_ignore_label();
}
inline void AccuracyParameter::_internal_set_ignore_label(int32_t value) {
_has_bits_[0] |= 0x00000001u;
ignore_label_ = value;
}
inline void AccuracyParameter::set_ignore_label(int32_t value) {
_internal_set_ignore_label(value);
// @@protoc_insertion_point(field_set:caffe.AccuracyParameter.ignore_label)
}
// -------------------------------------------------------------------
// AnnotatedDataParameter
// repeated .caffe.BatchSampler batch_sampler = 1;
inline int AnnotatedDataParameter::_internal_batch_sampler_size() const {
return batch_sampler_.size();
}
inline int AnnotatedDataParameter::batch_sampler_size() const {
return _internal_batch_sampler_size();
}
inline void AnnotatedDataParameter::clear_batch_sampler() {
batch_sampler_.Clear();
}
inline ::caffe::BatchSampler* AnnotatedDataParameter::mutable_batch_sampler(int index) {
// @@protoc_insertion_point(field_mutable:caffe.AnnotatedDataParameter.batch_sampler)
return batch_sampler_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BatchSampler >*
AnnotatedDataParameter::mutable_batch_sampler() {
// @@protoc_insertion_point(field_mutable_list:caffe.AnnotatedDataParameter.batch_sampler)
return &batch_sampler_;
}
inline const ::caffe::BatchSampler& AnnotatedDataParameter::_internal_batch_sampler(int index) const {
return batch_sampler_.Get(index);
}
inline const ::caffe::BatchSampler& AnnotatedDataParameter::batch_sampler(int index) const {
// @@protoc_insertion_point(field_get:caffe.AnnotatedDataParameter.batch_sampler)
return _internal_batch_sampler(index);
}
inline ::caffe::BatchSampler* AnnotatedDataParameter::_internal_add_batch_sampler() {
return batch_sampler_.Add();
}
inline ::caffe::BatchSampler* AnnotatedDataParameter::add_batch_sampler() {
::caffe::BatchSampler* _add = _internal_add_batch_sampler();
// @@protoc_insertion_point(field_add:caffe.AnnotatedDataParameter.batch_sampler)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BatchSampler >&
AnnotatedDataParameter::batch_sampler() const {
// @@protoc_insertion_point(field_list:caffe.AnnotatedDataParameter.batch_sampler)
return batch_sampler_;
}
// optional string label_map_file = 2;
inline bool AnnotatedDataParameter::_internal_has_label_map_file() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool AnnotatedDataParameter::has_label_map_file() const {
return _internal_has_label_map_file();
}
inline void AnnotatedDataParameter::clear_label_map_file() {
label_map_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& AnnotatedDataParameter::label_map_file() const {
// @@protoc_insertion_point(field_get:caffe.AnnotatedDataParameter.label_map_file)
return _internal_label_map_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AnnotatedDataParameter::set_label_map_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
label_map_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.AnnotatedDataParameter.label_map_file)
}
inline std::string* AnnotatedDataParameter::mutable_label_map_file() {
std::string* _s = _internal_mutable_label_map_file();
// @@protoc_insertion_point(field_mutable:caffe.AnnotatedDataParameter.label_map_file)
return _s;
}
inline const std::string& AnnotatedDataParameter::_internal_label_map_file() const {
return label_map_file_.Get();
}
inline void AnnotatedDataParameter::_internal_set_label_map_file(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
label_map_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AnnotatedDataParameter::_internal_mutable_label_map_file() {
_has_bits_[0] |= 0x00000001u;
return label_map_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AnnotatedDataParameter::release_label_map_file() {
// @@protoc_insertion_point(field_release:caffe.AnnotatedDataParameter.label_map_file)
if (!_internal_has_label_map_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = label_map_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (label_map_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AnnotatedDataParameter::set_allocated_label_map_file(std::string* label_map_file) {
if (label_map_file != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
label_map_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), label_map_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (label_map_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.AnnotatedDataParameter.label_map_file)
}
// optional .caffe.AnnotatedDatum.AnnotationType anno_type = 3;
inline bool AnnotatedDataParameter::_internal_has_anno_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool AnnotatedDataParameter::has_anno_type() const {
return _internal_has_anno_type();
}
inline void AnnotatedDataParameter::clear_anno_type() {
anno_type_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::caffe::AnnotatedDatum_AnnotationType AnnotatedDataParameter::_internal_anno_type() const {
return static_cast< ::caffe::AnnotatedDatum_AnnotationType >(anno_type_);
}
inline ::caffe::AnnotatedDatum_AnnotationType AnnotatedDataParameter::anno_type() const {
// @@protoc_insertion_point(field_get:caffe.AnnotatedDataParameter.anno_type)
return _internal_anno_type();
}
inline void AnnotatedDataParameter::_internal_set_anno_type(::caffe::AnnotatedDatum_AnnotationType value) {
assert(::caffe::AnnotatedDatum_AnnotationType_IsValid(value));
_has_bits_[0] |= 0x00000002u;
anno_type_ = value;
}
inline void AnnotatedDataParameter::set_anno_type(::caffe::AnnotatedDatum_AnnotationType value) {
_internal_set_anno_type(value);
// @@protoc_insertion_point(field_set:caffe.AnnotatedDataParameter.anno_type)
}
// -------------------------------------------------------------------
// ArgMaxParameter
// optional bool out_max_val = 1 [default = false];
inline bool ArgMaxParameter::_internal_has_out_max_val() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ArgMaxParameter::has_out_max_val() const {
return _internal_has_out_max_val();
}
inline void ArgMaxParameter::clear_out_max_val() {
out_max_val_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool ArgMaxParameter::_internal_out_max_val() const {
return out_max_val_;
}
inline bool ArgMaxParameter::out_max_val() const {
// @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.out_max_val)
return _internal_out_max_val();
}
inline void ArgMaxParameter::_internal_set_out_max_val(bool value) {
_has_bits_[0] |= 0x00000001u;
out_max_val_ = value;
}
inline void ArgMaxParameter::set_out_max_val(bool value) {
_internal_set_out_max_val(value);
// @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.out_max_val)
}
// optional uint32 top_k = 2 [default = 1];
inline bool ArgMaxParameter::_internal_has_top_k() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool ArgMaxParameter::has_top_k() const {
return _internal_has_top_k();
}
inline void ArgMaxParameter::clear_top_k() {
top_k_ = 1u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t ArgMaxParameter::_internal_top_k() const {
return top_k_;
}
inline uint32_t ArgMaxParameter::top_k() const {
// @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.top_k)
return _internal_top_k();
}
inline void ArgMaxParameter::_internal_set_top_k(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
top_k_ = value;
}
inline void ArgMaxParameter::set_top_k(uint32_t value) {
_internal_set_top_k(value);
// @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.top_k)
}
// optional int32 axis = 3;
inline bool ArgMaxParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ArgMaxParameter::has_axis() const {
return _internal_has_axis();
}
inline void ArgMaxParameter::clear_axis() {
axis_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t ArgMaxParameter::_internal_axis() const {
return axis_;
}
inline int32_t ArgMaxParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.axis)
return _internal_axis();
}
inline void ArgMaxParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000004u;
axis_ = value;
}
inline void ArgMaxParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.axis)
}
// optional bool softmax_threshold = 4 [default = false];
inline bool ArgMaxParameter::_internal_has_softmax_threshold() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ArgMaxParameter::has_softmax_threshold() const {
return _internal_has_softmax_threshold();
}
inline void ArgMaxParameter::clear_softmax_threshold() {
softmax_threshold_ = false;
_has_bits_[0] &= ~0x00000002u;
}
inline bool ArgMaxParameter::_internal_softmax_threshold() const {
return softmax_threshold_;
}
inline bool ArgMaxParameter::softmax_threshold() const {
// @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.softmax_threshold)
return _internal_softmax_threshold();
}
inline void ArgMaxParameter::_internal_set_softmax_threshold(bool value) {
_has_bits_[0] |= 0x00000002u;
softmax_threshold_ = value;
}
inline void ArgMaxParameter::set_softmax_threshold(bool value) {
_internal_set_softmax_threshold(value);
// @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.softmax_threshold)
}
// -------------------------------------------------------------------
// ConcatParameter
// optional int32 axis = 2 [default = 1];
inline bool ConcatParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ConcatParameter::has_axis() const {
return _internal_has_axis();
}
inline void ConcatParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t ConcatParameter::_internal_axis() const {
return axis_;
}
inline int32_t ConcatParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.ConcatParameter.axis)
return _internal_axis();
}
inline void ConcatParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000002u;
axis_ = value;
}
inline void ConcatParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.ConcatParameter.axis)
}
// optional uint32 concat_dim = 1 [default = 1];
inline bool ConcatParameter::_internal_has_concat_dim() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ConcatParameter::has_concat_dim() const {
return _internal_has_concat_dim();
}
inline void ConcatParameter::clear_concat_dim() {
concat_dim_ = 1u;
_has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ConcatParameter::_internal_concat_dim() const {
return concat_dim_;
}
inline uint32_t ConcatParameter::concat_dim() const {
// @@protoc_insertion_point(field_get:caffe.ConcatParameter.concat_dim)
return _internal_concat_dim();
}
inline void ConcatParameter::_internal_set_concat_dim(uint32_t value) {
_has_bits_[0] |= 0x00000001u;
concat_dim_ = value;
}
inline void ConcatParameter::set_concat_dim(uint32_t value) {
_internal_set_concat_dim(value);
// @@protoc_insertion_point(field_set:caffe.ConcatParameter.concat_dim)
}
// -------------------------------------------------------------------
// BatchNormParameter
// optional bool use_global_stats = 1;
inline bool BatchNormParameter::_internal_has_use_global_stats() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool BatchNormParameter::has_use_global_stats() const {
return _internal_has_use_global_stats();
}
inline void BatchNormParameter::clear_use_global_stats() {
use_global_stats_ = false;
_has_bits_[0] &= ~0x00000008u;
}
inline bool BatchNormParameter::_internal_use_global_stats() const {
return use_global_stats_;
}
inline bool BatchNormParameter::use_global_stats() const {
// @@protoc_insertion_point(field_get:caffe.BatchNormParameter.use_global_stats)
return _internal_use_global_stats();
}
inline void BatchNormParameter::_internal_set_use_global_stats(bool value) {
_has_bits_[0] |= 0x00000008u;
use_global_stats_ = value;
}
inline void BatchNormParameter::set_use_global_stats(bool value) {
_internal_set_use_global_stats(value);
// @@protoc_insertion_point(field_set:caffe.BatchNormParameter.use_global_stats)
}
// optional float moving_average_fraction = 2 [default = 0.999];
inline bool BatchNormParameter::_internal_has_moving_average_fraction() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool BatchNormParameter::has_moving_average_fraction() const {
return _internal_has_moving_average_fraction();
}
inline void BatchNormParameter::clear_moving_average_fraction() {
moving_average_fraction_ = 0.999f;
_has_bits_[0] &= ~0x00000040u;
}
inline float BatchNormParameter::_internal_moving_average_fraction() const {
return moving_average_fraction_;
}
inline float BatchNormParameter::moving_average_fraction() const {
// @@protoc_insertion_point(field_get:caffe.BatchNormParameter.moving_average_fraction)
return _internal_moving_average_fraction();
}
inline void BatchNormParameter::_internal_set_moving_average_fraction(float value) {
_has_bits_[0] |= 0x00000040u;
moving_average_fraction_ = value;
}
inline void BatchNormParameter::set_moving_average_fraction(float value) {
_internal_set_moving_average_fraction(value);
// @@protoc_insertion_point(field_set:caffe.BatchNormParameter.moving_average_fraction)
}
// optional float eps = 3 [default = 1e-05];
inline bool BatchNormParameter::_internal_has_eps() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool BatchNormParameter::has_eps() const {
return _internal_has_eps();
}
inline void BatchNormParameter::clear_eps() {
eps_ = 1e-05f;
_has_bits_[0] &= ~0x00000080u;
}
inline float BatchNormParameter::_internal_eps() const {
return eps_;
}
inline float BatchNormParameter::eps() const {
// @@protoc_insertion_point(field_get:caffe.BatchNormParameter.eps)
return _internal_eps();
}
inline void BatchNormParameter::_internal_set_eps(float value) {
_has_bits_[0] |= 0x00000080u;
eps_ = value;
}
inline void BatchNormParameter::set_eps(float value) {
_internal_set_eps(value);
// @@protoc_insertion_point(field_set:caffe.BatchNormParameter.eps)
}
// optional bool use_weight_bias = 5 [default = true];
inline bool BatchNormParameter::_internal_has_use_weight_bias() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool BatchNormParameter::has_use_weight_bias() const {
return _internal_has_use_weight_bias();
}
inline void BatchNormParameter::clear_use_weight_bias() {
use_weight_bias_ = true;
_has_bits_[0] &= ~0x00000010u;
}
inline bool BatchNormParameter::_internal_use_weight_bias() const {
return use_weight_bias_;
}
inline bool BatchNormParameter::use_weight_bias() const {
// @@protoc_insertion_point(field_get:caffe.BatchNormParameter.use_weight_bias)
return _internal_use_weight_bias();
}
inline void BatchNormParameter::_internal_set_use_weight_bias(bool value) {
_has_bits_[0] |= 0x00000010u;
use_weight_bias_ = value;
}
inline void BatchNormParameter::set_use_weight_bias(bool value) {
_internal_set_use_weight_bias(value);
// @@protoc_insertion_point(field_set:caffe.BatchNormParameter.use_weight_bias)
}
// optional bool bias_term = 6 [default = true];
inline bool BatchNormParameter::_internal_has_bias_term() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool BatchNormParameter::has_bias_term() const {
return _internal_has_bias_term();
}
inline void BatchNormParameter::clear_bias_term() {
bias_term_ = true;
_has_bits_[0] &= ~0x00000020u;
}
inline bool BatchNormParameter::_internal_bias_term() const {
return bias_term_;
}
inline bool BatchNormParameter::bias_term() const {
// @@protoc_insertion_point(field_get:caffe.BatchNormParameter.bias_term)
return _internal_bias_term();
}
inline void BatchNormParameter::_internal_set_bias_term(bool value) {
_has_bits_[0] |= 0x00000020u;
bias_term_ = value;
}
inline void BatchNormParameter::set_bias_term(bool value) {
_internal_set_bias_term(value);
// @@protoc_insertion_point(field_set:caffe.BatchNormParameter.bias_term)
}
// optional .caffe.FillerParameter filler = 7;
inline bool BatchNormParameter::_internal_has_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || filler_ != nullptr);
return value;
}
inline bool BatchNormParameter::has_filler() const {
return _internal_has_filler();
}
inline void BatchNormParameter::clear_filler() {
if (filler_ != nullptr) filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& BatchNormParameter::_internal_filler() const {
const ::caffe::FillerParameter* p = filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& BatchNormParameter::filler() const {
// @@protoc_insertion_point(field_get:caffe.BatchNormParameter.filler)
return _internal_filler();
}
inline void BatchNormParameter::unsafe_arena_set_allocated_filler(
::caffe::FillerParameter* filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filler_);
}
filler_ = filler;
if (filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.BatchNormParameter.filler)
}
inline ::caffe::FillerParameter* BatchNormParameter::release_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = filler_;
filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* BatchNormParameter::unsafe_arena_release_filler() {
// @@protoc_insertion_point(field_release:caffe.BatchNormParameter.filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = filler_;
filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* BatchNormParameter::_internal_mutable_filler() {
_has_bits_[0] |= 0x00000001u;
if (filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
filler_ = p;
}
return filler_;
}
inline ::caffe::FillerParameter* BatchNormParameter::mutable_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_filler();
// @@protoc_insertion_point(field_mutable:caffe.BatchNormParameter.filler)
return _msg;
}
inline void BatchNormParameter::set_allocated_filler(::caffe::FillerParameter* filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete filler_;
}
if (filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(filler);
if (message_arena != submessage_arena) {
filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
filler_ = filler;
// @@protoc_insertion_point(field_set_allocated:caffe.BatchNormParameter.filler)
}
// optional .caffe.FillerParameter bias_filler = 8;
inline bool BatchNormParameter::_internal_has_bias_filler() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || bias_filler_ != nullptr);
return value;
}
inline bool BatchNormParameter::has_bias_filler() const {
return _internal_has_bias_filler();
}
inline void BatchNormParameter::clear_bias_filler() {
if (bias_filler_ != nullptr) bias_filler_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::FillerParameter& BatchNormParameter::_internal_bias_filler() const {
const ::caffe::FillerParameter* p = bias_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& BatchNormParameter::bias_filler() const {
// @@protoc_insertion_point(field_get:caffe.BatchNormParameter.bias_filler)
return _internal_bias_filler();
}
inline void BatchNormParameter::unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_);
}
bias_filler_ = bias_filler;
if (bias_filler) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.BatchNormParameter.bias_filler)
}
inline ::caffe::FillerParameter* BatchNormParameter::release_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* BatchNormParameter::unsafe_arena_release_bias_filler() {
// @@protoc_insertion_point(field_release:caffe.BatchNormParameter.bias_filler)
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* BatchNormParameter::_internal_mutable_bias_filler() {
_has_bits_[0] |= 0x00000002u;
if (bias_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
bias_filler_ = p;
}
return bias_filler_;
}
inline ::caffe::FillerParameter* BatchNormParameter::mutable_bias_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
// @@protoc_insertion_point(field_mutable:caffe.BatchNormParameter.bias_filler)
return _msg;
}
inline void BatchNormParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_filler_;
}
if (bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(bias_filler);
if (message_arena != submessage_arena) {
bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.BatchNormParameter.bias_filler)
}
// optional .caffe.FillerParameter scale_filler = 9;
inline bool BatchNormParameter::_internal_has_scale_filler() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
PROTOBUF_ASSUME(!value || scale_filler_ != nullptr);
return value;
}
inline bool BatchNormParameter::has_scale_filler() const {
return _internal_has_scale_filler();
}
inline void BatchNormParameter::clear_scale_filler() {
if (scale_filler_ != nullptr) scale_filler_->Clear();
_has_bits_[0] &= ~0x00000004u;
}
inline const ::caffe::FillerParameter& BatchNormParameter::_internal_scale_filler() const {
const ::caffe::FillerParameter* p = scale_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& BatchNormParameter::scale_filler() const {
// @@protoc_insertion_point(field_get:caffe.BatchNormParameter.scale_filler)
return _internal_scale_filler();
}
inline void BatchNormParameter::unsafe_arena_set_allocated_scale_filler(
::caffe::FillerParameter* scale_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_filler_);
}
scale_filler_ = scale_filler;
if (scale_filler) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.BatchNormParameter.scale_filler)
}
inline ::caffe::FillerParameter* BatchNormParameter::release_scale_filler() {
_has_bits_[0] &= ~0x00000004u;
::caffe::FillerParameter* temp = scale_filler_;
scale_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* BatchNormParameter::unsafe_arena_release_scale_filler() {
// @@protoc_insertion_point(field_release:caffe.BatchNormParameter.scale_filler)
_has_bits_[0] &= ~0x00000004u;
::caffe::FillerParameter* temp = scale_filler_;
scale_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* BatchNormParameter::_internal_mutable_scale_filler() {
_has_bits_[0] |= 0x00000004u;
if (scale_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
scale_filler_ = p;
}
return scale_filler_;
}
inline ::caffe::FillerParameter* BatchNormParameter::mutable_scale_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_scale_filler();
// @@protoc_insertion_point(field_mutable:caffe.BatchNormParameter.scale_filler)
return _msg;
}
inline void BatchNormParameter::set_allocated_scale_filler(::caffe::FillerParameter* scale_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete scale_filler_;
}
if (scale_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(scale_filler);
if (message_arena != submessage_arena) {
scale_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, scale_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
scale_filler_ = scale_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.BatchNormParameter.scale_filler)
}
// -------------------------------------------------------------------
// BiasParameter
// optional int32 axis = 1 [default = 1];
inline bool BiasParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool BiasParameter::has_axis() const {
return _internal_has_axis();
}
inline void BiasParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t BiasParameter::_internal_axis() const {
return axis_;
}
inline int32_t BiasParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.BiasParameter.axis)
return _internal_axis();
}
inline void BiasParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000002u;
axis_ = value;
}
inline void BiasParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.BiasParameter.axis)
}
// optional int32 num_axes = 2 [default = 1];
inline bool BiasParameter::_internal_has_num_axes() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool BiasParameter::has_num_axes() const {
return _internal_has_num_axes();
}
inline void BiasParameter::clear_num_axes() {
num_axes_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t BiasParameter::_internal_num_axes() const {
return num_axes_;
}
inline int32_t BiasParameter::num_axes() const {
// @@protoc_insertion_point(field_get:caffe.BiasParameter.num_axes)
return _internal_num_axes();
}
inline void BiasParameter::_internal_set_num_axes(int32_t value) {
_has_bits_[0] |= 0x00000004u;
num_axes_ = value;
}
inline void BiasParameter::set_num_axes(int32_t value) {
_internal_set_num_axes(value);
// @@protoc_insertion_point(field_set:caffe.BiasParameter.num_axes)
}
// optional .caffe.FillerParameter filler = 3;
inline bool BiasParameter::_internal_has_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || filler_ != nullptr);
return value;
}
inline bool BiasParameter::has_filler() const {
return _internal_has_filler();
}
inline void BiasParameter::clear_filler() {
if (filler_ != nullptr) filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& BiasParameter::_internal_filler() const {
const ::caffe::FillerParameter* p = filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& BiasParameter::filler() const {
// @@protoc_insertion_point(field_get:caffe.BiasParameter.filler)
return _internal_filler();
}
inline void BiasParameter::unsafe_arena_set_allocated_filler(
::caffe::FillerParameter* filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filler_);
}
filler_ = filler;
if (filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.BiasParameter.filler)
}
inline ::caffe::FillerParameter* BiasParameter::release_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = filler_;
filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* BiasParameter::unsafe_arena_release_filler() {
// @@protoc_insertion_point(field_release:caffe.BiasParameter.filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = filler_;
filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* BiasParameter::_internal_mutable_filler() {
_has_bits_[0] |= 0x00000001u;
if (filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
filler_ = p;
}
return filler_;
}
inline ::caffe::FillerParameter* BiasParameter::mutable_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_filler();
// @@protoc_insertion_point(field_mutable:caffe.BiasParameter.filler)
return _msg;
}
inline void BiasParameter::set_allocated_filler(::caffe::FillerParameter* filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete filler_;
}
if (filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(filler);
if (message_arena != submessage_arena) {
filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
filler_ = filler;
// @@protoc_insertion_point(field_set_allocated:caffe.BiasParameter.filler)
}
// -------------------------------------------------------------------
// ContrastiveLossParameter
// optional float margin = 1 [default = 1];
inline bool ContrastiveLossParameter::_internal_has_margin() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ContrastiveLossParameter::has_margin() const {
return _internal_has_margin();
}
inline void ContrastiveLossParameter::clear_margin() {
margin_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline float ContrastiveLossParameter::_internal_margin() const {
return margin_;
}
inline float ContrastiveLossParameter::margin() const {
// @@protoc_insertion_point(field_get:caffe.ContrastiveLossParameter.margin)
return _internal_margin();
}
inline void ContrastiveLossParameter::_internal_set_margin(float value) {
_has_bits_[0] |= 0x00000002u;
margin_ = value;
}
inline void ContrastiveLossParameter::set_margin(float value) {
_internal_set_margin(value);
// @@protoc_insertion_point(field_set:caffe.ContrastiveLossParameter.margin)
}
// optional bool legacy_version = 2 [default = false];
inline bool ContrastiveLossParameter::_internal_has_legacy_version() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ContrastiveLossParameter::has_legacy_version() const {
return _internal_has_legacy_version();
}
inline void ContrastiveLossParameter::clear_legacy_version() {
legacy_version_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool ContrastiveLossParameter::_internal_legacy_version() const {
return legacy_version_;
}
inline bool ContrastiveLossParameter::legacy_version() const {
// @@protoc_insertion_point(field_get:caffe.ContrastiveLossParameter.legacy_version)
return _internal_legacy_version();
}
inline void ContrastiveLossParameter::_internal_set_legacy_version(bool value) {
_has_bits_[0] |= 0x00000001u;
legacy_version_ = value;
}
inline void ContrastiveLossParameter::set_legacy_version(bool value) {
_internal_set_legacy_version(value);
// @@protoc_insertion_point(field_set:caffe.ContrastiveLossParameter.legacy_version)
}
// -------------------------------------------------------------------
// ConvolutionParameter
// optional uint32 num_output = 1;
inline bool ConvolutionParameter::_internal_has_num_output() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ConvolutionParameter::has_num_output() const {
return _internal_has_num_output();
}
inline void ConvolutionParameter::clear_num_output() {
num_output_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ConvolutionParameter::_internal_num_output() const {
return num_output_;
}
inline uint32_t ConvolutionParameter::num_output() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.num_output)
return _internal_num_output();
}
inline void ConvolutionParameter::_internal_set_num_output(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
num_output_ = value;
}
inline void ConvolutionParameter::set_num_output(uint32_t value) {
_internal_set_num_output(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.num_output)
}
// optional bool bias_term = 2 [default = true];
inline bool ConvolutionParameter::_internal_has_bias_term() const {
bool value = (_has_bits_[0] & 0x00010000u) != 0;
return value;
}
inline bool ConvolutionParameter::has_bias_term() const {
return _internal_has_bias_term();
}
inline void ConvolutionParameter::clear_bias_term() {
bias_term_ = true;
_has_bits_[0] &= ~0x00010000u;
}
inline bool ConvolutionParameter::_internal_bias_term() const {
return bias_term_;
}
inline bool ConvolutionParameter::bias_term() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.bias_term)
return _internal_bias_term();
}
inline void ConvolutionParameter::_internal_set_bias_term(bool value) {
_has_bits_[0] |= 0x00010000u;
bias_term_ = value;
}
inline void ConvolutionParameter::set_bias_term(bool value) {
_internal_set_bias_term(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.bias_term)
}
// repeated uint32 pad = 3;
inline int ConvolutionParameter::_internal_pad_size() const {
return pad_.size();
}
inline int ConvolutionParameter::pad_size() const {
return _internal_pad_size();
}
inline void ConvolutionParameter::clear_pad() {
pad_.Clear();
}
inline uint32_t ConvolutionParameter::_internal_pad(int index) const {
return pad_.Get(index);
}
inline uint32_t ConvolutionParameter::pad(int index) const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.pad)
return _internal_pad(index);
}
inline void ConvolutionParameter::set_pad(int index, uint32_t value) {
pad_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.pad)
}
inline void ConvolutionParameter::_internal_add_pad(uint32_t value) {
pad_.Add(value);
}
inline void ConvolutionParameter::add_pad(uint32_t value) {
_internal_add_pad(value);
// @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.pad)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::_internal_pad() const {
return pad_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::pad() const {
// @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.pad)
return _internal_pad();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::_internal_mutable_pad() {
return &pad_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::mutable_pad() {
// @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.pad)
return _internal_mutable_pad();
}
// repeated uint32 kernel_size = 4;
inline int ConvolutionParameter::_internal_kernel_size_size() const {
return kernel_size_.size();
}
inline int ConvolutionParameter::kernel_size_size() const {
return _internal_kernel_size_size();
}
inline void ConvolutionParameter::clear_kernel_size() {
kernel_size_.Clear();
}
inline uint32_t ConvolutionParameter::_internal_kernel_size(int index) const {
return kernel_size_.Get(index);
}
inline uint32_t ConvolutionParameter::kernel_size(int index) const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.kernel_size)
return _internal_kernel_size(index);
}
inline void ConvolutionParameter::set_kernel_size(int index, uint32_t value) {
kernel_size_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.kernel_size)
}
inline void ConvolutionParameter::_internal_add_kernel_size(uint32_t value) {
kernel_size_.Add(value);
}
inline void ConvolutionParameter::add_kernel_size(uint32_t value) {
_internal_add_kernel_size(value);
// @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.kernel_size)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::_internal_kernel_size() const {
return kernel_size_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::kernel_size() const {
// @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.kernel_size)
return _internal_kernel_size();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::_internal_mutable_kernel_size() {
return &kernel_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::mutable_kernel_size() {
// @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.kernel_size)
return _internal_mutable_kernel_size();
}
// repeated uint32 stride = 6;
inline int ConvolutionParameter::_internal_stride_size() const {
return stride_.size();
}
inline int ConvolutionParameter::stride_size() const {
return _internal_stride_size();
}
inline void ConvolutionParameter::clear_stride() {
stride_.Clear();
}
inline uint32_t ConvolutionParameter::_internal_stride(int index) const {
return stride_.Get(index);
}
inline uint32_t ConvolutionParameter::stride(int index) const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.stride)
return _internal_stride(index);
}
inline void ConvolutionParameter::set_stride(int index, uint32_t value) {
stride_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.stride)
}
inline void ConvolutionParameter::_internal_add_stride(uint32_t value) {
stride_.Add(value);
}
inline void ConvolutionParameter::add_stride(uint32_t value) {
_internal_add_stride(value);
// @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.stride)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::_internal_stride() const {
return stride_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::stride() const {
// @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.stride)
return _internal_stride();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::_internal_mutable_stride() {
return &stride_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::mutable_stride() {
// @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.stride)
return _internal_mutable_stride();
}
// repeated uint32 dilation = 18;
inline int ConvolutionParameter::_internal_dilation_size() const {
return dilation_.size();
}
inline int ConvolutionParameter::dilation_size() const {
return _internal_dilation_size();
}
inline void ConvolutionParameter::clear_dilation() {
dilation_.Clear();
}
inline uint32_t ConvolutionParameter::_internal_dilation(int index) const {
return dilation_.Get(index);
}
inline uint32_t ConvolutionParameter::dilation(int index) const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.dilation)
return _internal_dilation(index);
}
inline void ConvolutionParameter::set_dilation(int index, uint32_t value) {
dilation_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.dilation)
}
inline void ConvolutionParameter::_internal_add_dilation(uint32_t value) {
dilation_.Add(value);
}
inline void ConvolutionParameter::add_dilation(uint32_t value) {
_internal_add_dilation(value);
// @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.dilation)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::_internal_dilation() const {
return dilation_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::dilation() const {
// @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.dilation)
return _internal_dilation();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::_internal_mutable_dilation() {
return &dilation_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::mutable_dilation() {
// @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.dilation)
return _internal_mutable_dilation();
}
// optional uint32 pad_h = 9 [default = 0];
inline bool ConvolutionParameter::_internal_has_pad_h() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool ConvolutionParameter::has_pad_h() const {
return _internal_has_pad_h();
}
inline void ConvolutionParameter::clear_pad_h() {
pad_h_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t ConvolutionParameter::_internal_pad_h() const {
return pad_h_;
}
inline uint32_t ConvolutionParameter::pad_h() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.pad_h)
return _internal_pad_h();
}
inline void ConvolutionParameter::_internal_set_pad_h(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
pad_h_ = value;
}
inline void ConvolutionParameter::set_pad_h(uint32_t value) {
_internal_set_pad_h(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.pad_h)
}
// optional uint32 pad_w = 10 [default = 0];
inline bool ConvolutionParameter::_internal_has_pad_w() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool ConvolutionParameter::has_pad_w() const {
return _internal_has_pad_w();
}
inline void ConvolutionParameter::clear_pad_w() {
pad_w_ = 0u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t ConvolutionParameter::_internal_pad_w() const {
return pad_w_;
}
inline uint32_t ConvolutionParameter::pad_w() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.pad_w)
return _internal_pad_w();
}
inline void ConvolutionParameter::_internal_set_pad_w(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
pad_w_ = value;
}
inline void ConvolutionParameter::set_pad_w(uint32_t value) {
_internal_set_pad_w(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.pad_w)
}
// optional uint32 kernel_h = 11;
inline bool ConvolutionParameter::_internal_has_kernel_h() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool ConvolutionParameter::has_kernel_h() const {
return _internal_has_kernel_h();
}
inline void ConvolutionParameter::clear_kernel_h() {
kernel_h_ = 0u;
_has_bits_[0] &= ~0x00000020u;
}
inline uint32_t ConvolutionParameter::_internal_kernel_h() const {
return kernel_h_;
}
inline uint32_t ConvolutionParameter::kernel_h() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.kernel_h)
return _internal_kernel_h();
}
inline void ConvolutionParameter::_internal_set_kernel_h(uint32_t value) {
_has_bits_[0] |= 0x00000020u;
kernel_h_ = value;
}
inline void ConvolutionParameter::set_kernel_h(uint32_t value) {
_internal_set_kernel_h(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.kernel_h)
}
// optional uint32 kernel_w = 12;
inline bool ConvolutionParameter::_internal_has_kernel_w() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool ConvolutionParameter::has_kernel_w() const {
return _internal_has_kernel_w();
}
inline void ConvolutionParameter::clear_kernel_w() {
kernel_w_ = 0u;
_has_bits_[0] &= ~0x00000040u;
}
inline uint32_t ConvolutionParameter::_internal_kernel_w() const {
return kernel_w_;
}
inline uint32_t ConvolutionParameter::kernel_w() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.kernel_w)
return _internal_kernel_w();
}
inline void ConvolutionParameter::_internal_set_kernel_w(uint32_t value) {
_has_bits_[0] |= 0x00000040u;
kernel_w_ = value;
}
inline void ConvolutionParameter::set_kernel_w(uint32_t value) {
_internal_set_kernel_w(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.kernel_w)
}
// optional uint32 stride_h = 13;
inline bool ConvolutionParameter::_internal_has_stride_h() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool ConvolutionParameter::has_stride_h() const {
return _internal_has_stride_h();
}
inline void ConvolutionParameter::clear_stride_h() {
stride_h_ = 0u;
_has_bits_[0] &= ~0x00000080u;
}
inline uint32_t ConvolutionParameter::_internal_stride_h() const {
return stride_h_;
}
inline uint32_t ConvolutionParameter::stride_h() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.stride_h)
return _internal_stride_h();
}
inline void ConvolutionParameter::_internal_set_stride_h(uint32_t value) {
_has_bits_[0] |= 0x00000080u;
stride_h_ = value;
}
inline void ConvolutionParameter::set_stride_h(uint32_t value) {
_internal_set_stride_h(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.stride_h)
}
// optional uint32 stride_w = 14;
inline bool ConvolutionParameter::_internal_has_stride_w() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool ConvolutionParameter::has_stride_w() const {
return _internal_has_stride_w();
}
inline void ConvolutionParameter::clear_stride_w() {
stride_w_ = 0u;
_has_bits_[0] &= ~0x00000100u;
}
inline uint32_t ConvolutionParameter::_internal_stride_w() const {
return stride_w_;
}
inline uint32_t ConvolutionParameter::stride_w() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.stride_w)
return _internal_stride_w();
}
inline void ConvolutionParameter::_internal_set_stride_w(uint32_t value) {
_has_bits_[0] |= 0x00000100u;
stride_w_ = value;
}
inline void ConvolutionParameter::set_stride_w(uint32_t value) {
_internal_set_stride_w(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.stride_w)
}
// optional uint32 group = 5 [default = 1];
inline bool ConvolutionParameter::_internal_has_group() const {
bool value = (_has_bits_[0] & 0x00020000u) != 0;
return value;
}
inline bool ConvolutionParameter::has_group() const {
return _internal_has_group();
}
inline void ConvolutionParameter::clear_group() {
group_ = 1u;
_has_bits_[0] &= ~0x00020000u;
}
inline uint32_t ConvolutionParameter::_internal_group() const {
return group_;
}
inline uint32_t ConvolutionParameter::group() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.group)
return _internal_group();
}
inline void ConvolutionParameter::_internal_set_group(uint32_t value) {
_has_bits_[0] |= 0x00020000u;
group_ = value;
}
inline void ConvolutionParameter::set_group(uint32_t value) {
_internal_set_group(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.group)
}
// optional .caffe.FillerParameter weight_filler = 7;
inline bool ConvolutionParameter::_internal_has_weight_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || weight_filler_ != nullptr);
return value;
}
inline bool ConvolutionParameter::has_weight_filler() const {
return _internal_has_weight_filler();
}
inline void ConvolutionParameter::clear_weight_filler() {
if (weight_filler_ != nullptr) weight_filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& ConvolutionParameter::_internal_weight_filler() const {
const ::caffe::FillerParameter* p = weight_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& ConvolutionParameter::weight_filler() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.weight_filler)
return _internal_weight_filler();
}
inline void ConvolutionParameter::unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_);
}
weight_filler_ = weight_filler;
if (weight_filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.ConvolutionParameter.weight_filler)
}
inline ::caffe::FillerParameter* ConvolutionParameter::release_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* ConvolutionParameter::unsafe_arena_release_weight_filler() {
// @@protoc_insertion_point(field_release:caffe.ConvolutionParameter.weight_filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* ConvolutionParameter::_internal_mutable_weight_filler() {
_has_bits_[0] |= 0x00000001u;
if (weight_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
weight_filler_ = p;
}
return weight_filler_;
}
inline ::caffe::FillerParameter* ConvolutionParameter::mutable_weight_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
// @@protoc_insertion_point(field_mutable:caffe.ConvolutionParameter.weight_filler)
return _msg;
}
inline void ConvolutionParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete weight_filler_;
}
if (weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(weight_filler);
if (message_arena != submessage_arena) {
weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.ConvolutionParameter.weight_filler)
}
// optional .caffe.FillerParameter bias_filler = 8;
inline bool ConvolutionParameter::_internal_has_bias_filler() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || bias_filler_ != nullptr);
return value;
}
inline bool ConvolutionParameter::has_bias_filler() const {
return _internal_has_bias_filler();
}
inline void ConvolutionParameter::clear_bias_filler() {
if (bias_filler_ != nullptr) bias_filler_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::FillerParameter& ConvolutionParameter::_internal_bias_filler() const {
const ::caffe::FillerParameter* p = bias_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& ConvolutionParameter::bias_filler() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.bias_filler)
return _internal_bias_filler();
}
inline void ConvolutionParameter::unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_);
}
bias_filler_ = bias_filler;
if (bias_filler) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.ConvolutionParameter.bias_filler)
}
inline ::caffe::FillerParameter* ConvolutionParameter::release_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* ConvolutionParameter::unsafe_arena_release_bias_filler() {
// @@protoc_insertion_point(field_release:caffe.ConvolutionParameter.bias_filler)
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* ConvolutionParameter::_internal_mutable_bias_filler() {
_has_bits_[0] |= 0x00000002u;
if (bias_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
bias_filler_ = p;
}
return bias_filler_;
}
inline ::caffe::FillerParameter* ConvolutionParameter::mutable_bias_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
// @@protoc_insertion_point(field_mutable:caffe.ConvolutionParameter.bias_filler)
return _msg;
}
inline void ConvolutionParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_filler_;
}
if (bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(bias_filler);
if (message_arena != submessage_arena) {
bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.ConvolutionParameter.bias_filler)
}
// optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
inline bool ConvolutionParameter::_internal_has_engine() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool ConvolutionParameter::has_engine() const {
return _internal_has_engine();
}
inline void ConvolutionParameter::clear_engine() {
engine_ = 0;
_has_bits_[0] &= ~0x00000200u;
}
inline ::caffe::ConvolutionParameter_Engine ConvolutionParameter::_internal_engine() const {
return static_cast< ::caffe::ConvolutionParameter_Engine >(engine_);
}
inline ::caffe::ConvolutionParameter_Engine ConvolutionParameter::engine() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.engine)
return _internal_engine();
}
inline void ConvolutionParameter::_internal_set_engine(::caffe::ConvolutionParameter_Engine value) {
assert(::caffe::ConvolutionParameter_Engine_IsValid(value));
_has_bits_[0] |= 0x00000200u;
engine_ = value;
}
inline void ConvolutionParameter::set_engine(::caffe::ConvolutionParameter_Engine value) {
_internal_set_engine(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.engine)
}
// optional int32 axis = 16 [default = 1];
inline bool ConvolutionParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00040000u) != 0;
return value;
}
inline bool ConvolutionParameter::has_axis() const {
return _internal_has_axis();
}
inline void ConvolutionParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00040000u;
}
inline int32_t ConvolutionParameter::_internal_axis() const {
return axis_;
}
inline int32_t ConvolutionParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.axis)
return _internal_axis();
}
inline void ConvolutionParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00040000u;
axis_ = value;
}
inline void ConvolutionParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.axis)
}
// optional bool force_nd_im2col = 17 [default = false];
inline bool ConvolutionParameter::_internal_has_force_nd_im2col() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool ConvolutionParameter::has_force_nd_im2col() const {
return _internal_has_force_nd_im2col();
}
inline void ConvolutionParameter::clear_force_nd_im2col() {
force_nd_im2col_ = false;
_has_bits_[0] &= ~0x00000400u;
}
inline bool ConvolutionParameter::_internal_force_nd_im2col() const {
return force_nd_im2col_;
}
inline bool ConvolutionParameter::force_nd_im2col() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.force_nd_im2col)
return _internal_force_nd_im2col();
}
inline void ConvolutionParameter::_internal_set_force_nd_im2col(bool value) {
_has_bits_[0] |= 0x00000400u;
force_nd_im2col_ = value;
}
inline void ConvolutionParameter::set_force_nd_im2col(bool value) {
_internal_set_force_nd_im2col(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.force_nd_im2col)
}
// optional uint32 paramq = 19;
inline bool ConvolutionParameter::_internal_has_paramq() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool ConvolutionParameter::has_paramq() const {
return _internal_has_paramq();
}
inline void ConvolutionParameter::clear_paramq() {
paramq_ = 0u;
_has_bits_[0] &= ~0x00000800u;
}
inline uint32_t ConvolutionParameter::_internal_paramq() const {
return paramq_;
}
inline uint32_t ConvolutionParameter::paramq() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.paramq)
return _internal_paramq();
}
inline void ConvolutionParameter::_internal_set_paramq(uint32_t value) {
_has_bits_[0] |= 0x00000800u;
paramq_ = value;
}
inline void ConvolutionParameter::set_paramq(uint32_t value) {
_internal_set_paramq(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.paramq)
}
// optional float params = 20 [default = 0];
inline bool ConvolutionParameter::_internal_has_params() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool ConvolutionParameter::has_params() const {
return _internal_has_params();
}
inline void ConvolutionParameter::clear_params() {
params_ = 0;
_has_bits_[0] &= ~0x00001000u;
}
inline float ConvolutionParameter::_internal_params() const {
return params_;
}
inline float ConvolutionParameter::params() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.params)
return _internal_params();
}
inline void ConvolutionParameter::_internal_set_params(float value) {
_has_bits_[0] |= 0x00001000u;
params_ = value;
}
inline void ConvolutionParameter::set_params(float value) {
_internal_set_params(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.params)
}
// optional float scale_in = 21;
inline bool ConvolutionParameter::_internal_has_scale_in() const {
bool value = (_has_bits_[0] & 0x00002000u) != 0;
return value;
}
inline bool ConvolutionParameter::has_scale_in() const {
return _internal_has_scale_in();
}
inline void ConvolutionParameter::clear_scale_in() {
scale_in_ = 0;
_has_bits_[0] &= ~0x00002000u;
}
inline float ConvolutionParameter::_internal_scale_in() const {
return scale_in_;
}
inline float ConvolutionParameter::scale_in() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.scale_in)
return _internal_scale_in();
}
inline void ConvolutionParameter::_internal_set_scale_in(float value) {
_has_bits_[0] |= 0x00002000u;
scale_in_ = value;
}
inline void ConvolutionParameter::set_scale_in(float value) {
_internal_set_scale_in(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.scale_in)
}
// optional float scale_out = 22;
inline bool ConvolutionParameter::_internal_has_scale_out() const {
bool value = (_has_bits_[0] & 0x00004000u) != 0;
return value;
}
inline bool ConvolutionParameter::has_scale_out() const {
return _internal_has_scale_out();
}
inline void ConvolutionParameter::clear_scale_out() {
scale_out_ = 0;
_has_bits_[0] &= ~0x00004000u;
}
inline float ConvolutionParameter::_internal_scale_out() const {
return scale_out_;
}
inline float ConvolutionParameter::scale_out() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.scale_out)
return _internal_scale_out();
}
inline void ConvolutionParameter::_internal_set_scale_out(float value) {
_has_bits_[0] |= 0x00004000u;
scale_out_ = value;
}
inline void ConvolutionParameter::set_scale_out(float value) {
_internal_set_scale_out(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.scale_out)
}
// optional int32 a_min = 23 [default = -128];
inline bool ConvolutionParameter::_internal_has_a_min() const {
bool value = (_has_bits_[0] & 0x00080000u) != 0;
return value;
}
inline bool ConvolutionParameter::has_a_min() const {
return _internal_has_a_min();
}
inline void ConvolutionParameter::clear_a_min() {
a_min_ = -128;
_has_bits_[0] &= ~0x00080000u;
}
inline int32_t ConvolutionParameter::_internal_a_min() const {
return a_min_;
}
inline int32_t ConvolutionParameter::a_min() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.a_min)
return _internal_a_min();
}
inline void ConvolutionParameter::_internal_set_a_min(int32_t value) {
_has_bits_[0] |= 0x00080000u;
a_min_ = value;
}
inline void ConvolutionParameter::set_a_min(int32_t value) {
_internal_set_a_min(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.a_min)
}
// optional int32 a_max = 24 [default = 127];
inline bool ConvolutionParameter::_internal_has_a_max() const {
bool value = (_has_bits_[0] & 0x00008000u) != 0;
return value;
}
inline bool ConvolutionParameter::has_a_max() const {
return _internal_has_a_max();
}
inline void ConvolutionParameter::clear_a_max() {
a_max_ = 127;
_has_bits_[0] &= ~0x00008000u;
}
inline int32_t ConvolutionParameter::_internal_a_max() const {
return a_max_;
}
inline int32_t ConvolutionParameter::a_max() const {
// @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.a_max)
return _internal_a_max();
}
inline void ConvolutionParameter::_internal_set_a_max(int32_t value) {
_has_bits_[0] |= 0x00008000u;
a_max_ = value;
}
inline void ConvolutionParameter::set_a_max(int32_t value) {
_internal_set_a_max(value);
// @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.a_max)
}
// -------------------------------------------------------------------
// Convolution3DParameter
// optional uint32 num_output = 1;
inline bool Convolution3DParameter::_internal_has_num_output() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool Convolution3DParameter::has_num_output() const {
return _internal_has_num_output();
}
inline void Convolution3DParameter::clear_num_output() {
num_output_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t Convolution3DParameter::_internal_num_output() const {
return num_output_;
}
inline uint32_t Convolution3DParameter::num_output() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.num_output)
return _internal_num_output();
}
inline void Convolution3DParameter::_internal_set_num_output(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
num_output_ = value;
}
inline void Convolution3DParameter::set_num_output(uint32_t value) {
_internal_set_num_output(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.num_output)
}
// optional bool bias_term = 2 [default = true];
inline bool Convolution3DParameter::_internal_has_bias_term() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool Convolution3DParameter::has_bias_term() const {
return _internal_has_bias_term();
}
inline void Convolution3DParameter::clear_bias_term() {
bias_term_ = true;
_has_bits_[0] &= ~0x00000100u;
}
inline bool Convolution3DParameter::_internal_bias_term() const {
return bias_term_;
}
inline bool Convolution3DParameter::bias_term() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.bias_term)
return _internal_bias_term();
}
inline void Convolution3DParameter::_internal_set_bias_term(bool value) {
_has_bits_[0] |= 0x00000100u;
bias_term_ = value;
}
inline void Convolution3DParameter::set_bias_term(bool value) {
_internal_set_bias_term(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.bias_term)
}
// optional uint32 pad = 3 [default = 0];
inline bool Convolution3DParameter::_internal_has_pad() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool Convolution3DParameter::has_pad() const {
return _internal_has_pad();
}
inline void Convolution3DParameter::clear_pad() {
pad_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Convolution3DParameter::_internal_pad() const {
return pad_;
}
inline uint32_t Convolution3DParameter::pad() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.pad)
return _internal_pad();
}
inline void Convolution3DParameter::_internal_set_pad(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
pad_ = value;
}
inline void Convolution3DParameter::set_pad(uint32_t value) {
_internal_set_pad(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.pad)
}
// optional uint32 kernel_size = 4;
inline bool Convolution3DParameter::_internal_has_kernel_size() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool Convolution3DParameter::has_kernel_size() const {
return _internal_has_kernel_size();
}
inline void Convolution3DParameter::clear_kernel_size() {
kernel_size_ = 0u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t Convolution3DParameter::_internal_kernel_size() const {
return kernel_size_;
}
inline uint32_t Convolution3DParameter::kernel_size() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.kernel_size)
return _internal_kernel_size();
}
inline void Convolution3DParameter::_internal_set_kernel_size(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
kernel_size_ = value;
}
inline void Convolution3DParameter::set_kernel_size(uint32_t value) {
_internal_set_kernel_size(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.kernel_size)
}
// optional uint32 group = 5 [default = 1];
inline bool Convolution3DParameter::_internal_has_group() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool Convolution3DParameter::has_group() const {
return _internal_has_group();
}
inline void Convolution3DParameter::clear_group() {
group_ = 1u;
_has_bits_[0] &= ~0x00000200u;
}
inline uint32_t Convolution3DParameter::_internal_group() const {
return group_;
}
inline uint32_t Convolution3DParameter::group() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.group)
return _internal_group();
}
inline void Convolution3DParameter::_internal_set_group(uint32_t value) {
_has_bits_[0] |= 0x00000200u;
group_ = value;
}
inline void Convolution3DParameter::set_group(uint32_t value) {
_internal_set_group(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.group)
}
// optional uint32 kernel_depth = 6;
inline bool Convolution3DParameter::_internal_has_kernel_depth() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool Convolution3DParameter::has_kernel_depth() const {
return _internal_has_kernel_depth();
}
inline void Convolution3DParameter::clear_kernel_depth() {
kernel_depth_ = 0u;
_has_bits_[0] &= ~0x00000020u;
}
inline uint32_t Convolution3DParameter::_internal_kernel_depth() const {
return kernel_depth_;
}
inline uint32_t Convolution3DParameter::kernel_depth() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.kernel_depth)
return _internal_kernel_depth();
}
inline void Convolution3DParameter::_internal_set_kernel_depth(uint32_t value) {
_has_bits_[0] |= 0x00000020u;
kernel_depth_ = value;
}
inline void Convolution3DParameter::set_kernel_depth(uint32_t value) {
_internal_set_kernel_depth(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.kernel_depth)
}
// optional uint32 stride = 7 [default = 1];
inline bool Convolution3DParameter::_internal_has_stride() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool Convolution3DParameter::has_stride() const {
return _internal_has_stride();
}
inline void Convolution3DParameter::clear_stride() {
stride_ = 1u;
_has_bits_[0] &= ~0x00000400u;
}
inline uint32_t Convolution3DParameter::_internal_stride() const {
return stride_;
}
inline uint32_t Convolution3DParameter::stride() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.stride)
return _internal_stride();
}
inline void Convolution3DParameter::_internal_set_stride(uint32_t value) {
_has_bits_[0] |= 0x00000400u;
stride_ = value;
}
inline void Convolution3DParameter::set_stride(uint32_t value) {
_internal_set_stride(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.stride)
}
// optional uint32 temporal_stride = 8 [default = 1];
inline bool Convolution3DParameter::_internal_has_temporal_stride() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool Convolution3DParameter::has_temporal_stride() const {
return _internal_has_temporal_stride();
}
inline void Convolution3DParameter::clear_temporal_stride() {
temporal_stride_ = 1u;
_has_bits_[0] &= ~0x00000800u;
}
inline uint32_t Convolution3DParameter::_internal_temporal_stride() const {
return temporal_stride_;
}
inline uint32_t Convolution3DParameter::temporal_stride() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.temporal_stride)
return _internal_temporal_stride();
}
inline void Convolution3DParameter::_internal_set_temporal_stride(uint32_t value) {
_has_bits_[0] |= 0x00000800u;
temporal_stride_ = value;
}
inline void Convolution3DParameter::set_temporal_stride(uint32_t value) {
_internal_set_temporal_stride(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.temporal_stride)
}
// optional .caffe.FillerParameter weight_filler = 9;
inline bool Convolution3DParameter::_internal_has_weight_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || weight_filler_ != nullptr);
return value;
}
inline bool Convolution3DParameter::has_weight_filler() const {
return _internal_has_weight_filler();
}
inline void Convolution3DParameter::clear_weight_filler() {
if (weight_filler_ != nullptr) weight_filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& Convolution3DParameter::_internal_weight_filler() const {
const ::caffe::FillerParameter* p = weight_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& Convolution3DParameter::weight_filler() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.weight_filler)
return _internal_weight_filler();
}
inline void Convolution3DParameter::unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_);
}
weight_filler_ = weight_filler;
if (weight_filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.Convolution3DParameter.weight_filler)
}
inline ::caffe::FillerParameter* Convolution3DParameter::release_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* Convolution3DParameter::unsafe_arena_release_weight_filler() {
// @@protoc_insertion_point(field_release:caffe.Convolution3DParameter.weight_filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* Convolution3DParameter::_internal_mutable_weight_filler() {
_has_bits_[0] |= 0x00000001u;
if (weight_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
weight_filler_ = p;
}
return weight_filler_;
}
inline ::caffe::FillerParameter* Convolution3DParameter::mutable_weight_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
// @@protoc_insertion_point(field_mutable:caffe.Convolution3DParameter.weight_filler)
return _msg;
}
inline void Convolution3DParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete weight_filler_;
}
if (weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(weight_filler);
if (message_arena != submessage_arena) {
weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.Convolution3DParameter.weight_filler)
}
// optional .caffe.FillerParameter bias_filler = 10;
inline bool Convolution3DParameter::_internal_has_bias_filler() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || bias_filler_ != nullptr);
return value;
}
inline bool Convolution3DParameter::has_bias_filler() const {
return _internal_has_bias_filler();
}
inline void Convolution3DParameter::clear_bias_filler() {
if (bias_filler_ != nullptr) bias_filler_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::FillerParameter& Convolution3DParameter::_internal_bias_filler() const {
const ::caffe::FillerParameter* p = bias_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& Convolution3DParameter::bias_filler() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.bias_filler)
return _internal_bias_filler();
}
inline void Convolution3DParameter::unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_);
}
bias_filler_ = bias_filler;
if (bias_filler) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.Convolution3DParameter.bias_filler)
}
inline ::caffe::FillerParameter* Convolution3DParameter::release_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* Convolution3DParameter::unsafe_arena_release_bias_filler() {
// @@protoc_insertion_point(field_release:caffe.Convolution3DParameter.bias_filler)
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* Convolution3DParameter::_internal_mutable_bias_filler() {
_has_bits_[0] |= 0x00000002u;
if (bias_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
bias_filler_ = p;
}
return bias_filler_;
}
inline ::caffe::FillerParameter* Convolution3DParameter::mutable_bias_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
// @@protoc_insertion_point(field_mutable:caffe.Convolution3DParameter.bias_filler)
return _msg;
}
inline void Convolution3DParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_filler_;
}
if (bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(bias_filler);
if (message_arena != submessage_arena) {
bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.Convolution3DParameter.bias_filler)
}
// optional uint32 filter_group = 11 [default = 1];
inline bool Convolution3DParameter::_internal_has_filter_group() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool Convolution3DParameter::has_filter_group() const {
return _internal_has_filter_group();
}
inline void Convolution3DParameter::clear_filter_group() {
filter_group_ = 1u;
_has_bits_[0] &= ~0x00000080u;
}
inline uint32_t Convolution3DParameter::_internal_filter_group() const {
return filter_group_;
}
inline uint32_t Convolution3DParameter::filter_group() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.filter_group)
return _internal_filter_group();
}
inline void Convolution3DParameter::_internal_set_filter_group(uint32_t value) {
_has_bits_[0] |= 0x00000080u;
filter_group_ = value;
}
inline void Convolution3DParameter::set_filter_group(uint32_t value) {
_internal_set_filter_group(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.filter_group)
}
// optional uint32 temporal_pad = 12 [default = 0];
inline bool Convolution3DParameter::_internal_has_temporal_pad() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool Convolution3DParameter::has_temporal_pad() const {
return _internal_has_temporal_pad();
}
inline void Convolution3DParameter::clear_temporal_pad() {
temporal_pad_ = 0u;
_has_bits_[0] &= ~0x00000040u;
}
inline uint32_t Convolution3DParameter::_internal_temporal_pad() const {
return temporal_pad_;
}
inline uint32_t Convolution3DParameter::temporal_pad() const {
// @@protoc_insertion_point(field_get:caffe.Convolution3DParameter.temporal_pad)
return _internal_temporal_pad();
}
inline void Convolution3DParameter::_internal_set_temporal_pad(uint32_t value) {
_has_bits_[0] |= 0x00000040u;
temporal_pad_ = value;
}
inline void Convolution3DParameter::set_temporal_pad(uint32_t value) {
_internal_set_temporal_pad(value);
// @@protoc_insertion_point(field_set:caffe.Convolution3DParameter.temporal_pad)
}
// -------------------------------------------------------------------
// CropParameter
// optional int32 axis = 1 [default = 2];
inline bool CropParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool CropParameter::has_axis() const {
return _internal_has_axis();
}
inline void CropParameter::clear_axis() {
axis_ = 2;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t CropParameter::_internal_axis() const {
return axis_;
}
inline int32_t CropParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.CropParameter.axis)
return _internal_axis();
}
inline void CropParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000001u;
axis_ = value;
}
inline void CropParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.CropParameter.axis)
}
// repeated uint32 offset = 2;
inline int CropParameter::_internal_offset_size() const {
return offset_.size();
}
inline int CropParameter::offset_size() const {
return _internal_offset_size();
}
inline void CropParameter::clear_offset() {
offset_.Clear();
}
inline uint32_t CropParameter::_internal_offset(int index) const {
return offset_.Get(index);
}
inline uint32_t CropParameter::offset(int index) const {
// @@protoc_insertion_point(field_get:caffe.CropParameter.offset)
return _internal_offset(index);
}
inline void CropParameter::set_offset(int index, uint32_t value) {
offset_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.CropParameter.offset)
}
inline void CropParameter::_internal_add_offset(uint32_t value) {
offset_.Add(value);
}
inline void CropParameter::add_offset(uint32_t value) {
_internal_add_offset(value);
// @@protoc_insertion_point(field_add:caffe.CropParameter.offset)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CropParameter::_internal_offset() const {
return offset_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CropParameter::offset() const {
// @@protoc_insertion_point(field_list:caffe.CropParameter.offset)
return _internal_offset();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CropParameter::_internal_mutable_offset() {
return &offset_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CropParameter::mutable_offset() {
// @@protoc_insertion_point(field_mutable_list:caffe.CropParameter.offset)
return _internal_mutable_offset();
}
// -------------------------------------------------------------------
// DataParameter
// optional string source = 1;
inline bool DataParameter::_internal_has_source() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool DataParameter::has_source() const {
return _internal_has_source();
}
inline void DataParameter::clear_source() {
source_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DataParameter::source() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.source)
return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataParameter::set_source(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.DataParameter.source)
}
inline std::string* DataParameter::mutable_source() {
std::string* _s = _internal_mutable_source();
// @@protoc_insertion_point(field_mutable:caffe.DataParameter.source)
return _s;
}
inline const std::string& DataParameter::_internal_source() const {
return source_.Get();
}
inline void DataParameter::_internal_set_source(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DataParameter::_internal_mutable_source() {
_has_bits_[0] |= 0x00000001u;
return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DataParameter::release_source() {
// @@protoc_insertion_point(field_release:caffe.DataParameter.source)
if (!_internal_has_source()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void DataParameter::set_allocated_source(std::string* source) {
if (source != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.DataParameter.source)
}
// optional uint32 batch_size = 4;
inline bool DataParameter::_internal_has_batch_size() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool DataParameter::has_batch_size() const {
return _internal_has_batch_size();
}
inline void DataParameter::clear_batch_size() {
batch_size_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t DataParameter::_internal_batch_size() const {
return batch_size_;
}
inline uint32_t DataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.batch_size)
return _internal_batch_size();
}
inline void DataParameter::_internal_set_batch_size(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
batch_size_ = value;
}
inline void DataParameter::set_batch_size(uint32_t value) {
_internal_set_batch_size(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.batch_size)
}
// optional uint32 rand_skip = 7 [default = 0];
inline bool DataParameter::_internal_has_rand_skip() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool DataParameter::has_rand_skip() const {
return _internal_has_rand_skip();
}
inline void DataParameter::clear_rand_skip() {
rand_skip_ = 0u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t DataParameter::_internal_rand_skip() const {
return rand_skip_;
}
inline uint32_t DataParameter::rand_skip() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.rand_skip)
return _internal_rand_skip();
}
inline void DataParameter::_internal_set_rand_skip(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
rand_skip_ = value;
}
inline void DataParameter::set_rand_skip(uint32_t value) {
_internal_set_rand_skip(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.rand_skip)
}
// optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB];
inline bool DataParameter::_internal_has_backend() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool DataParameter::has_backend() const {
return _internal_has_backend();
}
inline void DataParameter::clear_backend() {
backend_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline ::caffe::DataParameter_DB DataParameter::_internal_backend() const {
return static_cast< ::caffe::DataParameter_DB >(backend_);
}
inline ::caffe::DataParameter_DB DataParameter::backend() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.backend)
return _internal_backend();
}
inline void DataParameter::_internal_set_backend(::caffe::DataParameter_DB value) {
assert(::caffe::DataParameter_DB_IsValid(value));
_has_bits_[0] |= 0x00000020u;
backend_ = value;
}
inline void DataParameter::set_backend(::caffe::DataParameter_DB value) {
_internal_set_backend(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.backend)
}
// optional float scale = 2 [default = 1];
inline bool DataParameter::_internal_has_scale() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool DataParameter::has_scale() const {
return _internal_has_scale();
}
inline void DataParameter::clear_scale() {
scale_ = 1;
_has_bits_[0] &= ~0x00000800u;
}
inline float DataParameter::_internal_scale() const {
return scale_;
}
inline float DataParameter::scale() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.scale)
return _internal_scale();
}
inline void DataParameter::_internal_set_scale(float value) {
_has_bits_[0] |= 0x00000800u;
scale_ = value;
}
inline void DataParameter::set_scale(float value) {
_internal_set_scale(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.scale)
}
// optional string mean_file = 3;
inline bool DataParameter::_internal_has_mean_file() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool DataParameter::has_mean_file() const {
return _internal_has_mean_file();
}
inline void DataParameter::clear_mean_file() {
mean_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DataParameter::mean_file() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.mean_file)
return _internal_mean_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataParameter::set_mean_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.DataParameter.mean_file)
}
inline std::string* DataParameter::mutable_mean_file() {
std::string* _s = _internal_mutable_mean_file();
// @@protoc_insertion_point(field_mutable:caffe.DataParameter.mean_file)
return _s;
}
inline const std::string& DataParameter::_internal_mean_file() const {
return mean_file_.Get();
}
inline void DataParameter::_internal_set_mean_file(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DataParameter::_internal_mutable_mean_file() {
_has_bits_[0] |= 0x00000002u;
return mean_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DataParameter::release_mean_file() {
// @@protoc_insertion_point(field_release:caffe.DataParameter.mean_file)
if (!_internal_has_mean_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = mean_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void DataParameter::set_allocated_mean_file(std::string* mean_file) {
if (mean_file != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
mean_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mean_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.DataParameter.mean_file)
}
// optional uint32 crop_size = 5 [default = 0];
inline bool DataParameter::_internal_has_crop_size() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool DataParameter::has_crop_size() const {
return _internal_has_crop_size();
}
inline void DataParameter::clear_crop_size() {
crop_size_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t DataParameter::_internal_crop_size() const {
return crop_size_;
}
inline uint32_t DataParameter::crop_size() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.crop_size)
return _internal_crop_size();
}
inline void DataParameter::_internal_set_crop_size(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
crop_size_ = value;
}
inline void DataParameter::set_crop_size(uint32_t value) {
_internal_set_crop_size(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.crop_size)
}
// optional bool mirror = 6 [default = false];
inline bool DataParameter::_internal_has_mirror() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool DataParameter::has_mirror() const {
return _internal_has_mirror();
}
inline void DataParameter::clear_mirror() {
mirror_ = false;
_has_bits_[0] &= ~0x00000040u;
}
inline bool DataParameter::_internal_mirror() const {
return mirror_;
}
inline bool DataParameter::mirror() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.mirror)
return _internal_mirror();
}
inline void DataParameter::_internal_set_mirror(bool value) {
_has_bits_[0] |= 0x00000040u;
mirror_ = value;
}
inline void DataParameter::set_mirror(bool value) {
_internal_set_mirror(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.mirror)
}
// optional bool force_encoded_color = 9 [default = false];
inline bool DataParameter::_internal_has_force_encoded_color() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool DataParameter::has_force_encoded_color() const {
return _internal_has_force_encoded_color();
}
inline void DataParameter::clear_force_encoded_color() {
force_encoded_color_ = false;
_has_bits_[0] &= ~0x00000080u;
}
inline bool DataParameter::_internal_force_encoded_color() const {
return force_encoded_color_;
}
inline bool DataParameter::force_encoded_color() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.force_encoded_color)
return _internal_force_encoded_color();
}
inline void DataParameter::_internal_set_force_encoded_color(bool value) {
_has_bits_[0] |= 0x00000080u;
force_encoded_color_ = value;
}
inline void DataParameter::set_force_encoded_color(bool value) {
_internal_set_force_encoded_color(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.force_encoded_color)
}
// optional uint32 prefetch = 10 [default = 4];
inline bool DataParameter::_internal_has_prefetch() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool DataParameter::has_prefetch() const {
return _internal_has_prefetch();
}
inline void DataParameter::clear_prefetch() {
prefetch_ = 4u;
_has_bits_[0] &= ~0x00001000u;
}
inline uint32_t DataParameter::_internal_prefetch() const {
return prefetch_;
}
inline uint32_t DataParameter::prefetch() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.prefetch)
return _internal_prefetch();
}
inline void DataParameter::_internal_set_prefetch(uint32_t value) {
_has_bits_[0] |= 0x00001000u;
prefetch_ = value;
}
inline void DataParameter::set_prefetch(uint32_t value) {
_internal_set_prefetch(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.prefetch)
}
// optional uint32 label_size = 11 [default = 0];
inline bool DataParameter::_internal_has_label_size() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool DataParameter::has_label_size() const {
return _internal_has_label_size();
}
inline void DataParameter::clear_label_size() {
label_size_ = 0u;
_has_bits_[0] &= ~0x00000200u;
}
inline uint32_t DataParameter::_internal_label_size() const {
return label_size_;
}
inline uint32_t DataParameter::label_size() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.label_size)
return _internal_label_size();
}
inline void DataParameter::_internal_set_label_size(uint32_t value) {
_has_bits_[0] |= 0x00000200u;
label_size_ = value;
}
inline void DataParameter::set_label_size(uint32_t value) {
_internal_set_label_size(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.label_size)
}
// optional uint32 data_width = 12 [default = 0];
inline bool DataParameter::_internal_has_data_width() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool DataParameter::has_data_width() const {
return _internal_has_data_width();
}
inline void DataParameter::clear_data_width() {
data_width_ = 0u;
_has_bits_[0] &= ~0x00000400u;
}
inline uint32_t DataParameter::_internal_data_width() const {
return data_width_;
}
inline uint32_t DataParameter::data_width() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.data_width)
return _internal_data_width();
}
inline void DataParameter::_internal_set_data_width(uint32_t value) {
_has_bits_[0] |= 0x00000400u;
data_width_ = value;
}
inline void DataParameter::set_data_width(uint32_t value) {
_internal_set_data_width(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.data_width)
}
// optional bool output_width = 13 [default = false];
inline bool DataParameter::_internal_has_output_width() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool DataParameter::has_output_width() const {
return _internal_has_output_width();
}
inline void DataParameter::clear_output_width() {
output_width_ = false;
_has_bits_[0] &= ~0x00000100u;
}
inline bool DataParameter::_internal_output_width() const {
return output_width_;
}
inline bool DataParameter::output_width() const {
// @@protoc_insertion_point(field_get:caffe.DataParameter.output_width)
return _internal_output_width();
}
inline void DataParameter::_internal_set_output_width(bool value) {
_has_bits_[0] |= 0x00000100u;
output_width_ = value;
}
inline void DataParameter::set_output_width(bool value) {
_internal_set_output_width(value);
// @@protoc_insertion_point(field_set:caffe.DataParameter.output_width)
}
// -------------------------------------------------------------------
// DetectionEvaluateParameter
// optional uint32 num_classes = 1;
inline bool DetectionEvaluateParameter::_internal_has_num_classes() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool DetectionEvaluateParameter::has_num_classes() const {
return _internal_has_num_classes();
}
inline void DetectionEvaluateParameter::clear_num_classes() {
num_classes_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t DetectionEvaluateParameter::_internal_num_classes() const {
return num_classes_;
}
inline uint32_t DetectionEvaluateParameter::num_classes() const {
// @@protoc_insertion_point(field_get:caffe.DetectionEvaluateParameter.num_classes)
return _internal_num_classes();
}
inline void DetectionEvaluateParameter::_internal_set_num_classes(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
num_classes_ = value;
}
inline void DetectionEvaluateParameter::set_num_classes(uint32_t value) {
_internal_set_num_classes(value);
// @@protoc_insertion_point(field_set:caffe.DetectionEvaluateParameter.num_classes)
}
// optional uint32 background_label_id = 2 [default = 0];
inline bool DetectionEvaluateParameter::_internal_has_background_label_id() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool DetectionEvaluateParameter::has_background_label_id() const {
return _internal_has_background_label_id();
}
inline void DetectionEvaluateParameter::clear_background_label_id() {
background_label_id_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t DetectionEvaluateParameter::_internal_background_label_id() const {
return background_label_id_;
}
inline uint32_t DetectionEvaluateParameter::background_label_id() const {
// @@protoc_insertion_point(field_get:caffe.DetectionEvaluateParameter.background_label_id)
return _internal_background_label_id();
}
inline void DetectionEvaluateParameter::_internal_set_background_label_id(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
background_label_id_ = value;
}
inline void DetectionEvaluateParameter::set_background_label_id(uint32_t value) {
_internal_set_background_label_id(value);
// @@protoc_insertion_point(field_set:caffe.DetectionEvaluateParameter.background_label_id)
}
// optional float overlap_threshold = 3 [default = 0.5];
inline bool DetectionEvaluateParameter::_internal_has_overlap_threshold() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool DetectionEvaluateParameter::has_overlap_threshold() const {
return _internal_has_overlap_threshold();
}
inline void DetectionEvaluateParameter::clear_overlap_threshold() {
overlap_threshold_ = 0.5f;
_has_bits_[0] &= ~0x00000010u;
}
inline float DetectionEvaluateParameter::_internal_overlap_threshold() const {
return overlap_threshold_;
}
inline float DetectionEvaluateParameter::overlap_threshold() const {
// @@protoc_insertion_point(field_get:caffe.DetectionEvaluateParameter.overlap_threshold)
return _internal_overlap_threshold();
}
inline void DetectionEvaluateParameter::_internal_set_overlap_threshold(float value) {
_has_bits_[0] |= 0x00000010u;
overlap_threshold_ = value;
}
inline void DetectionEvaluateParameter::set_overlap_threshold(float value) {
_internal_set_overlap_threshold(value);
// @@protoc_insertion_point(field_set:caffe.DetectionEvaluateParameter.overlap_threshold)
}
// optional bool evaluate_difficult_gt = 4 [default = true];
inline bool DetectionEvaluateParameter::_internal_has_evaluate_difficult_gt() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool DetectionEvaluateParameter::has_evaluate_difficult_gt() const {
return _internal_has_evaluate_difficult_gt();
}
inline void DetectionEvaluateParameter::clear_evaluate_difficult_gt() {
evaluate_difficult_gt_ = true;
_has_bits_[0] &= ~0x00000020u;
}
inline bool DetectionEvaluateParameter::_internal_evaluate_difficult_gt() const {
return evaluate_difficult_gt_;
}
inline bool DetectionEvaluateParameter::evaluate_difficult_gt() const {
// @@protoc_insertion_point(field_get:caffe.DetectionEvaluateParameter.evaluate_difficult_gt)
return _internal_evaluate_difficult_gt();
}
inline void DetectionEvaluateParameter::_internal_set_evaluate_difficult_gt(bool value) {
_has_bits_[0] |= 0x00000020u;
evaluate_difficult_gt_ = value;
}
inline void DetectionEvaluateParameter::set_evaluate_difficult_gt(bool value) {
_internal_set_evaluate_difficult_gt(value);
// @@protoc_insertion_point(field_set:caffe.DetectionEvaluateParameter.evaluate_difficult_gt)
}
// optional string name_size_file = 5;
inline bool DetectionEvaluateParameter::_internal_has_name_size_file() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool DetectionEvaluateParameter::has_name_size_file() const {
return _internal_has_name_size_file();
}
inline void DetectionEvaluateParameter::clear_name_size_file() {
name_size_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DetectionEvaluateParameter::name_size_file() const {
// @@protoc_insertion_point(field_get:caffe.DetectionEvaluateParameter.name_size_file)
return _internal_name_size_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DetectionEvaluateParameter::set_name_size_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_size_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.DetectionEvaluateParameter.name_size_file)
}
inline std::string* DetectionEvaluateParameter::mutable_name_size_file() {
std::string* _s = _internal_mutable_name_size_file();
// @@protoc_insertion_point(field_mutable:caffe.DetectionEvaluateParameter.name_size_file)
return _s;
}
inline const std::string& DetectionEvaluateParameter::_internal_name_size_file() const {
return name_size_file_.Get();
}
inline void DetectionEvaluateParameter::_internal_set_name_size_file(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_size_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DetectionEvaluateParameter::_internal_mutable_name_size_file() {
_has_bits_[0] |= 0x00000001u;
return name_size_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DetectionEvaluateParameter::release_name_size_file() {
// @@protoc_insertion_point(field_release:caffe.DetectionEvaluateParameter.name_size_file)
if (!_internal_has_name_size_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_size_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_size_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void DetectionEvaluateParameter::set_allocated_name_size_file(std::string* name_size_file) {
if (name_size_file != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_size_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name_size_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_size_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.DetectionEvaluateParameter.name_size_file)
}
// optional .caffe.ResizeParameter resize_param = 6;
inline bool DetectionEvaluateParameter::_internal_has_resize_param() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || resize_param_ != nullptr);
return value;
}
inline bool DetectionEvaluateParameter::has_resize_param() const {
return _internal_has_resize_param();
}
inline void DetectionEvaluateParameter::clear_resize_param() {
if (resize_param_ != nullptr) resize_param_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::ResizeParameter& DetectionEvaluateParameter::_internal_resize_param() const {
const ::caffe::ResizeParameter* p = resize_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ResizeParameter&>(
::caffe::_ResizeParameter_default_instance_);
}
inline const ::caffe::ResizeParameter& DetectionEvaluateParameter::resize_param() const {
// @@protoc_insertion_point(field_get:caffe.DetectionEvaluateParameter.resize_param)
return _internal_resize_param();
}
inline void DetectionEvaluateParameter::unsafe_arena_set_allocated_resize_param(
::caffe::ResizeParameter* resize_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(resize_param_);
}
resize_param_ = resize_param;
if (resize_param) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.DetectionEvaluateParameter.resize_param)
}
inline ::caffe::ResizeParameter* DetectionEvaluateParameter::release_resize_param() {
_has_bits_[0] &= ~0x00000002u;
::caffe::ResizeParameter* temp = resize_param_;
resize_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ResizeParameter* DetectionEvaluateParameter::unsafe_arena_release_resize_param() {
// @@protoc_insertion_point(field_release:caffe.DetectionEvaluateParameter.resize_param)
_has_bits_[0] &= ~0x00000002u;
::caffe::ResizeParameter* temp = resize_param_;
resize_param_ = nullptr;
return temp;
}
inline ::caffe::ResizeParameter* DetectionEvaluateParameter::_internal_mutable_resize_param() {
_has_bits_[0] |= 0x00000002u;
if (resize_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ResizeParameter>(GetArenaForAllocation());
resize_param_ = p;
}
return resize_param_;
}
inline ::caffe::ResizeParameter* DetectionEvaluateParameter::mutable_resize_param() {
::caffe::ResizeParameter* _msg = _internal_mutable_resize_param();
// @@protoc_insertion_point(field_mutable:caffe.DetectionEvaluateParameter.resize_param)
return _msg;
}
inline void DetectionEvaluateParameter::set_allocated_resize_param(::caffe::ResizeParameter* resize_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete resize_param_;
}
if (resize_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ResizeParameter>::GetOwningArena(resize_param);
if (message_arena != submessage_arena) {
resize_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, resize_param, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
resize_param_ = resize_param;
// @@protoc_insertion_point(field_set_allocated:caffe.DetectionEvaluateParameter.resize_param)
}
// -------------------------------------------------------------------
// NonMaximumSuppressionParameter
// optional float nms_threshold = 1 [default = 0.3];
inline bool NonMaximumSuppressionParameter::_internal_has_nms_threshold() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool NonMaximumSuppressionParameter::has_nms_threshold() const {
return _internal_has_nms_threshold();
}
inline void NonMaximumSuppressionParameter::clear_nms_threshold() {
nms_threshold_ = 0.3f;
_has_bits_[0] &= ~0x00000002u;
}
inline float NonMaximumSuppressionParameter::_internal_nms_threshold() const {
return nms_threshold_;
}
inline float NonMaximumSuppressionParameter::nms_threshold() const {
// @@protoc_insertion_point(field_get:caffe.NonMaximumSuppressionParameter.nms_threshold)
return _internal_nms_threshold();
}
inline void NonMaximumSuppressionParameter::_internal_set_nms_threshold(float value) {
_has_bits_[0] |= 0x00000002u;
nms_threshold_ = value;
}
inline void NonMaximumSuppressionParameter::set_nms_threshold(float value) {
_internal_set_nms_threshold(value);
// @@protoc_insertion_point(field_set:caffe.NonMaximumSuppressionParameter.nms_threshold)
}
// optional int32 top_k = 2;
inline bool NonMaximumSuppressionParameter::_internal_has_top_k() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool NonMaximumSuppressionParameter::has_top_k() const {
return _internal_has_top_k();
}
inline void NonMaximumSuppressionParameter::clear_top_k() {
top_k_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t NonMaximumSuppressionParameter::_internal_top_k() const {
return top_k_;
}
inline int32_t NonMaximumSuppressionParameter::top_k() const {
// @@protoc_insertion_point(field_get:caffe.NonMaximumSuppressionParameter.top_k)
return _internal_top_k();
}
inline void NonMaximumSuppressionParameter::_internal_set_top_k(int32_t value) {
_has_bits_[0] |= 0x00000001u;
top_k_ = value;
}
inline void NonMaximumSuppressionParameter::set_top_k(int32_t value) {
_internal_set_top_k(value);
// @@protoc_insertion_point(field_set:caffe.NonMaximumSuppressionParameter.top_k)
}
// optional float eta = 3 [default = 1];
inline bool NonMaximumSuppressionParameter::_internal_has_eta() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool NonMaximumSuppressionParameter::has_eta() const {
return _internal_has_eta();
}
inline void NonMaximumSuppressionParameter::clear_eta() {
eta_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline float NonMaximumSuppressionParameter::_internal_eta() const {
return eta_;
}
inline float NonMaximumSuppressionParameter::eta() const {
// @@protoc_insertion_point(field_get:caffe.NonMaximumSuppressionParameter.eta)
return _internal_eta();
}
inline void NonMaximumSuppressionParameter::_internal_set_eta(float value) {
_has_bits_[0] |= 0x00000004u;
eta_ = value;
}
inline void NonMaximumSuppressionParameter::set_eta(float value) {
_internal_set_eta(value);
// @@protoc_insertion_point(field_set:caffe.NonMaximumSuppressionParameter.eta)
}
// -------------------------------------------------------------------
// SaveOutputParameter
// optional string output_directory = 1;
inline bool SaveOutputParameter::_internal_has_output_directory() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SaveOutputParameter::has_output_directory() const {
return _internal_has_output_directory();
}
inline void SaveOutputParameter::clear_output_directory() {
output_directory_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SaveOutputParameter::output_directory() const {
// @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.output_directory)
return _internal_output_directory();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_output_directory(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
output_directory_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.output_directory)
}
inline std::string* SaveOutputParameter::mutable_output_directory() {
std::string* _s = _internal_mutable_output_directory();
// @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.output_directory)
return _s;
}
inline const std::string& SaveOutputParameter::_internal_output_directory() const {
return output_directory_.Get();
}
inline void SaveOutputParameter::_internal_set_output_directory(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
output_directory_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_output_directory() {
_has_bits_[0] |= 0x00000001u;
return output_directory_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_output_directory() {
// @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.output_directory)
if (!_internal_has_output_directory()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = output_directory_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (output_directory_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
output_directory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SaveOutputParameter::set_allocated_output_directory(std::string* output_directory) {
if (output_directory != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
output_directory_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), output_directory,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (output_directory_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
output_directory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.output_directory)
}
// optional string output_name_prefix = 2;
inline bool SaveOutputParameter::_internal_has_output_name_prefix() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool SaveOutputParameter::has_output_name_prefix() const {
return _internal_has_output_name_prefix();
}
inline void SaveOutputParameter::clear_output_name_prefix() {
output_name_prefix_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SaveOutputParameter::output_name_prefix() const {
// @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.output_name_prefix)
return _internal_output_name_prefix();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_output_name_prefix(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
output_name_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.output_name_prefix)
}
inline std::string* SaveOutputParameter::mutable_output_name_prefix() {
std::string* _s = _internal_mutable_output_name_prefix();
// @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.output_name_prefix)
return _s;
}
inline const std::string& SaveOutputParameter::_internal_output_name_prefix() const {
return output_name_prefix_.Get();
}
inline void SaveOutputParameter::_internal_set_output_name_prefix(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
output_name_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_output_name_prefix() {
_has_bits_[0] |= 0x00000002u;
return output_name_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_output_name_prefix() {
// @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.output_name_prefix)
if (!_internal_has_output_name_prefix()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = output_name_prefix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (output_name_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
output_name_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SaveOutputParameter::set_allocated_output_name_prefix(std::string* output_name_prefix) {
if (output_name_prefix != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
output_name_prefix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), output_name_prefix,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (output_name_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
output_name_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.output_name_prefix)
}
// optional string output_format = 3;
inline bool SaveOutputParameter::_internal_has_output_format() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool SaveOutputParameter::has_output_format() const {
return _internal_has_output_format();
}
inline void SaveOutputParameter::clear_output_format() {
output_format_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SaveOutputParameter::output_format() const {
// @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.output_format)
return _internal_output_format();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_output_format(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
output_format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.output_format)
}
inline std::string* SaveOutputParameter::mutable_output_format() {
std::string* _s = _internal_mutable_output_format();
// @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.output_format)
return _s;
}
inline const std::string& SaveOutputParameter::_internal_output_format() const {
return output_format_.Get();
}
inline void SaveOutputParameter::_internal_set_output_format(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
output_format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_output_format() {
_has_bits_[0] |= 0x00000004u;
return output_format_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_output_format() {
// @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.output_format)
if (!_internal_has_output_format()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = output_format_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (output_format_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
output_format_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SaveOutputParameter::set_allocated_output_format(std::string* output_format) {
if (output_format != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
output_format_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), output_format,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (output_format_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
output_format_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.output_format)
}
// optional string label_map_file = 4;
inline bool SaveOutputParameter::_internal_has_label_map_file() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool SaveOutputParameter::has_label_map_file() const {
return _internal_has_label_map_file();
}
inline void SaveOutputParameter::clear_label_map_file() {
label_map_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SaveOutputParameter::label_map_file() const {
// @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.label_map_file)
return _internal_label_map_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_label_map_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000008u;
label_map_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.label_map_file)
}
inline std::string* SaveOutputParameter::mutable_label_map_file() {
std::string* _s = _internal_mutable_label_map_file();
// @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.label_map_file)
return _s;
}
inline const std::string& SaveOutputParameter::_internal_label_map_file() const {
return label_map_file_.Get();
}
inline void SaveOutputParameter::_internal_set_label_map_file(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
label_map_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_label_map_file() {
_has_bits_[0] |= 0x00000008u;
return label_map_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_label_map_file() {
// @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.label_map_file)
if (!_internal_has_label_map_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
auto* p = label_map_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (label_map_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SaveOutputParameter::set_allocated_label_map_file(std::string* label_map_file) {
if (label_map_file != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
label_map_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), label_map_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (label_map_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.label_map_file)
}
// optional string name_size_file = 5;
inline bool SaveOutputParameter::_internal_has_name_size_file() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool SaveOutputParameter::has_name_size_file() const {
return _internal_has_name_size_file();
}
inline void SaveOutputParameter::clear_name_size_file() {
name_size_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000010u;
}
inline const std::string& SaveOutputParameter::name_size_file() const {
// @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.name_size_file)
return _internal_name_size_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_name_size_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000010u;
name_size_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.name_size_file)
}
inline std::string* SaveOutputParameter::mutable_name_size_file() {
std::string* _s = _internal_mutable_name_size_file();
// @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.name_size_file)
return _s;
}
inline const std::string& SaveOutputParameter::_internal_name_size_file() const {
return name_size_file_.Get();
}
inline void SaveOutputParameter::_internal_set_name_size_file(const std::string& value) {
_has_bits_[0] |= 0x00000010u;
name_size_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_name_size_file() {
_has_bits_[0] |= 0x00000010u;
return name_size_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_name_size_file() {
// @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.name_size_file)
if (!_internal_has_name_size_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000010u;
auto* p = name_size_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_size_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void SaveOutputParameter::set_allocated_name_size_file(std::string* name_size_file) {
if (name_size_file != nullptr) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
name_size_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name_size_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_size_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.name_size_file)
}
// optional uint32 num_test_image = 6;
inline bool SaveOutputParameter::_internal_has_num_test_image() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool SaveOutputParameter::has_num_test_image() const {
return _internal_has_num_test_image();
}
inline void SaveOutputParameter::clear_num_test_image() {
num_test_image_ = 0u;
_has_bits_[0] &= ~0x00000040u;
}
inline uint32_t SaveOutputParameter::_internal_num_test_image() const {
return num_test_image_;
}
inline uint32_t SaveOutputParameter::num_test_image() const {
// @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.num_test_image)
return _internal_num_test_image();
}
inline void SaveOutputParameter::_internal_set_num_test_image(uint32_t value) {
_has_bits_[0] |= 0x00000040u;
num_test_image_ = value;
}
inline void SaveOutputParameter::set_num_test_image(uint32_t value) {
_internal_set_num_test_image(value);
// @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.num_test_image)
}
// optional .caffe.ResizeParameter resize_param = 7;
inline bool SaveOutputParameter::_internal_has_resize_param() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
PROTOBUF_ASSUME(!value || resize_param_ != nullptr);
return value;
}
inline bool SaveOutputParameter::has_resize_param() const {
return _internal_has_resize_param();
}
inline void SaveOutputParameter::clear_resize_param() {
if (resize_param_ != nullptr) resize_param_->Clear();
_has_bits_[0] &= ~0x00000020u;
}
inline const ::caffe::ResizeParameter& SaveOutputParameter::_internal_resize_param() const {
const ::caffe::ResizeParameter* p = resize_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ResizeParameter&>(
::caffe::_ResizeParameter_default_instance_);
}
inline const ::caffe::ResizeParameter& SaveOutputParameter::resize_param() const {
// @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.resize_param)
return _internal_resize_param();
}
inline void SaveOutputParameter::unsafe_arena_set_allocated_resize_param(
::caffe::ResizeParameter* resize_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(resize_param_);
}
resize_param_ = resize_param;
if (resize_param) {
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.SaveOutputParameter.resize_param)
}
inline ::caffe::ResizeParameter* SaveOutputParameter::release_resize_param() {
_has_bits_[0] &= ~0x00000020u;
::caffe::ResizeParameter* temp = resize_param_;
resize_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ResizeParameter* SaveOutputParameter::unsafe_arena_release_resize_param() {
// @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.resize_param)
_has_bits_[0] &= ~0x00000020u;
::caffe::ResizeParameter* temp = resize_param_;
resize_param_ = nullptr;
return temp;
}
inline ::caffe::ResizeParameter* SaveOutputParameter::_internal_mutable_resize_param() {
_has_bits_[0] |= 0x00000020u;
if (resize_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ResizeParameter>(GetArenaForAllocation());
resize_param_ = p;
}
return resize_param_;
}
inline ::caffe::ResizeParameter* SaveOutputParameter::mutable_resize_param() {
::caffe::ResizeParameter* _msg = _internal_mutable_resize_param();
// @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.resize_param)
return _msg;
}
inline void SaveOutputParameter::set_allocated_resize_param(::caffe::ResizeParameter* resize_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete resize_param_;
}
if (resize_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ResizeParameter>::GetOwningArena(resize_param);
if (message_arena != submessage_arena) {
resize_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, resize_param, submessage_arena);
}
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
resize_param_ = resize_param;
// @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.resize_param)
}
// -------------------------------------------------------------------
// DetectionOutputParameter
// optional uint32 num_classes = 1;
inline bool DetectionOutputParameter::_internal_has_num_classes() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_num_classes() const {
return _internal_has_num_classes();
}
inline void DetectionOutputParameter::clear_num_classes() {
num_classes_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t DetectionOutputParameter::_internal_num_classes() const {
return num_classes_;
}
inline uint32_t DetectionOutputParameter::num_classes() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.num_classes)
return _internal_num_classes();
}
inline void DetectionOutputParameter::_internal_set_num_classes(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
num_classes_ = value;
}
inline void DetectionOutputParameter::set_num_classes(uint32_t value) {
_internal_set_num_classes(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.num_classes)
}
// optional bool share_location = 2 [default = true];
inline bool DetectionOutputParameter::_internal_has_share_location() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_share_location() const {
return _internal_has_share_location();
}
inline void DetectionOutputParameter::clear_share_location() {
share_location_ = true;
_has_bits_[0] &= ~0x00000200u;
}
inline bool DetectionOutputParameter::_internal_share_location() const {
return share_location_;
}
inline bool DetectionOutputParameter::share_location() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.share_location)
return _internal_share_location();
}
inline void DetectionOutputParameter::_internal_set_share_location(bool value) {
_has_bits_[0] |= 0x00000200u;
share_location_ = value;
}
inline void DetectionOutputParameter::set_share_location(bool value) {
_internal_set_share_location(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.share_location)
}
// optional int32 background_label_id = 3 [default = 0];
inline bool DetectionOutputParameter::_internal_has_background_label_id() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_background_label_id() const {
return _internal_has_background_label_id();
}
inline void DetectionOutputParameter::clear_background_label_id() {
background_label_id_ = 0;
_has_bits_[0] &= ~0x00000010u;
}
inline int32_t DetectionOutputParameter::_internal_background_label_id() const {
return background_label_id_;
}
inline int32_t DetectionOutputParameter::background_label_id() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.background_label_id)
return _internal_background_label_id();
}
inline void DetectionOutputParameter::_internal_set_background_label_id(int32_t value) {
_has_bits_[0] |= 0x00000010u;
background_label_id_ = value;
}
inline void DetectionOutputParameter::set_background_label_id(int32_t value) {
_internal_set_background_label_id(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.background_label_id)
}
// optional .caffe.NonMaximumSuppressionParameter nms_param = 4;
inline bool DetectionOutputParameter::_internal_has_nms_param() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || nms_param_ != nullptr);
return value;
}
inline bool DetectionOutputParameter::has_nms_param() const {
return _internal_has_nms_param();
}
inline void DetectionOutputParameter::clear_nms_param() {
if (nms_param_ != nullptr) nms_param_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::_internal_nms_param() const {
const ::caffe::NonMaximumSuppressionParameter* p = nms_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::NonMaximumSuppressionParameter&>(
::caffe::_NonMaximumSuppressionParameter_default_instance_);
}
inline const ::caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::nms_param() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.nms_param)
return _internal_nms_param();
}
inline void DetectionOutputParameter::unsafe_arena_set_allocated_nms_param(
::caffe::NonMaximumSuppressionParameter* nms_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(nms_param_);
}
nms_param_ = nms_param;
if (nms_param) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.DetectionOutputParameter.nms_param)
}
inline ::caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::release_nms_param() {
_has_bits_[0] &= ~0x00000002u;
::caffe::NonMaximumSuppressionParameter* temp = nms_param_;
nms_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::unsafe_arena_release_nms_param() {
// @@protoc_insertion_point(field_release:caffe.DetectionOutputParameter.nms_param)
_has_bits_[0] &= ~0x00000002u;
::caffe::NonMaximumSuppressionParameter* temp = nms_param_;
nms_param_ = nullptr;
return temp;
}
inline ::caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::_internal_mutable_nms_param() {
_has_bits_[0] |= 0x00000002u;
if (nms_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::NonMaximumSuppressionParameter>(GetArenaForAllocation());
nms_param_ = p;
}
return nms_param_;
}
inline ::caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::mutable_nms_param() {
::caffe::NonMaximumSuppressionParameter* _msg = _internal_mutable_nms_param();
// @@protoc_insertion_point(field_mutable:caffe.DetectionOutputParameter.nms_param)
return _msg;
}
inline void DetectionOutputParameter::set_allocated_nms_param(::caffe::NonMaximumSuppressionParameter* nms_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete nms_param_;
}
if (nms_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::NonMaximumSuppressionParameter>::GetOwningArena(nms_param);
if (message_arena != submessage_arena) {
nms_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, nms_param, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
nms_param_ = nms_param;
// @@protoc_insertion_point(field_set_allocated:caffe.DetectionOutputParameter.nms_param)
}
// optional .caffe.SaveOutputParameter save_output_param = 5;
inline bool DetectionOutputParameter::_internal_has_save_output_param() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
PROTOBUF_ASSUME(!value || save_output_param_ != nullptr);
return value;
}
inline bool DetectionOutputParameter::has_save_output_param() const {
return _internal_has_save_output_param();
}
inline void DetectionOutputParameter::clear_save_output_param() {
if (save_output_param_ != nullptr) save_output_param_->Clear();
_has_bits_[0] &= ~0x00000004u;
}
inline const ::caffe::SaveOutputParameter& DetectionOutputParameter::_internal_save_output_param() const {
const ::caffe::SaveOutputParameter* p = save_output_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SaveOutputParameter&>(
::caffe::_SaveOutputParameter_default_instance_);
}
inline const ::caffe::SaveOutputParameter& DetectionOutputParameter::save_output_param() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.save_output_param)
return _internal_save_output_param();
}
inline void DetectionOutputParameter::unsafe_arena_set_allocated_save_output_param(
::caffe::SaveOutputParameter* save_output_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(save_output_param_);
}
save_output_param_ = save_output_param;
if (save_output_param) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.DetectionOutputParameter.save_output_param)
}
inline ::caffe::SaveOutputParameter* DetectionOutputParameter::release_save_output_param() {
_has_bits_[0] &= ~0x00000004u;
::caffe::SaveOutputParameter* temp = save_output_param_;
save_output_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SaveOutputParameter* DetectionOutputParameter::unsafe_arena_release_save_output_param() {
// @@protoc_insertion_point(field_release:caffe.DetectionOutputParameter.save_output_param)
_has_bits_[0] &= ~0x00000004u;
::caffe::SaveOutputParameter* temp = save_output_param_;
save_output_param_ = nullptr;
return temp;
}
inline ::caffe::SaveOutputParameter* DetectionOutputParameter::_internal_mutable_save_output_param() {
_has_bits_[0] |= 0x00000004u;
if (save_output_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SaveOutputParameter>(GetArenaForAllocation());
save_output_param_ = p;
}
return save_output_param_;
}
inline ::caffe::SaveOutputParameter* DetectionOutputParameter::mutable_save_output_param() {
::caffe::SaveOutputParameter* _msg = _internal_mutable_save_output_param();
// @@protoc_insertion_point(field_mutable:caffe.DetectionOutputParameter.save_output_param)
return _msg;
}
inline void DetectionOutputParameter::set_allocated_save_output_param(::caffe::SaveOutputParameter* save_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete save_output_param_;
}
if (save_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SaveOutputParameter>::GetOwningArena(save_output_param);
if (message_arena != submessage_arena) {
save_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, save_output_param, submessage_arena);
}
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
save_output_param_ = save_output_param;
// @@protoc_insertion_point(field_set_allocated:caffe.DetectionOutputParameter.save_output_param)
}
// optional .caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
inline bool DetectionOutputParameter::_internal_has_code_type() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_code_type() const {
return _internal_has_code_type();
}
inline void DetectionOutputParameter::clear_code_type() {
code_type_ = 1;
_has_bits_[0] &= ~0x00000400u;
}
inline ::caffe::PriorBoxParameter_CodeType DetectionOutputParameter::_internal_code_type() const {
return static_cast< ::caffe::PriorBoxParameter_CodeType >(code_type_);
}
inline ::caffe::PriorBoxParameter_CodeType DetectionOutputParameter::code_type() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.code_type)
return _internal_code_type();
}
inline void DetectionOutputParameter::_internal_set_code_type(::caffe::PriorBoxParameter_CodeType value) {
assert(::caffe::PriorBoxParameter_CodeType_IsValid(value));
_has_bits_[0] |= 0x00000400u;
code_type_ = value;
}
inline void DetectionOutputParameter::set_code_type(::caffe::PriorBoxParameter_CodeType value) {
_internal_set_code_type(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.code_type)
}
// optional bool variance_encoded_in_target = 8 [default = false];
inline bool DetectionOutputParameter::_internal_has_variance_encoded_in_target() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_variance_encoded_in_target() const {
return _internal_has_variance_encoded_in_target();
}
inline void DetectionOutputParameter::clear_variance_encoded_in_target() {
variance_encoded_in_target_ = false;
_has_bits_[0] &= ~0x00000040u;
}
inline bool DetectionOutputParameter::_internal_variance_encoded_in_target() const {
return variance_encoded_in_target_;
}
inline bool DetectionOutputParameter::variance_encoded_in_target() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.variance_encoded_in_target)
return _internal_variance_encoded_in_target();
}
inline void DetectionOutputParameter::_internal_set_variance_encoded_in_target(bool value) {
_has_bits_[0] |= 0x00000040u;
variance_encoded_in_target_ = value;
}
inline void DetectionOutputParameter::set_variance_encoded_in_target(bool value) {
_internal_set_variance_encoded_in_target(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.variance_encoded_in_target)
}
// optional int32 keep_top_k = 7 [default = -1];
inline bool DetectionOutputParameter::_internal_has_keep_top_k() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_keep_top_k() const {
return _internal_has_keep_top_k();
}
inline void DetectionOutputParameter::clear_keep_top_k() {
keep_top_k_ = -1;
_has_bits_[0] &= ~0x00000800u;
}
inline int32_t DetectionOutputParameter::_internal_keep_top_k() const {
return keep_top_k_;
}
inline int32_t DetectionOutputParameter::keep_top_k() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.keep_top_k)
return _internal_keep_top_k();
}
inline void DetectionOutputParameter::_internal_set_keep_top_k(int32_t value) {
_has_bits_[0] |= 0x00000800u;
keep_top_k_ = value;
}
inline void DetectionOutputParameter::set_keep_top_k(int32_t value) {
_internal_set_keep_top_k(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.keep_top_k)
}
// optional float confidence_threshold = 9;
inline bool DetectionOutputParameter::_internal_has_confidence_threshold() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_confidence_threshold() const {
return _internal_has_confidence_threshold();
}
inline void DetectionOutputParameter::clear_confidence_threshold() {
confidence_threshold_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline float DetectionOutputParameter::_internal_confidence_threshold() const {
return confidence_threshold_;
}
inline float DetectionOutputParameter::confidence_threshold() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.confidence_threshold)
return _internal_confidence_threshold();
}
inline void DetectionOutputParameter::_internal_set_confidence_threshold(float value) {
_has_bits_[0] |= 0x00000020u;
confidence_threshold_ = value;
}
inline void DetectionOutputParameter::set_confidence_threshold(float value) {
_internal_set_confidence_threshold(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.confidence_threshold)
}
// optional bool visualize = 10 [default = false];
inline bool DetectionOutputParameter::_internal_has_visualize() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_visualize() const {
return _internal_has_visualize();
}
inline void DetectionOutputParameter::clear_visualize() {
visualize_ = false;
_has_bits_[0] &= ~0x00000080u;
}
inline bool DetectionOutputParameter::_internal_visualize() const {
return visualize_;
}
inline bool DetectionOutputParameter::visualize() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.visualize)
return _internal_visualize();
}
inline void DetectionOutputParameter::_internal_set_visualize(bool value) {
_has_bits_[0] |= 0x00000080u;
visualize_ = value;
}
inline void DetectionOutputParameter::set_visualize(bool value) {
_internal_set_visualize(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.visualize)
}
// optional float visualize_threshold = 11;
inline bool DetectionOutputParameter::_internal_has_visualize_threshold() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_visualize_threshold() const {
return _internal_has_visualize_threshold();
}
inline void DetectionOutputParameter::clear_visualize_threshold() {
visualize_threshold_ = 0;
_has_bits_[0] &= ~0x00000100u;
}
inline float DetectionOutputParameter::_internal_visualize_threshold() const {
return visualize_threshold_;
}
inline float DetectionOutputParameter::visualize_threshold() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.visualize_threshold)
return _internal_visualize_threshold();
}
inline void DetectionOutputParameter::_internal_set_visualize_threshold(float value) {
_has_bits_[0] |= 0x00000100u;
visualize_threshold_ = value;
}
inline void DetectionOutputParameter::set_visualize_threshold(float value) {
_internal_set_visualize_threshold(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.visualize_threshold)
}
// optional string save_file = 12;
inline bool DetectionOutputParameter::_internal_has_save_file() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_save_file() const {
return _internal_has_save_file();
}
inline void DetectionOutputParameter::clear_save_file() {
save_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DetectionOutputParameter::save_file() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.save_file)
return _internal_save_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DetectionOutputParameter::set_save_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
save_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.save_file)
}
inline std::string* DetectionOutputParameter::mutable_save_file() {
std::string* _s = _internal_mutable_save_file();
// @@protoc_insertion_point(field_mutable:caffe.DetectionOutputParameter.save_file)
return _s;
}
inline const std::string& DetectionOutputParameter::_internal_save_file() const {
return save_file_.Get();
}
inline void DetectionOutputParameter::_internal_set_save_file(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
save_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DetectionOutputParameter::_internal_mutable_save_file() {
_has_bits_[0] |= 0x00000001u;
return save_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DetectionOutputParameter::release_save_file() {
// @@protoc_insertion_point(field_release:caffe.DetectionOutputParameter.save_file)
if (!_internal_has_save_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = save_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (save_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
save_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void DetectionOutputParameter::set_allocated_save_file(std::string* save_file) {
if (save_file != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
save_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), save_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (save_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
save_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.DetectionOutputParameter.save_file)
}
// optional float objectness_score = 24 [default = 0.01];
inline bool DetectionOutputParameter::_internal_has_objectness_score() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool DetectionOutputParameter::has_objectness_score() const {
return _internal_has_objectness_score();
}
inline void DetectionOutputParameter::clear_objectness_score() {
objectness_score_ = 0.01f;
_has_bits_[0] &= ~0x00001000u;
}
inline float DetectionOutputParameter::_internal_objectness_score() const {
return objectness_score_;
}
inline float DetectionOutputParameter::objectness_score() const {
// @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.objectness_score)
return _internal_objectness_score();
}
inline void DetectionOutputParameter::_internal_set_objectness_score(float value) {
_has_bits_[0] |= 0x00001000u;
objectness_score_ = value;
}
inline void DetectionOutputParameter::set_objectness_score(float value) {
_internal_set_objectness_score(value);
// @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.objectness_score)
}
// -------------------------------------------------------------------
// DropoutParameter
// optional float dropout_ratio = 1 [default = 0.5];
inline bool DropoutParameter::_internal_has_dropout_ratio() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool DropoutParameter::has_dropout_ratio() const {
return _internal_has_dropout_ratio();
}
inline void DropoutParameter::clear_dropout_ratio() {
dropout_ratio_ = 0.5f;
_has_bits_[0] &= ~0x00000001u;
}
inline float DropoutParameter::_internal_dropout_ratio() const {
return dropout_ratio_;
}
inline float DropoutParameter::dropout_ratio() const {
// @@protoc_insertion_point(field_get:caffe.DropoutParameter.dropout_ratio)
return _internal_dropout_ratio();
}
inline void DropoutParameter::_internal_set_dropout_ratio(float value) {
_has_bits_[0] |= 0x00000001u;
dropout_ratio_ = value;
}
inline void DropoutParameter::set_dropout_ratio(float value) {
_internal_set_dropout_ratio(value);
// @@protoc_insertion_point(field_set:caffe.DropoutParameter.dropout_ratio)
}
// -------------------------------------------------------------------
// DummyDataParameter
// repeated .caffe.FillerParameter data_filler = 1;
inline int DummyDataParameter::_internal_data_filler_size() const {
return data_filler_.size();
}
inline int DummyDataParameter::data_filler_size() const {
return _internal_data_filler_size();
}
inline void DummyDataParameter::clear_data_filler() {
data_filler_.Clear();
}
inline ::caffe::FillerParameter* DummyDataParameter::mutable_data_filler(int index) {
// @@protoc_insertion_point(field_mutable:caffe.DummyDataParameter.data_filler)
return data_filler_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::FillerParameter >*
DummyDataParameter::mutable_data_filler() {
// @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.data_filler)
return &data_filler_;
}
inline const ::caffe::FillerParameter& DummyDataParameter::_internal_data_filler(int index) const {
return data_filler_.Get(index);
}
inline const ::caffe::FillerParameter& DummyDataParameter::data_filler(int index) const {
// @@protoc_insertion_point(field_get:caffe.DummyDataParameter.data_filler)
return _internal_data_filler(index);
}
inline ::caffe::FillerParameter* DummyDataParameter::_internal_add_data_filler() {
return data_filler_.Add();
}
inline ::caffe::FillerParameter* DummyDataParameter::add_data_filler() {
::caffe::FillerParameter* _add = _internal_add_data_filler();
// @@protoc_insertion_point(field_add:caffe.DummyDataParameter.data_filler)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::FillerParameter >&
DummyDataParameter::data_filler() const {
// @@protoc_insertion_point(field_list:caffe.DummyDataParameter.data_filler)
return data_filler_;
}
// repeated .caffe.BlobShape shape = 6;
inline int DummyDataParameter::_internal_shape_size() const {
return shape_.size();
}
inline int DummyDataParameter::shape_size() const {
return _internal_shape_size();
}
inline void DummyDataParameter::clear_shape() {
shape_.Clear();
}
inline ::caffe::BlobShape* DummyDataParameter::mutable_shape(int index) {
// @@protoc_insertion_point(field_mutable:caffe.DummyDataParameter.shape)
return shape_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >*
DummyDataParameter::mutable_shape() {
// @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.shape)
return &shape_;
}
inline const ::caffe::BlobShape& DummyDataParameter::_internal_shape(int index) const {
return shape_.Get(index);
}
inline const ::caffe::BlobShape& DummyDataParameter::shape(int index) const {
// @@protoc_insertion_point(field_get:caffe.DummyDataParameter.shape)
return _internal_shape(index);
}
inline ::caffe::BlobShape* DummyDataParameter::_internal_add_shape() {
return shape_.Add();
}
inline ::caffe::BlobShape* DummyDataParameter::add_shape() {
::caffe::BlobShape* _add = _internal_add_shape();
// @@protoc_insertion_point(field_add:caffe.DummyDataParameter.shape)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >&
DummyDataParameter::shape() const {
// @@protoc_insertion_point(field_list:caffe.DummyDataParameter.shape)
return shape_;
}
// repeated uint32 num = 2;
inline int DummyDataParameter::_internal_num_size() const {
return num_.size();
}
inline int DummyDataParameter::num_size() const {
return _internal_num_size();
}
inline void DummyDataParameter::clear_num() {
num_.Clear();
}
inline uint32_t DummyDataParameter::_internal_num(int index) const {
return num_.Get(index);
}
inline uint32_t DummyDataParameter::num(int index) const {
// @@protoc_insertion_point(field_get:caffe.DummyDataParameter.num)
return _internal_num(index);
}
inline void DummyDataParameter::set_num(int index, uint32_t value) {
num_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.DummyDataParameter.num)
}
inline void DummyDataParameter::_internal_add_num(uint32_t value) {
num_.Add(value);
}
inline void DummyDataParameter::add_num(uint32_t value) {
_internal_add_num(value);
// @@protoc_insertion_point(field_add:caffe.DummyDataParameter.num)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::_internal_num() const {
return num_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::num() const {
// @@protoc_insertion_point(field_list:caffe.DummyDataParameter.num)
return _internal_num();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::_internal_mutable_num() {
return &num_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::mutable_num() {
// @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.num)
return _internal_mutable_num();
}
// repeated uint32 channels = 3;
inline int DummyDataParameter::_internal_channels_size() const {
return channels_.size();
}
inline int DummyDataParameter::channels_size() const {
return _internal_channels_size();
}
inline void DummyDataParameter::clear_channels() {
channels_.Clear();
}
inline uint32_t DummyDataParameter::_internal_channels(int index) const {
return channels_.Get(index);
}
inline uint32_t DummyDataParameter::channels(int index) const {
// @@protoc_insertion_point(field_get:caffe.DummyDataParameter.channels)
return _internal_channels(index);
}
inline void DummyDataParameter::set_channels(int index, uint32_t value) {
channels_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.DummyDataParameter.channels)
}
inline void DummyDataParameter::_internal_add_channels(uint32_t value) {
channels_.Add(value);
}
inline void DummyDataParameter::add_channels(uint32_t value) {
_internal_add_channels(value);
// @@protoc_insertion_point(field_add:caffe.DummyDataParameter.channels)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::_internal_channels() const {
return channels_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::channels() const {
// @@protoc_insertion_point(field_list:caffe.DummyDataParameter.channels)
return _internal_channels();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::_internal_mutable_channels() {
return &channels_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::mutable_channels() {
// @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.channels)
return _internal_mutable_channels();
}
// repeated uint32 height = 4;
inline int DummyDataParameter::_internal_height_size() const {
return height_.size();
}
inline int DummyDataParameter::height_size() const {
return _internal_height_size();
}
inline void DummyDataParameter::clear_height() {
height_.Clear();
}
inline uint32_t DummyDataParameter::_internal_height(int index) const {
return height_.Get(index);
}
inline uint32_t DummyDataParameter::height(int index) const {
// @@protoc_insertion_point(field_get:caffe.DummyDataParameter.height)
return _internal_height(index);
}
inline void DummyDataParameter::set_height(int index, uint32_t value) {
height_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.DummyDataParameter.height)
}
inline void DummyDataParameter::_internal_add_height(uint32_t value) {
height_.Add(value);
}
inline void DummyDataParameter::add_height(uint32_t value) {
_internal_add_height(value);
// @@protoc_insertion_point(field_add:caffe.DummyDataParameter.height)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::_internal_height() const {
return height_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::height() const {
// @@protoc_insertion_point(field_list:caffe.DummyDataParameter.height)
return _internal_height();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::_internal_mutable_height() {
return &height_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::mutable_height() {
// @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.height)
return _internal_mutable_height();
}
// repeated uint32 width = 5;
inline int DummyDataParameter::_internal_width_size() const {
return width_.size();
}
inline int DummyDataParameter::width_size() const {
return _internal_width_size();
}
inline void DummyDataParameter::clear_width() {
width_.Clear();
}
inline uint32_t DummyDataParameter::_internal_width(int index) const {
return width_.Get(index);
}
inline uint32_t DummyDataParameter::width(int index) const {
// @@protoc_insertion_point(field_get:caffe.DummyDataParameter.width)
return _internal_width(index);
}
inline void DummyDataParameter::set_width(int index, uint32_t value) {
width_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.DummyDataParameter.width)
}
inline void DummyDataParameter::_internal_add_width(uint32_t value) {
width_.Add(value);
}
inline void DummyDataParameter::add_width(uint32_t value) {
_internal_add_width(value);
// @@protoc_insertion_point(field_add:caffe.DummyDataParameter.width)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::_internal_width() const {
return width_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::width() const {
// @@protoc_insertion_point(field_list:caffe.DummyDataParameter.width)
return _internal_width();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::_internal_mutable_width() {
return &width_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::mutable_width() {
// @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.width)
return _internal_mutable_width();
}
// -------------------------------------------------------------------
// EltwiseParameter
// optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
inline bool EltwiseParameter::_internal_has_operation() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool EltwiseParameter::has_operation() const {
return _internal_has_operation();
}
inline void EltwiseParameter::clear_operation() {
operation_ = 1;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::EltwiseParameter_EltwiseOp EltwiseParameter::_internal_operation() const {
return static_cast< ::caffe::EltwiseParameter_EltwiseOp >(operation_);
}
inline ::caffe::EltwiseParameter_EltwiseOp EltwiseParameter::operation() const {
// @@protoc_insertion_point(field_get:caffe.EltwiseParameter.operation)
return _internal_operation();
}
inline void EltwiseParameter::_internal_set_operation(::caffe::EltwiseParameter_EltwiseOp value) {
assert(::caffe::EltwiseParameter_EltwiseOp_IsValid(value));
_has_bits_[0] |= 0x00000001u;
operation_ = value;
}
inline void EltwiseParameter::set_operation(::caffe::EltwiseParameter_EltwiseOp value) {
_internal_set_operation(value);
// @@protoc_insertion_point(field_set:caffe.EltwiseParameter.operation)
}
// repeated float coeff = 2;
inline int EltwiseParameter::_internal_coeff_size() const {
return coeff_.size();
}
inline int EltwiseParameter::coeff_size() const {
return _internal_coeff_size();
}
inline void EltwiseParameter::clear_coeff() {
coeff_.Clear();
}
inline float EltwiseParameter::_internal_coeff(int index) const {
return coeff_.Get(index);
}
inline float EltwiseParameter::coeff(int index) const {
// @@protoc_insertion_point(field_get:caffe.EltwiseParameter.coeff)
return _internal_coeff(index);
}
inline void EltwiseParameter::set_coeff(int index, float value) {
coeff_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.EltwiseParameter.coeff)
}
inline void EltwiseParameter::_internal_add_coeff(float value) {
coeff_.Add(value);
}
inline void EltwiseParameter::add_coeff(float value) {
_internal_add_coeff(value);
// @@protoc_insertion_point(field_add:caffe.EltwiseParameter.coeff)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
EltwiseParameter::_internal_coeff() const {
return coeff_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
EltwiseParameter::coeff() const {
// @@protoc_insertion_point(field_list:caffe.EltwiseParameter.coeff)
return _internal_coeff();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
EltwiseParameter::_internal_mutable_coeff() {
return &coeff_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
EltwiseParameter::mutable_coeff() {
// @@protoc_insertion_point(field_mutable_list:caffe.EltwiseParameter.coeff)
return _internal_mutable_coeff();
}
// optional bool stable_prod_grad = 3 [default = true];
inline bool EltwiseParameter::_internal_has_stable_prod_grad() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool EltwiseParameter::has_stable_prod_grad() const {
return _internal_has_stable_prod_grad();
}
inline void EltwiseParameter::clear_stable_prod_grad() {
stable_prod_grad_ = true;
_has_bits_[0] &= ~0x00000002u;
}
inline bool EltwiseParameter::_internal_stable_prod_grad() const {
return stable_prod_grad_;
}
inline bool EltwiseParameter::stable_prod_grad() const {
// @@protoc_insertion_point(field_get:caffe.EltwiseParameter.stable_prod_grad)
return _internal_stable_prod_grad();
}
inline void EltwiseParameter::_internal_set_stable_prod_grad(bool value) {
_has_bits_[0] |= 0x00000002u;
stable_prod_grad_ = value;
}
inline void EltwiseParameter::set_stable_prod_grad(bool value) {
_internal_set_stable_prod_grad(value);
// @@protoc_insertion_point(field_set:caffe.EltwiseParameter.stable_prod_grad)
}
// -------------------------------------------------------------------
// ELUParameter
// optional float alpha = 1 [default = 1];
inline bool ELUParameter::_internal_has_alpha() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ELUParameter::has_alpha() const {
return _internal_has_alpha();
}
inline void ELUParameter::clear_alpha() {
alpha_ = 1;
_has_bits_[0] &= ~0x00000001u;
}
inline float ELUParameter::_internal_alpha() const {
return alpha_;
}
inline float ELUParameter::alpha() const {
// @@protoc_insertion_point(field_get:caffe.ELUParameter.alpha)
return _internal_alpha();
}
inline void ELUParameter::_internal_set_alpha(float value) {
_has_bits_[0] |= 0x00000001u;
alpha_ = value;
}
inline void ELUParameter::set_alpha(float value) {
_internal_set_alpha(value);
// @@protoc_insertion_point(field_set:caffe.ELUParameter.alpha)
}
// -------------------------------------------------------------------
// EmbedParameter
// optional uint32 num_output = 1;
inline bool EmbedParameter::_internal_has_num_output() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool EmbedParameter::has_num_output() const {
return _internal_has_num_output();
}
inline void EmbedParameter::clear_num_output() {
num_output_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t EmbedParameter::_internal_num_output() const {
return num_output_;
}
inline uint32_t EmbedParameter::num_output() const {
// @@protoc_insertion_point(field_get:caffe.EmbedParameter.num_output)
return _internal_num_output();
}
inline void EmbedParameter::_internal_set_num_output(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
num_output_ = value;
}
inline void EmbedParameter::set_num_output(uint32_t value) {
_internal_set_num_output(value);
// @@protoc_insertion_point(field_set:caffe.EmbedParameter.num_output)
}
// optional uint32 input_dim = 2;
inline bool EmbedParameter::_internal_has_input_dim() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool EmbedParameter::has_input_dim() const {
return _internal_has_input_dim();
}
inline void EmbedParameter::clear_input_dim() {
input_dim_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t EmbedParameter::_internal_input_dim() const {
return input_dim_;
}
inline uint32_t EmbedParameter::input_dim() const {
// @@protoc_insertion_point(field_get:caffe.EmbedParameter.input_dim)
return _internal_input_dim();
}
inline void EmbedParameter::_internal_set_input_dim(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
input_dim_ = value;
}
inline void EmbedParameter::set_input_dim(uint32_t value) {
_internal_set_input_dim(value);
// @@protoc_insertion_point(field_set:caffe.EmbedParameter.input_dim)
}
// optional bool bias_term = 3 [default = true];
inline bool EmbedParameter::_internal_has_bias_term() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool EmbedParameter::has_bias_term() const {
return _internal_has_bias_term();
}
inline void EmbedParameter::clear_bias_term() {
bias_term_ = true;
_has_bits_[0] &= ~0x00000010u;
}
inline bool EmbedParameter::_internal_bias_term() const {
return bias_term_;
}
inline bool EmbedParameter::bias_term() const {
// @@protoc_insertion_point(field_get:caffe.EmbedParameter.bias_term)
return _internal_bias_term();
}
inline void EmbedParameter::_internal_set_bias_term(bool value) {
_has_bits_[0] |= 0x00000010u;
bias_term_ = value;
}
inline void EmbedParameter::set_bias_term(bool value) {
_internal_set_bias_term(value);
// @@protoc_insertion_point(field_set:caffe.EmbedParameter.bias_term)
}
// optional .caffe.FillerParameter weight_filler = 4;
inline bool EmbedParameter::_internal_has_weight_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || weight_filler_ != nullptr);
return value;
}
inline bool EmbedParameter::has_weight_filler() const {
return _internal_has_weight_filler();
}
inline void EmbedParameter::clear_weight_filler() {
if (weight_filler_ != nullptr) weight_filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& EmbedParameter::_internal_weight_filler() const {
const ::caffe::FillerParameter* p = weight_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& EmbedParameter::weight_filler() const {
// @@protoc_insertion_point(field_get:caffe.EmbedParameter.weight_filler)
return _internal_weight_filler();
}
inline void EmbedParameter::unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_);
}
weight_filler_ = weight_filler;
if (weight_filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.EmbedParameter.weight_filler)
}
inline ::caffe::FillerParameter* EmbedParameter::release_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* EmbedParameter::unsafe_arena_release_weight_filler() {
// @@protoc_insertion_point(field_release:caffe.EmbedParameter.weight_filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* EmbedParameter::_internal_mutable_weight_filler() {
_has_bits_[0] |= 0x00000001u;
if (weight_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
weight_filler_ = p;
}
return weight_filler_;
}
inline ::caffe::FillerParameter* EmbedParameter::mutable_weight_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
// @@protoc_insertion_point(field_mutable:caffe.EmbedParameter.weight_filler)
return _msg;
}
inline void EmbedParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete weight_filler_;
}
if (weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(weight_filler);
if (message_arena != submessage_arena) {
weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.EmbedParameter.weight_filler)
}
// optional .caffe.FillerParameter bias_filler = 5;
inline bool EmbedParameter::_internal_has_bias_filler() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || bias_filler_ != nullptr);
return value;
}
inline bool EmbedParameter::has_bias_filler() const {
return _internal_has_bias_filler();
}
inline void EmbedParameter::clear_bias_filler() {
if (bias_filler_ != nullptr) bias_filler_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::FillerParameter& EmbedParameter::_internal_bias_filler() const {
const ::caffe::FillerParameter* p = bias_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& EmbedParameter::bias_filler() const {
// @@protoc_insertion_point(field_get:caffe.EmbedParameter.bias_filler)
return _internal_bias_filler();
}
inline void EmbedParameter::unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_);
}
bias_filler_ = bias_filler;
if (bias_filler) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.EmbedParameter.bias_filler)
}
inline ::caffe::FillerParameter* EmbedParameter::release_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* EmbedParameter::unsafe_arena_release_bias_filler() {
// @@protoc_insertion_point(field_release:caffe.EmbedParameter.bias_filler)
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* EmbedParameter::_internal_mutable_bias_filler() {
_has_bits_[0] |= 0x00000002u;
if (bias_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
bias_filler_ = p;
}
return bias_filler_;
}
inline ::caffe::FillerParameter* EmbedParameter::mutable_bias_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
// @@protoc_insertion_point(field_mutable:caffe.EmbedParameter.bias_filler)
return _msg;
}
inline void EmbedParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_filler_;
}
if (bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(bias_filler);
if (message_arena != submessage_arena) {
bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.EmbedParameter.bias_filler)
}
// -------------------------------------------------------------------
// ExpParameter
// optional float base = 1 [default = -1];
inline bool ExpParameter::_internal_has_base() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ExpParameter::has_base() const {
return _internal_has_base();
}
inline void ExpParameter::clear_base() {
base_ = -1;
_has_bits_[0] &= ~0x00000002u;
}
inline float ExpParameter::_internal_base() const {
return base_;
}
inline float ExpParameter::base() const {
// @@protoc_insertion_point(field_get:caffe.ExpParameter.base)
return _internal_base();
}
inline void ExpParameter::_internal_set_base(float value) {
_has_bits_[0] |= 0x00000002u;
base_ = value;
}
inline void ExpParameter::set_base(float value) {
_internal_set_base(value);
// @@protoc_insertion_point(field_set:caffe.ExpParameter.base)
}
// optional float scale = 2 [default = 1];
inline bool ExpParameter::_internal_has_scale() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ExpParameter::has_scale() const {
return _internal_has_scale();
}
inline void ExpParameter::clear_scale() {
scale_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline float ExpParameter::_internal_scale() const {
return scale_;
}
inline float ExpParameter::scale() const {
// @@protoc_insertion_point(field_get:caffe.ExpParameter.scale)
return _internal_scale();
}
inline void ExpParameter::_internal_set_scale(float value) {
_has_bits_[0] |= 0x00000004u;
scale_ = value;
}
inline void ExpParameter::set_scale(float value) {
_internal_set_scale(value);
// @@protoc_insertion_point(field_set:caffe.ExpParameter.scale)
}
// optional float shift = 3 [default = 0];
inline bool ExpParameter::_internal_has_shift() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ExpParameter::has_shift() const {
return _internal_has_shift();
}
inline void ExpParameter::clear_shift() {
shift_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float ExpParameter::_internal_shift() const {
return shift_;
}
inline float ExpParameter::shift() const {
// @@protoc_insertion_point(field_get:caffe.ExpParameter.shift)
return _internal_shift();
}
inline void ExpParameter::_internal_set_shift(float value) {
_has_bits_[0] |= 0x00000001u;
shift_ = value;
}
inline void ExpParameter::set_shift(float value) {
_internal_set_shift(value);
// @@protoc_insertion_point(field_set:caffe.ExpParameter.shift)
}
// -------------------------------------------------------------------
// FlattenParameter
// optional int32 axis = 1 [default = 1];
inline bool FlattenParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool FlattenParameter::has_axis() const {
return _internal_has_axis();
}
inline void FlattenParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t FlattenParameter::_internal_axis() const {
return axis_;
}
inline int32_t FlattenParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.FlattenParameter.axis)
return _internal_axis();
}
inline void FlattenParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000001u;
axis_ = value;
}
inline void FlattenParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.FlattenParameter.axis)
}
// optional int32 end_axis = 2 [default = -1];
inline bool FlattenParameter::_internal_has_end_axis() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool FlattenParameter::has_end_axis() const {
return _internal_has_end_axis();
}
inline void FlattenParameter::clear_end_axis() {
end_axis_ = -1;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t FlattenParameter::_internal_end_axis() const {
return end_axis_;
}
inline int32_t FlattenParameter::end_axis() const {
// @@protoc_insertion_point(field_get:caffe.FlattenParameter.end_axis)
return _internal_end_axis();
}
inline void FlattenParameter::_internal_set_end_axis(int32_t value) {
_has_bits_[0] |= 0x00000002u;
end_axis_ = value;
}
inline void FlattenParameter::set_end_axis(int32_t value) {
_internal_set_end_axis(value);
// @@protoc_insertion_point(field_set:caffe.FlattenParameter.end_axis)
}
// -------------------------------------------------------------------
// HDF5DataParameter
// optional string source = 1;
inline bool HDF5DataParameter::_internal_has_source() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool HDF5DataParameter::has_source() const {
return _internal_has_source();
}
inline void HDF5DataParameter::clear_source() {
source_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HDF5DataParameter::source() const {
// @@protoc_insertion_point(field_get:caffe.HDF5DataParameter.source)
return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HDF5DataParameter::set_source(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.HDF5DataParameter.source)
}
inline std::string* HDF5DataParameter::mutable_source() {
std::string* _s = _internal_mutable_source();
// @@protoc_insertion_point(field_mutable:caffe.HDF5DataParameter.source)
return _s;
}
inline const std::string& HDF5DataParameter::_internal_source() const {
return source_.Get();
}
inline void HDF5DataParameter::_internal_set_source(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* HDF5DataParameter::_internal_mutable_source() {
_has_bits_[0] |= 0x00000001u;
return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* HDF5DataParameter::release_source() {
// @@protoc_insertion_point(field_release:caffe.HDF5DataParameter.source)
if (!_internal_has_source()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void HDF5DataParameter::set_allocated_source(std::string* source) {
if (source != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.HDF5DataParameter.source)
}
// optional uint32 batch_size = 2;
inline bool HDF5DataParameter::_internal_has_batch_size() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool HDF5DataParameter::has_batch_size() const {
return _internal_has_batch_size();
}
inline void HDF5DataParameter::clear_batch_size() {
batch_size_ = 0u;
_has_bits_[0] &= ~0x00000002u;
}
inline uint32_t HDF5DataParameter::_internal_batch_size() const {
return batch_size_;
}
inline uint32_t HDF5DataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:caffe.HDF5DataParameter.batch_size)
return _internal_batch_size();
}
inline void HDF5DataParameter::_internal_set_batch_size(uint32_t value) {
_has_bits_[0] |= 0x00000002u;
batch_size_ = value;
}
inline void HDF5DataParameter::set_batch_size(uint32_t value) {
_internal_set_batch_size(value);
// @@protoc_insertion_point(field_set:caffe.HDF5DataParameter.batch_size)
}
// optional bool shuffle = 3 [default = false];
inline bool HDF5DataParameter::_internal_has_shuffle() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool HDF5DataParameter::has_shuffle() const {
return _internal_has_shuffle();
}
inline void HDF5DataParameter::clear_shuffle() {
shuffle_ = false;
_has_bits_[0] &= ~0x00000004u;
}
inline bool HDF5DataParameter::_internal_shuffle() const {
return shuffle_;
}
inline bool HDF5DataParameter::shuffle() const {
// @@protoc_insertion_point(field_get:caffe.HDF5DataParameter.shuffle)
return _internal_shuffle();
}
inline void HDF5DataParameter::_internal_set_shuffle(bool value) {
_has_bits_[0] |= 0x00000004u;
shuffle_ = value;
}
inline void HDF5DataParameter::set_shuffle(bool value) {
_internal_set_shuffle(value);
// @@protoc_insertion_point(field_set:caffe.HDF5DataParameter.shuffle)
}
// -------------------------------------------------------------------
// HDF5OutputParameter
// optional string file_name = 1;
inline bool HDF5OutputParameter::_internal_has_file_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool HDF5OutputParameter::has_file_name() const {
return _internal_has_file_name();
}
inline void HDF5OutputParameter::clear_file_name() {
file_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HDF5OutputParameter::file_name() const {
// @@protoc_insertion_point(field_get:caffe.HDF5OutputParameter.file_name)
return _internal_file_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HDF5OutputParameter::set_file_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.HDF5OutputParameter.file_name)
}
inline std::string* HDF5OutputParameter::mutable_file_name() {
std::string* _s = _internal_mutable_file_name();
// @@protoc_insertion_point(field_mutable:caffe.HDF5OutputParameter.file_name)
return _s;
}
inline const std::string& HDF5OutputParameter::_internal_file_name() const {
return file_name_.Get();
}
inline void HDF5OutputParameter::_internal_set_file_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* HDF5OutputParameter::_internal_mutable_file_name() {
_has_bits_[0] |= 0x00000001u;
return file_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* HDF5OutputParameter::release_file_name() {
// @@protoc_insertion_point(field_release:caffe.HDF5OutputParameter.file_name)
if (!_internal_has_file_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = file_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (file_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void HDF5OutputParameter::set_allocated_file_name(std::string* file_name) {
if (file_name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
file_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (file_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.HDF5OutputParameter.file_name)
}
// -------------------------------------------------------------------
// HingeLossParameter
// optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1];
inline bool HingeLossParameter::_internal_has_norm() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool HingeLossParameter::has_norm() const {
return _internal_has_norm();
}
inline void HingeLossParameter::clear_norm() {
norm_ = 1;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::HingeLossParameter_Norm HingeLossParameter::_internal_norm() const {
return static_cast< ::caffe::HingeLossParameter_Norm >(norm_);
}
inline ::caffe::HingeLossParameter_Norm HingeLossParameter::norm() const {
// @@protoc_insertion_point(field_get:caffe.HingeLossParameter.norm)
return _internal_norm();
}
inline void HingeLossParameter::_internal_set_norm(::caffe::HingeLossParameter_Norm value) {
assert(::caffe::HingeLossParameter_Norm_IsValid(value));
_has_bits_[0] |= 0x00000001u;
norm_ = value;
}
inline void HingeLossParameter::set_norm(::caffe::HingeLossParameter_Norm value) {
_internal_set_norm(value);
// @@protoc_insertion_point(field_set:caffe.HingeLossParameter.norm)
}
// -------------------------------------------------------------------
// ImageDataParameter
// optional string source = 1;
inline bool ImageDataParameter::_internal_has_source() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ImageDataParameter::has_source() const {
return _internal_has_source();
}
inline void ImageDataParameter::clear_source() {
source_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ImageDataParameter::source() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.source)
return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ImageDataParameter::set_source(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.source)
}
inline std::string* ImageDataParameter::mutable_source() {
std::string* _s = _internal_mutable_source();
// @@protoc_insertion_point(field_mutable:caffe.ImageDataParameter.source)
return _s;
}
inline const std::string& ImageDataParameter::_internal_source() const {
return source_.Get();
}
inline void ImageDataParameter::_internal_set_source(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ImageDataParameter::_internal_mutable_source() {
_has_bits_[0] |= 0x00000001u;
return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ImageDataParameter::release_source() {
// @@protoc_insertion_point(field_release:caffe.ImageDataParameter.source)
if (!_internal_has_source()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ImageDataParameter::set_allocated_source(std::string* source) {
if (source != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.ImageDataParameter.source)
}
// optional uint32 batch_size = 4 [default = 1];
inline bool ImageDataParameter::_internal_has_batch_size() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool ImageDataParameter::has_batch_size() const {
return _internal_has_batch_size();
}
inline void ImageDataParameter::clear_batch_size() {
batch_size_ = 1u;
_has_bits_[0] &= ~0x00000800u;
}
inline uint32_t ImageDataParameter::_internal_batch_size() const {
return batch_size_;
}
inline uint32_t ImageDataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.batch_size)
return _internal_batch_size();
}
inline void ImageDataParameter::_internal_set_batch_size(uint32_t value) {
_has_bits_[0] |= 0x00000800u;
batch_size_ = value;
}
inline void ImageDataParameter::set_batch_size(uint32_t value) {
_internal_set_batch_size(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.batch_size)
}
// optional uint32 rand_skip = 7 [default = 0];
inline bool ImageDataParameter::_internal_has_rand_skip() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool ImageDataParameter::has_rand_skip() const {
return _internal_has_rand_skip();
}
inline void ImageDataParameter::clear_rand_skip() {
rand_skip_ = 0u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t ImageDataParameter::_internal_rand_skip() const {
return rand_skip_;
}
inline uint32_t ImageDataParameter::rand_skip() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.rand_skip)
return _internal_rand_skip();
}
inline void ImageDataParameter::_internal_set_rand_skip(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
rand_skip_ = value;
}
inline void ImageDataParameter::set_rand_skip(uint32_t value) {
_internal_set_rand_skip(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.rand_skip)
}
// optional bool shuffle = 8 [default = false];
inline bool ImageDataParameter::_internal_has_shuffle() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool ImageDataParameter::has_shuffle() const {
return _internal_has_shuffle();
}
inline void ImageDataParameter::clear_shuffle() {
shuffle_ = false;
_has_bits_[0] &= ~0x00000020u;
}
inline bool ImageDataParameter::_internal_shuffle() const {
return shuffle_;
}
inline bool ImageDataParameter::shuffle() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.shuffle)
return _internal_shuffle();
}
inline void ImageDataParameter::_internal_set_shuffle(bool value) {
_has_bits_[0] |= 0x00000020u;
shuffle_ = value;
}
inline void ImageDataParameter::set_shuffle(bool value) {
_internal_set_shuffle(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.shuffle)
}
// optional uint32 new_height = 9 [default = 0];
inline bool ImageDataParameter::_internal_has_new_height() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool ImageDataParameter::has_new_height() const {
return _internal_has_new_height();
}
inline void ImageDataParameter::clear_new_height() {
new_height_ = 0u;
_has_bits_[0] &= ~0x00000080u;
}
inline uint32_t ImageDataParameter::_internal_new_height() const {
return new_height_;
}
inline uint32_t ImageDataParameter::new_height() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.new_height)
return _internal_new_height();
}
inline void ImageDataParameter::_internal_set_new_height(uint32_t value) {
_has_bits_[0] |= 0x00000080u;
new_height_ = value;
}
inline void ImageDataParameter::set_new_height(uint32_t value) {
_internal_set_new_height(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.new_height)
}
// optional uint32 new_width = 10 [default = 0];
inline bool ImageDataParameter::_internal_has_new_width() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool ImageDataParameter::has_new_width() const {
return _internal_has_new_width();
}
inline void ImageDataParameter::clear_new_width() {
new_width_ = 0u;
_has_bits_[0] &= ~0x00000100u;
}
inline uint32_t ImageDataParameter::_internal_new_width() const {
return new_width_;
}
inline uint32_t ImageDataParameter::new_width() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.new_width)
return _internal_new_width();
}
inline void ImageDataParameter::_internal_set_new_width(uint32_t value) {
_has_bits_[0] |= 0x00000100u;
new_width_ = value;
}
inline void ImageDataParameter::set_new_width(uint32_t value) {
_internal_set_new_width(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.new_width)
}
// optional bool is_color = 11 [default = true];
inline bool ImageDataParameter::_internal_has_is_color() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool ImageDataParameter::has_is_color() const {
return _internal_has_is_color();
}
inline void ImageDataParameter::clear_is_color() {
is_color_ = true;
_has_bits_[0] &= ~0x00001000u;
}
inline bool ImageDataParameter::_internal_is_color() const {
return is_color_;
}
inline bool ImageDataParameter::is_color() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.is_color)
return _internal_is_color();
}
inline void ImageDataParameter::_internal_set_is_color(bool value) {
_has_bits_[0] |= 0x00001000u;
is_color_ = value;
}
inline void ImageDataParameter::set_is_color(bool value) {
_internal_set_is_color(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.is_color)
}
// optional float scale = 2 [default = 1];
inline bool ImageDataParameter::_internal_has_scale() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool ImageDataParameter::has_scale() const {
return _internal_has_scale();
}
inline void ImageDataParameter::clear_scale() {
scale_ = 1;
_has_bits_[0] &= ~0x00000400u;
}
inline float ImageDataParameter::_internal_scale() const {
return scale_;
}
inline float ImageDataParameter::scale() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.scale)
return _internal_scale();
}
inline void ImageDataParameter::_internal_set_scale(float value) {
_has_bits_[0] |= 0x00000400u;
scale_ = value;
}
inline void ImageDataParameter::set_scale(float value) {
_internal_set_scale(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.scale)
}
// optional string mean_file = 3;
inline bool ImageDataParameter::_internal_has_mean_file() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ImageDataParameter::has_mean_file() const {
return _internal_has_mean_file();
}
inline void ImageDataParameter::clear_mean_file() {
mean_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ImageDataParameter::mean_file() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.mean_file)
return _internal_mean_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ImageDataParameter::set_mean_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.mean_file)
}
inline std::string* ImageDataParameter::mutable_mean_file() {
std::string* _s = _internal_mutable_mean_file();
// @@protoc_insertion_point(field_mutable:caffe.ImageDataParameter.mean_file)
return _s;
}
inline const std::string& ImageDataParameter::_internal_mean_file() const {
return mean_file_.Get();
}
inline void ImageDataParameter::_internal_set_mean_file(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ImageDataParameter::_internal_mutable_mean_file() {
_has_bits_[0] |= 0x00000002u;
return mean_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ImageDataParameter::release_mean_file() {
// @@protoc_insertion_point(field_release:caffe.ImageDataParameter.mean_file)
if (!_internal_has_mean_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = mean_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ImageDataParameter::set_allocated_mean_file(std::string* mean_file) {
if (mean_file != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
mean_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mean_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.ImageDataParameter.mean_file)
}
// optional uint32 crop_size = 5 [default = 0];
inline bool ImageDataParameter::_internal_has_crop_size() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool ImageDataParameter::has_crop_size() const {
return _internal_has_crop_size();
}
inline void ImageDataParameter::clear_crop_size() {
crop_size_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t ImageDataParameter::_internal_crop_size() const {
return crop_size_;
}
inline uint32_t ImageDataParameter::crop_size() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.crop_size)
return _internal_crop_size();
}
inline void ImageDataParameter::_internal_set_crop_size(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
crop_size_ = value;
}
inline void ImageDataParameter::set_crop_size(uint32_t value) {
_internal_set_crop_size(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.crop_size)
}
// optional bool mirror = 6 [default = false];
inline bool ImageDataParameter::_internal_has_mirror() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool ImageDataParameter::has_mirror() const {
return _internal_has_mirror();
}
inline void ImageDataParameter::clear_mirror() {
mirror_ = false;
_has_bits_[0] &= ~0x00000040u;
}
inline bool ImageDataParameter::_internal_mirror() const {
return mirror_;
}
inline bool ImageDataParameter::mirror() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.mirror)
return _internal_mirror();
}
inline void ImageDataParameter::_internal_set_mirror(bool value) {
_has_bits_[0] |= 0x00000040u;
mirror_ = value;
}
inline void ImageDataParameter::set_mirror(bool value) {
_internal_set_mirror(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.mirror)
}
// optional string root_folder = 12 [default = ""];
inline bool ImageDataParameter::_internal_has_root_folder() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ImageDataParameter::has_root_folder() const {
return _internal_has_root_folder();
}
inline void ImageDataParameter::clear_root_folder() {
root_folder_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ImageDataParameter::root_folder() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.root_folder)
return _internal_root_folder();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ImageDataParameter::set_root_folder(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.root_folder)
}
inline std::string* ImageDataParameter::mutable_root_folder() {
std::string* _s = _internal_mutable_root_folder();
// @@protoc_insertion_point(field_mutable:caffe.ImageDataParameter.root_folder)
return _s;
}
inline const std::string& ImageDataParameter::_internal_root_folder() const {
return root_folder_.Get();
}
inline void ImageDataParameter::_internal_set_root_folder(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ImageDataParameter::_internal_mutable_root_folder() {
_has_bits_[0] |= 0x00000004u;
return root_folder_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ImageDataParameter::release_root_folder() {
// @@protoc_insertion_point(field_release:caffe.ImageDataParameter.root_folder)
if (!_internal_has_root_folder()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = root_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (root_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ImageDataParameter::set_allocated_root_folder(std::string* root_folder) {
if (root_folder != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
root_folder_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), root_folder,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (root_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.ImageDataParameter.root_folder)
}
// optional uint32 label_num = 13 [default = 1];
inline bool ImageDataParameter::_internal_has_label_num() const {
bool value = (_has_bits_[0] & 0x00002000u) != 0;
return value;
}
inline bool ImageDataParameter::has_label_num() const {
return _internal_has_label_num();
}
inline void ImageDataParameter::clear_label_num() {
label_num_ = 1u;
_has_bits_[0] &= ~0x00002000u;
}
inline uint32_t ImageDataParameter::_internal_label_num() const {
return label_num_;
}
inline uint32_t ImageDataParameter::label_num() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.label_num)
return _internal_label_num();
}
inline void ImageDataParameter::_internal_set_label_num(uint32_t value) {
_has_bits_[0] |= 0x00002000u;
label_num_ = value;
}
inline void ImageDataParameter::set_label_num(uint32_t value) {
_internal_set_label_num(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.label_num)
}
// optional uint32 att_num = 14 [default = 1];
inline bool ImageDataParameter::_internal_has_att_num() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool ImageDataParameter::has_att_num() const {
return _internal_has_att_num();
}
inline void ImageDataParameter::clear_att_num() {
att_num_ = 1u;
_has_bits_[0] &= ~0x00000200u;
}
inline uint32_t ImageDataParameter::_internal_att_num() const {
return att_num_;
}
inline uint32_t ImageDataParameter::att_num() const {
// @@protoc_insertion_point(field_get:caffe.ImageDataParameter.att_num)
return _internal_att_num();
}
inline void ImageDataParameter::_internal_set_att_num(uint32_t value) {
_has_bits_[0] |= 0x00000200u;
att_num_ = value;
}
inline void ImageDataParameter::set_att_num(uint32_t value) {
_internal_set_att_num(value);
// @@protoc_insertion_point(field_set:caffe.ImageDataParameter.att_num)
}
// -------------------------------------------------------------------
// InfogainLossParameter
// optional string source = 1;
inline bool InfogainLossParameter::_internal_has_source() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool InfogainLossParameter::has_source() const {
return _internal_has_source();
}
inline void InfogainLossParameter::clear_source() {
source_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& InfogainLossParameter::source() const {
// @@protoc_insertion_point(field_get:caffe.InfogainLossParameter.source)
return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InfogainLossParameter::set_source(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.InfogainLossParameter.source)
}
inline std::string* InfogainLossParameter::mutable_source() {
std::string* _s = _internal_mutable_source();
// @@protoc_insertion_point(field_mutable:caffe.InfogainLossParameter.source)
return _s;
}
inline const std::string& InfogainLossParameter::_internal_source() const {
return source_.Get();
}
inline void InfogainLossParameter::_internal_set_source(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* InfogainLossParameter::_internal_mutable_source() {
_has_bits_[0] |= 0x00000001u;
return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* InfogainLossParameter::release_source() {
// @@protoc_insertion_point(field_release:caffe.InfogainLossParameter.source)
if (!_internal_has_source()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void InfogainLossParameter::set_allocated_source(std::string* source) {
if (source != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.InfogainLossParameter.source)
}
// optional int32 axis = 2 [default = 1];
inline bool InfogainLossParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool InfogainLossParameter::has_axis() const {
return _internal_has_axis();
}
inline void InfogainLossParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t InfogainLossParameter::_internal_axis() const {
return axis_;
}
inline int32_t InfogainLossParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.InfogainLossParameter.axis)
return _internal_axis();
}
inline void InfogainLossParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000002u;
axis_ = value;
}
inline void InfogainLossParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.InfogainLossParameter.axis)
}
// -------------------------------------------------------------------
// InnerProductParameter
// optional uint32 num_output = 1;
inline bool InnerProductParameter::_internal_has_num_output() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool InnerProductParameter::has_num_output() const {
return _internal_has_num_output();
}
inline void InnerProductParameter::clear_num_output() {
num_output_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t InnerProductParameter::_internal_num_output() const {
return num_output_;
}
inline uint32_t InnerProductParameter::num_output() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.num_output)
return _internal_num_output();
}
inline void InnerProductParameter::_internal_set_num_output(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
num_output_ = value;
}
inline void InnerProductParameter::set_num_output(uint32_t value) {
_internal_set_num_output(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.num_output)
}
// optional bool bias_term = 2 [default = true];
inline bool InnerProductParameter::_internal_has_bias_term() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool InnerProductParameter::has_bias_term() const {
return _internal_has_bias_term();
}
inline void InnerProductParameter::clear_bias_term() {
bias_term_ = true;
_has_bits_[0] &= ~0x00000100u;
}
inline bool InnerProductParameter::_internal_bias_term() const {
return bias_term_;
}
inline bool InnerProductParameter::bias_term() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.bias_term)
return _internal_bias_term();
}
inline void InnerProductParameter::_internal_set_bias_term(bool value) {
_has_bits_[0] |= 0x00000100u;
bias_term_ = value;
}
inline void InnerProductParameter::set_bias_term(bool value) {
_internal_set_bias_term(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.bias_term)
}
// optional .caffe.FillerParameter weight_filler = 3;
inline bool InnerProductParameter::_internal_has_weight_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || weight_filler_ != nullptr);
return value;
}
inline bool InnerProductParameter::has_weight_filler() const {
return _internal_has_weight_filler();
}
inline void InnerProductParameter::clear_weight_filler() {
if (weight_filler_ != nullptr) weight_filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& InnerProductParameter::_internal_weight_filler() const {
const ::caffe::FillerParameter* p = weight_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& InnerProductParameter::weight_filler() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.weight_filler)
return _internal_weight_filler();
}
inline void InnerProductParameter::unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_);
}
weight_filler_ = weight_filler;
if (weight_filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.InnerProductParameter.weight_filler)
}
inline ::caffe::FillerParameter* InnerProductParameter::release_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* InnerProductParameter::unsafe_arena_release_weight_filler() {
// @@protoc_insertion_point(field_release:caffe.InnerProductParameter.weight_filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* InnerProductParameter::_internal_mutable_weight_filler() {
_has_bits_[0] |= 0x00000001u;
if (weight_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
weight_filler_ = p;
}
return weight_filler_;
}
inline ::caffe::FillerParameter* InnerProductParameter::mutable_weight_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
// @@protoc_insertion_point(field_mutable:caffe.InnerProductParameter.weight_filler)
return _msg;
}
inline void InnerProductParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete weight_filler_;
}
if (weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(weight_filler);
if (message_arena != submessage_arena) {
weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.InnerProductParameter.weight_filler)
}
// optional .caffe.FillerParameter bias_filler = 4;
inline bool InnerProductParameter::_internal_has_bias_filler() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || bias_filler_ != nullptr);
return value;
}
inline bool InnerProductParameter::has_bias_filler() const {
return _internal_has_bias_filler();
}
inline void InnerProductParameter::clear_bias_filler() {
if (bias_filler_ != nullptr) bias_filler_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::FillerParameter& InnerProductParameter::_internal_bias_filler() const {
const ::caffe::FillerParameter* p = bias_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& InnerProductParameter::bias_filler() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.bias_filler)
return _internal_bias_filler();
}
inline void InnerProductParameter::unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_);
}
bias_filler_ = bias_filler;
if (bias_filler) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.InnerProductParameter.bias_filler)
}
inline ::caffe::FillerParameter* InnerProductParameter::release_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* InnerProductParameter::unsafe_arena_release_bias_filler() {
// @@protoc_insertion_point(field_release:caffe.InnerProductParameter.bias_filler)
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* InnerProductParameter::_internal_mutable_bias_filler() {
_has_bits_[0] |= 0x00000002u;
if (bias_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
bias_filler_ = p;
}
return bias_filler_;
}
inline ::caffe::FillerParameter* InnerProductParameter::mutable_bias_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
// @@protoc_insertion_point(field_mutable:caffe.InnerProductParameter.bias_filler)
return _msg;
}
inline void InnerProductParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_filler_;
}
if (bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(bias_filler);
if (message_arena != submessage_arena) {
bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.InnerProductParameter.bias_filler)
}
// optional int32 axis = 5 [default = 1];
inline bool InnerProductParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool InnerProductParameter::has_axis() const {
return _internal_has_axis();
}
inline void InnerProductParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000200u;
}
inline int32_t InnerProductParameter::_internal_axis() const {
return axis_;
}
inline int32_t InnerProductParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.axis)
return _internal_axis();
}
inline void InnerProductParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000200u;
axis_ = value;
}
inline void InnerProductParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.axis)
}
// optional bool transpose = 6 [default = false];
inline bool InnerProductParameter::_internal_has_transpose() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool InnerProductParameter::has_transpose() const {
return _internal_has_transpose();
}
inline void InnerProductParameter::clear_transpose() {
transpose_ = false;
_has_bits_[0] &= ~0x00000008u;
}
inline bool InnerProductParameter::_internal_transpose() const {
return transpose_;
}
inline bool InnerProductParameter::transpose() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.transpose)
return _internal_transpose();
}
inline void InnerProductParameter::_internal_set_transpose(bool value) {
_has_bits_[0] |= 0x00000008u;
transpose_ = value;
}
inline void InnerProductParameter::set_transpose(bool value) {
_internal_set_transpose(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.transpose)
}
// optional uint32 paramq = 7 [default = 0];
inline bool InnerProductParameter::_internal_has_paramq() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool InnerProductParameter::has_paramq() const {
return _internal_has_paramq();
}
inline void InnerProductParameter::clear_paramq() {
paramq_ = 0u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t InnerProductParameter::_internal_paramq() const {
return paramq_;
}
inline uint32_t InnerProductParameter::paramq() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.paramq)
return _internal_paramq();
}
inline void InnerProductParameter::_internal_set_paramq(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
paramq_ = value;
}
inline void InnerProductParameter::set_paramq(uint32_t value) {
_internal_set_paramq(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.paramq)
}
// optional float params = 8 [default = 0];
inline bool InnerProductParameter::_internal_has_params() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool InnerProductParameter::has_params() const {
return _internal_has_params();
}
inline void InnerProductParameter::clear_params() {
params_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline float InnerProductParameter::_internal_params() const {
return params_;
}
inline float InnerProductParameter::params() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.params)
return _internal_params();
}
inline void InnerProductParameter::_internal_set_params(float value) {
_has_bits_[0] |= 0x00000020u;
params_ = value;
}
inline void InnerProductParameter::set_params(float value) {
_internal_set_params(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.params)
}
// optional float scale_in = 9;
inline bool InnerProductParameter::_internal_has_scale_in() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool InnerProductParameter::has_scale_in() const {
return _internal_has_scale_in();
}
inline void InnerProductParameter::clear_scale_in() {
scale_in_ = 0;
_has_bits_[0] &= ~0x00000040u;
}
inline float InnerProductParameter::_internal_scale_in() const {
return scale_in_;
}
inline float InnerProductParameter::scale_in() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.scale_in)
return _internal_scale_in();
}
inline void InnerProductParameter::_internal_set_scale_in(float value) {
_has_bits_[0] |= 0x00000040u;
scale_in_ = value;
}
inline void InnerProductParameter::set_scale_in(float value) {
_internal_set_scale_in(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.scale_in)
}
// optional float scale_out = 10;
inline bool InnerProductParameter::_internal_has_scale_out() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool InnerProductParameter::has_scale_out() const {
return _internal_has_scale_out();
}
inline void InnerProductParameter::clear_scale_out() {
scale_out_ = 0;
_has_bits_[0] &= ~0x00000080u;
}
inline float InnerProductParameter::_internal_scale_out() const {
return scale_out_;
}
inline float InnerProductParameter::scale_out() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.scale_out)
return _internal_scale_out();
}
inline void InnerProductParameter::_internal_set_scale_out(float value) {
_has_bits_[0] |= 0x00000080u;
scale_out_ = value;
}
inline void InnerProductParameter::set_scale_out(float value) {
_internal_set_scale_out(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.scale_out)
}
// optional int32 a_min = 11 [default = -128];
inline bool InnerProductParameter::_internal_has_a_min() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool InnerProductParameter::has_a_min() const {
return _internal_has_a_min();
}
inline void InnerProductParameter::clear_a_min() {
a_min_ = -128;
_has_bits_[0] &= ~0x00000400u;
}
inline int32_t InnerProductParameter::_internal_a_min() const {
return a_min_;
}
inline int32_t InnerProductParameter::a_min() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.a_min)
return _internal_a_min();
}
inline void InnerProductParameter::_internal_set_a_min(int32_t value) {
_has_bits_[0] |= 0x00000400u;
a_min_ = value;
}
inline void InnerProductParameter::set_a_min(int32_t value) {
_internal_set_a_min(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.a_min)
}
// optional int32 a_max = 12 [default = 127];
inline bool InnerProductParameter::_internal_has_a_max() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool InnerProductParameter::has_a_max() const {
return _internal_has_a_max();
}
inline void InnerProductParameter::clear_a_max() {
a_max_ = 127;
_has_bits_[0] &= ~0x00000800u;
}
inline int32_t InnerProductParameter::_internal_a_max() const {
return a_max_;
}
inline int32_t InnerProductParameter::a_max() const {
// @@protoc_insertion_point(field_get:caffe.InnerProductParameter.a_max)
return _internal_a_max();
}
inline void InnerProductParameter::_internal_set_a_max(int32_t value) {
_has_bits_[0] |= 0x00000800u;
a_max_ = value;
}
inline void InnerProductParameter::set_a_max(int32_t value) {
_internal_set_a_max(value);
// @@protoc_insertion_point(field_set:caffe.InnerProductParameter.a_max)
}
// -------------------------------------------------------------------
// InputParameter
// repeated .caffe.BlobShape shape = 1;
inline int InputParameter::_internal_shape_size() const {
return shape_.size();
}
inline int InputParameter::shape_size() const {
return _internal_shape_size();
}
inline void InputParameter::clear_shape() {
shape_.Clear();
}
inline ::caffe::BlobShape* InputParameter::mutable_shape(int index) {
// @@protoc_insertion_point(field_mutable:caffe.InputParameter.shape)
return shape_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >*
InputParameter::mutable_shape() {
// @@protoc_insertion_point(field_mutable_list:caffe.InputParameter.shape)
return &shape_;
}
inline const ::caffe::BlobShape& InputParameter::_internal_shape(int index) const {
return shape_.Get(index);
}
inline const ::caffe::BlobShape& InputParameter::shape(int index) const {
// @@protoc_insertion_point(field_get:caffe.InputParameter.shape)
return _internal_shape(index);
}
inline ::caffe::BlobShape* InputParameter::_internal_add_shape() {
return shape_.Add();
}
inline ::caffe::BlobShape* InputParameter::add_shape() {
::caffe::BlobShape* _add = _internal_add_shape();
// @@protoc_insertion_point(field_add:caffe.InputParameter.shape)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobShape >&
InputParameter::shape() const {
// @@protoc_insertion_point(field_list:caffe.InputParameter.shape)
return shape_;
}
// -------------------------------------------------------------------
// LogParameter
// optional float base = 1 [default = -1];
inline bool LogParameter::_internal_has_base() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool LogParameter::has_base() const {
return _internal_has_base();
}
inline void LogParameter::clear_base() {
base_ = -1;
_has_bits_[0] &= ~0x00000002u;
}
inline float LogParameter::_internal_base() const {
return base_;
}
inline float LogParameter::base() const {
// @@protoc_insertion_point(field_get:caffe.LogParameter.base)
return _internal_base();
}
inline void LogParameter::_internal_set_base(float value) {
_has_bits_[0] |= 0x00000002u;
base_ = value;
}
inline void LogParameter::set_base(float value) {
_internal_set_base(value);
// @@protoc_insertion_point(field_set:caffe.LogParameter.base)
}
// optional float scale = 2 [default = 1];
inline bool LogParameter::_internal_has_scale() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool LogParameter::has_scale() const {
return _internal_has_scale();
}
inline void LogParameter::clear_scale() {
scale_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline float LogParameter::_internal_scale() const {
return scale_;
}
inline float LogParameter::scale() const {
// @@protoc_insertion_point(field_get:caffe.LogParameter.scale)
return _internal_scale();
}
inline void LogParameter::_internal_set_scale(float value) {
_has_bits_[0] |= 0x00000004u;
scale_ = value;
}
inline void LogParameter::set_scale(float value) {
_internal_set_scale(value);
// @@protoc_insertion_point(field_set:caffe.LogParameter.scale)
}
// optional float shift = 3 [default = 0];
inline bool LogParameter::_internal_has_shift() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool LogParameter::has_shift() const {
return _internal_has_shift();
}
inline void LogParameter::clear_shift() {
shift_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float LogParameter::_internal_shift() const {
return shift_;
}
inline float LogParameter::shift() const {
// @@protoc_insertion_point(field_get:caffe.LogParameter.shift)
return _internal_shift();
}
inline void LogParameter::_internal_set_shift(float value) {
_has_bits_[0] |= 0x00000001u;
shift_ = value;
}
inline void LogParameter::set_shift(float value) {
_internal_set_shift(value);
// @@protoc_insertion_point(field_set:caffe.LogParameter.shift)
}
// -------------------------------------------------------------------
// LRNParameter
// optional uint32 local_size = 1 [default = 5];
inline bool LRNParameter::_internal_has_local_size() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool LRNParameter::has_local_size() const {
return _internal_has_local_size();
}
inline void LRNParameter::clear_local_size() {
local_size_ = 5u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t LRNParameter::_internal_local_size() const {
return local_size_;
}
inline uint32_t LRNParameter::local_size() const {
// @@protoc_insertion_point(field_get:caffe.LRNParameter.local_size)
return _internal_local_size();
}
inline void LRNParameter::_internal_set_local_size(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
local_size_ = value;
}
inline void LRNParameter::set_local_size(uint32_t value) {
_internal_set_local_size(value);
// @@protoc_insertion_point(field_set:caffe.LRNParameter.local_size)
}
// optional float alpha = 2 [default = 1];
inline bool LRNParameter::_internal_has_alpha() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool LRNParameter::has_alpha() const {
return _internal_has_alpha();
}
inline void LRNParameter::clear_alpha() {
alpha_ = 1;
_has_bits_[0] &= ~0x00000008u;
}
inline float LRNParameter::_internal_alpha() const {
return alpha_;
}
inline float LRNParameter::alpha() const {
// @@protoc_insertion_point(field_get:caffe.LRNParameter.alpha)
return _internal_alpha();
}
inline void LRNParameter::_internal_set_alpha(float value) {
_has_bits_[0] |= 0x00000008u;
alpha_ = value;
}
inline void LRNParameter::set_alpha(float value) {
_internal_set_alpha(value);
// @@protoc_insertion_point(field_set:caffe.LRNParameter.alpha)
}
// optional float beta = 3 [default = 0.75];
inline bool LRNParameter::_internal_has_beta() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool LRNParameter::has_beta() const {
return _internal_has_beta();
}
inline void LRNParameter::clear_beta() {
beta_ = 0.75f;
_has_bits_[0] &= ~0x00000010u;
}
inline float LRNParameter::_internal_beta() const {
return beta_;
}
inline float LRNParameter::beta() const {
// @@protoc_insertion_point(field_get:caffe.LRNParameter.beta)
return _internal_beta();
}
inline void LRNParameter::_internal_set_beta(float value) {
_has_bits_[0] |= 0x00000010u;
beta_ = value;
}
inline void LRNParameter::set_beta(float value) {
_internal_set_beta(value);
// @@protoc_insertion_point(field_set:caffe.LRNParameter.beta)
}
// optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
inline bool LRNParameter::_internal_has_norm_region() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool LRNParameter::has_norm_region() const {
return _internal_has_norm_region();
}
inline void LRNParameter::clear_norm_region() {
norm_region_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::LRNParameter_NormRegion LRNParameter::_internal_norm_region() const {
return static_cast< ::caffe::LRNParameter_NormRegion >(norm_region_);
}
inline ::caffe::LRNParameter_NormRegion LRNParameter::norm_region() const {
// @@protoc_insertion_point(field_get:caffe.LRNParameter.norm_region)
return _internal_norm_region();
}
inline void LRNParameter::_internal_set_norm_region(::caffe::LRNParameter_NormRegion value) {
assert(::caffe::LRNParameter_NormRegion_IsValid(value));
_has_bits_[0] |= 0x00000001u;
norm_region_ = value;
}
inline void LRNParameter::set_norm_region(::caffe::LRNParameter_NormRegion value) {
_internal_set_norm_region(value);
// @@protoc_insertion_point(field_set:caffe.LRNParameter.norm_region)
}
// optional float k = 5 [default = 1];
inline bool LRNParameter::_internal_has_k() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool LRNParameter::has_k() const {
return _internal_has_k();
}
inline void LRNParameter::clear_k() {
k_ = 1;
_has_bits_[0] &= ~0x00000020u;
}
inline float LRNParameter::_internal_k() const {
return k_;
}
inline float LRNParameter::k() const {
// @@protoc_insertion_point(field_get:caffe.LRNParameter.k)
return _internal_k();
}
inline void LRNParameter::_internal_set_k(float value) {
_has_bits_[0] |= 0x00000020u;
k_ = value;
}
inline void LRNParameter::set_k(float value) {
_internal_set_k(value);
// @@protoc_insertion_point(field_set:caffe.LRNParameter.k)
}
// optional .caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
inline bool LRNParameter::_internal_has_engine() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool LRNParameter::has_engine() const {
return _internal_has_engine();
}
inline void LRNParameter::clear_engine() {
engine_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::caffe::LRNParameter_Engine LRNParameter::_internal_engine() const {
return static_cast< ::caffe::LRNParameter_Engine >(engine_);
}
inline ::caffe::LRNParameter_Engine LRNParameter::engine() const {
// @@protoc_insertion_point(field_get:caffe.LRNParameter.engine)
return _internal_engine();
}
inline void LRNParameter::_internal_set_engine(::caffe::LRNParameter_Engine value) {
assert(::caffe::LRNParameter_Engine_IsValid(value));
_has_bits_[0] |= 0x00000002u;
engine_ = value;
}
inline void LRNParameter::set_engine(::caffe::LRNParameter_Engine value) {
_internal_set_engine(value);
// @@protoc_insertion_point(field_set:caffe.LRNParameter.engine)
}
// -------------------------------------------------------------------
// MemoryDataParameter
// optional uint32 batch_size = 1;
inline bool MemoryDataParameter::_internal_has_batch_size() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool MemoryDataParameter::has_batch_size() const {
return _internal_has_batch_size();
}
inline void MemoryDataParameter::clear_batch_size() {
batch_size_ = 0u;
_has_bits_[0] &= ~0x00000001u;
}
inline uint32_t MemoryDataParameter::_internal_batch_size() const {
return batch_size_;
}
inline uint32_t MemoryDataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.batch_size)
return _internal_batch_size();
}
inline void MemoryDataParameter::_internal_set_batch_size(uint32_t value) {
_has_bits_[0] |= 0x00000001u;
batch_size_ = value;
}
inline void MemoryDataParameter::set_batch_size(uint32_t value) {
_internal_set_batch_size(value);
// @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.batch_size)
}
// optional uint32 channels = 2;
inline bool MemoryDataParameter::_internal_has_channels() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool MemoryDataParameter::has_channels() const {
return _internal_has_channels();
}
inline void MemoryDataParameter::clear_channels() {
channels_ = 0u;
_has_bits_[0] &= ~0x00000002u;
}
inline uint32_t MemoryDataParameter::_internal_channels() const {
return channels_;
}
inline uint32_t MemoryDataParameter::channels() const {
// @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.channels)
return _internal_channels();
}
inline void MemoryDataParameter::_internal_set_channels(uint32_t value) {
_has_bits_[0] |= 0x00000002u;
channels_ = value;
}
inline void MemoryDataParameter::set_channels(uint32_t value) {
_internal_set_channels(value);
// @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.channels)
}
// optional uint32 height = 3;
inline bool MemoryDataParameter::_internal_has_height() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool MemoryDataParameter::has_height() const {
return _internal_has_height();
}
inline void MemoryDataParameter::clear_height() {
height_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t MemoryDataParameter::_internal_height() const {
return height_;
}
inline uint32_t MemoryDataParameter::height() const {
// @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.height)
return _internal_height();
}
inline void MemoryDataParameter::_internal_set_height(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
height_ = value;
}
inline void MemoryDataParameter::set_height(uint32_t value) {
_internal_set_height(value);
// @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.height)
}
// optional uint32 width = 4;
inline bool MemoryDataParameter::_internal_has_width() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool MemoryDataParameter::has_width() const {
return _internal_has_width();
}
inline void MemoryDataParameter::clear_width() {
width_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t MemoryDataParameter::_internal_width() const {
return width_;
}
inline uint32_t MemoryDataParameter::width() const {
// @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.width)
return _internal_width();
}
inline void MemoryDataParameter::_internal_set_width(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
width_ = value;
}
inline void MemoryDataParameter::set_width(uint32_t value) {
_internal_set_width(value);
// @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.width)
}
// -------------------------------------------------------------------
// MultiBoxLossParameter
// optional .caffe.MultiBoxLossParameter.LocLossType loc_loss_type = 1 [default = SMOOTH_L1];
inline bool MultiBoxLossParameter::_internal_has_loc_loss_type() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_loc_loss_type() const {
return _internal_has_loc_loss_type();
}
inline void MultiBoxLossParameter::clear_loc_loss_type() {
loc_loss_type_ = 1;
_has_bits_[0] &= ~0x00000400u;
}
inline ::caffe::MultiBoxLossParameter_LocLossType MultiBoxLossParameter::_internal_loc_loss_type() const {
return static_cast< ::caffe::MultiBoxLossParameter_LocLossType >(loc_loss_type_);
}
inline ::caffe::MultiBoxLossParameter_LocLossType MultiBoxLossParameter::loc_loss_type() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.loc_loss_type)
return _internal_loc_loss_type();
}
inline void MultiBoxLossParameter::_internal_set_loc_loss_type(::caffe::MultiBoxLossParameter_LocLossType value) {
assert(::caffe::MultiBoxLossParameter_LocLossType_IsValid(value));
_has_bits_[0] |= 0x00000400u;
loc_loss_type_ = value;
}
inline void MultiBoxLossParameter::set_loc_loss_type(::caffe::MultiBoxLossParameter_LocLossType value) {
_internal_set_loc_loss_type(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.loc_loss_type)
}
// optional .caffe.MultiBoxLossParameter.ConfLossType conf_loss_type = 2 [default = SOFTMAX];
inline bool MultiBoxLossParameter::_internal_has_conf_loss_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_conf_loss_type() const {
return _internal_has_conf_loss_type();
}
inline void MultiBoxLossParameter::clear_conf_loss_type() {
conf_loss_type_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::caffe::MultiBoxLossParameter_ConfLossType MultiBoxLossParameter::_internal_conf_loss_type() const {
return static_cast< ::caffe::MultiBoxLossParameter_ConfLossType >(conf_loss_type_);
}
inline ::caffe::MultiBoxLossParameter_ConfLossType MultiBoxLossParameter::conf_loss_type() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.conf_loss_type)
return _internal_conf_loss_type();
}
inline void MultiBoxLossParameter::_internal_set_conf_loss_type(::caffe::MultiBoxLossParameter_ConfLossType value) {
assert(::caffe::MultiBoxLossParameter_ConfLossType_IsValid(value));
_has_bits_[0] |= 0x00000002u;
conf_loss_type_ = value;
}
inline void MultiBoxLossParameter::set_conf_loss_type(::caffe::MultiBoxLossParameter_ConfLossType value) {
_internal_set_conf_loss_type(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.conf_loss_type)
}
// optional float loc_weight = 3 [default = 1];
inline bool MultiBoxLossParameter::_internal_has_loc_weight() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_loc_weight() const {
return _internal_has_loc_weight();
}
inline void MultiBoxLossParameter::clear_loc_weight() {
loc_weight_ = 1;
_has_bits_[0] &= ~0x00000800u;
}
inline float MultiBoxLossParameter::_internal_loc_weight() const {
return loc_weight_;
}
inline float MultiBoxLossParameter::loc_weight() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.loc_weight)
return _internal_loc_weight();
}
inline void MultiBoxLossParameter::_internal_set_loc_weight(float value) {
_has_bits_[0] |= 0x00000800u;
loc_weight_ = value;
}
inline void MultiBoxLossParameter::set_loc_weight(float value) {
_internal_set_loc_weight(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.loc_weight)
}
// optional uint32 num_classes = 4;
inline bool MultiBoxLossParameter::_internal_has_num_classes() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_num_classes() const {
return _internal_has_num_classes();
}
inline void MultiBoxLossParameter::clear_num_classes() {
num_classes_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t MultiBoxLossParameter::_internal_num_classes() const {
return num_classes_;
}
inline uint32_t MultiBoxLossParameter::num_classes() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.num_classes)
return _internal_num_classes();
}
inline void MultiBoxLossParameter::_internal_set_num_classes(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
num_classes_ = value;
}
inline void MultiBoxLossParameter::set_num_classes(uint32_t value) {
_internal_set_num_classes(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.num_classes)
}
// optional bool share_location = 5 [default = true];
inline bool MultiBoxLossParameter::_internal_has_share_location() const {
bool value = (_has_bits_[0] & 0x00004000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_share_location() const {
return _internal_has_share_location();
}
inline void MultiBoxLossParameter::clear_share_location() {
share_location_ = true;
_has_bits_[0] &= ~0x00004000u;
}
inline bool MultiBoxLossParameter::_internal_share_location() const {
return share_location_;
}
inline bool MultiBoxLossParameter::share_location() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.share_location)
return _internal_share_location();
}
inline void MultiBoxLossParameter::_internal_set_share_location(bool value) {
_has_bits_[0] |= 0x00004000u;
share_location_ = value;
}
inline void MultiBoxLossParameter::set_share_location(bool value) {
_internal_set_share_location(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.share_location)
}
// optional .caffe.MultiBoxLossParameter.MatchType match_type = 6 [default = PER_PREDICTION];
inline bool MultiBoxLossParameter::_internal_has_match_type() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_match_type() const {
return _internal_has_match_type();
}
inline void MultiBoxLossParameter::clear_match_type() {
match_type_ = 1;
_has_bits_[0] &= ~0x00001000u;
}
inline ::caffe::MultiBoxLossParameter_MatchType MultiBoxLossParameter::_internal_match_type() const {
return static_cast< ::caffe::MultiBoxLossParameter_MatchType >(match_type_);
}
inline ::caffe::MultiBoxLossParameter_MatchType MultiBoxLossParameter::match_type() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.match_type)
return _internal_match_type();
}
inline void MultiBoxLossParameter::_internal_set_match_type(::caffe::MultiBoxLossParameter_MatchType value) {
assert(::caffe::MultiBoxLossParameter_MatchType_IsValid(value));
_has_bits_[0] |= 0x00001000u;
match_type_ = value;
}
inline void MultiBoxLossParameter::set_match_type(::caffe::MultiBoxLossParameter_MatchType value) {
_internal_set_match_type(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.match_type)
}
// optional float overlap_threshold = 7 [default = 0.5];
inline bool MultiBoxLossParameter::_internal_has_overlap_threshold() const {
bool value = (_has_bits_[0] & 0x00002000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_overlap_threshold() const {
return _internal_has_overlap_threshold();
}
inline void MultiBoxLossParameter::clear_overlap_threshold() {
overlap_threshold_ = 0.5f;
_has_bits_[0] &= ~0x00002000u;
}
inline float MultiBoxLossParameter::_internal_overlap_threshold() const {
return overlap_threshold_;
}
inline float MultiBoxLossParameter::overlap_threshold() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.overlap_threshold)
return _internal_overlap_threshold();
}
inline void MultiBoxLossParameter::_internal_set_overlap_threshold(float value) {
_has_bits_[0] |= 0x00002000u;
overlap_threshold_ = value;
}
inline void MultiBoxLossParameter::set_overlap_threshold(float value) {
_internal_set_overlap_threshold(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.overlap_threshold)
}
// optional bool use_prior_for_matching = 8 [default = true];
inline bool MultiBoxLossParameter::_internal_has_use_prior_for_matching() const {
bool value = (_has_bits_[0] & 0x00008000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_use_prior_for_matching() const {
return _internal_has_use_prior_for_matching();
}
inline void MultiBoxLossParameter::clear_use_prior_for_matching() {
use_prior_for_matching_ = true;
_has_bits_[0] &= ~0x00008000u;
}
inline bool MultiBoxLossParameter::_internal_use_prior_for_matching() const {
return use_prior_for_matching_;
}
inline bool MultiBoxLossParameter::use_prior_for_matching() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.use_prior_for_matching)
return _internal_use_prior_for_matching();
}
inline void MultiBoxLossParameter::_internal_set_use_prior_for_matching(bool value) {
_has_bits_[0] |= 0x00008000u;
use_prior_for_matching_ = value;
}
inline void MultiBoxLossParameter::set_use_prior_for_matching(bool value) {
_internal_set_use_prior_for_matching(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.use_prior_for_matching)
}
// optional uint32 background_label_id = 9 [default = 0];
inline bool MultiBoxLossParameter::_internal_has_background_label_id() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_background_label_id() const {
return _internal_has_background_label_id();
}
inline void MultiBoxLossParameter::clear_background_label_id() {
background_label_id_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t MultiBoxLossParameter::_internal_background_label_id() const {
return background_label_id_;
}
inline uint32_t MultiBoxLossParameter::background_label_id() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.background_label_id)
return _internal_background_label_id();
}
inline void MultiBoxLossParameter::_internal_set_background_label_id(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
background_label_id_ = value;
}
inline void MultiBoxLossParameter::set_background_label_id(uint32_t value) {
_internal_set_background_label_id(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.background_label_id)
}
// optional bool use_difficult_gt = 10 [default = true];
inline bool MultiBoxLossParameter::_internal_has_use_difficult_gt() const {
bool value = (_has_bits_[0] & 0x00010000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_use_difficult_gt() const {
return _internal_has_use_difficult_gt();
}
inline void MultiBoxLossParameter::clear_use_difficult_gt() {
use_difficult_gt_ = true;
_has_bits_[0] &= ~0x00010000u;
}
inline bool MultiBoxLossParameter::_internal_use_difficult_gt() const {
return use_difficult_gt_;
}
inline bool MultiBoxLossParameter::use_difficult_gt() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.use_difficult_gt)
return _internal_use_difficult_gt();
}
inline void MultiBoxLossParameter::_internal_set_use_difficult_gt(bool value) {
_has_bits_[0] |= 0x00010000u;
use_difficult_gt_ = value;
}
inline void MultiBoxLossParameter::set_use_difficult_gt(bool value) {
_internal_set_use_difficult_gt(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.use_difficult_gt)
}
// optional bool do_neg_mining = 11;
inline bool MultiBoxLossParameter::_internal_has_do_neg_mining() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_do_neg_mining() const {
return _internal_has_do_neg_mining();
}
inline void MultiBoxLossParameter::clear_do_neg_mining() {
do_neg_mining_ = false;
_has_bits_[0] &= ~0x00000010u;
}
inline bool MultiBoxLossParameter::_internal_do_neg_mining() const {
return do_neg_mining_;
}
inline bool MultiBoxLossParameter::do_neg_mining() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.do_neg_mining)
return _internal_do_neg_mining();
}
inline void MultiBoxLossParameter::_internal_set_do_neg_mining(bool value) {
_has_bits_[0] |= 0x00000010u;
do_neg_mining_ = value;
}
inline void MultiBoxLossParameter::set_do_neg_mining(bool value) {
_internal_set_do_neg_mining(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.do_neg_mining)
}
// optional float neg_pos_ratio = 12 [default = 3];
inline bool MultiBoxLossParameter::_internal_has_neg_pos_ratio() const {
bool value = (_has_bits_[0] & 0x00020000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_neg_pos_ratio() const {
return _internal_has_neg_pos_ratio();
}
inline void MultiBoxLossParameter::clear_neg_pos_ratio() {
neg_pos_ratio_ = 3;
_has_bits_[0] &= ~0x00020000u;
}
inline float MultiBoxLossParameter::_internal_neg_pos_ratio() const {
return neg_pos_ratio_;
}
inline float MultiBoxLossParameter::neg_pos_ratio() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.neg_pos_ratio)
return _internal_neg_pos_ratio();
}
inline void MultiBoxLossParameter::_internal_set_neg_pos_ratio(float value) {
_has_bits_[0] |= 0x00020000u;
neg_pos_ratio_ = value;
}
inline void MultiBoxLossParameter::set_neg_pos_ratio(float value) {
_internal_set_neg_pos_ratio(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.neg_pos_ratio)
}
// optional float neg_overlap = 13 [default = 0.5];
inline bool MultiBoxLossParameter::_internal_has_neg_overlap() const {
bool value = (_has_bits_[0] & 0x00040000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_neg_overlap() const {
return _internal_has_neg_overlap();
}
inline void MultiBoxLossParameter::clear_neg_overlap() {
neg_overlap_ = 0.5f;
_has_bits_[0] &= ~0x00040000u;
}
inline float MultiBoxLossParameter::_internal_neg_overlap() const {
return neg_overlap_;
}
inline float MultiBoxLossParameter::neg_overlap() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.neg_overlap)
return _internal_neg_overlap();
}
inline void MultiBoxLossParameter::_internal_set_neg_overlap(float value) {
_has_bits_[0] |= 0x00040000u;
neg_overlap_ = value;
}
inline void MultiBoxLossParameter::set_neg_overlap(float value) {
_internal_set_neg_overlap(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.neg_overlap)
}
// optional .caffe.PriorBoxParameter.CodeType code_type = 14 [default = CORNER];
inline bool MultiBoxLossParameter::_internal_has_code_type() const {
bool value = (_has_bits_[0] & 0x00080000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_code_type() const {
return _internal_has_code_type();
}
inline void MultiBoxLossParameter::clear_code_type() {
code_type_ = 1;
_has_bits_[0] &= ~0x00080000u;
}
inline ::caffe::PriorBoxParameter_CodeType MultiBoxLossParameter::_internal_code_type() const {
return static_cast< ::caffe::PriorBoxParameter_CodeType >(code_type_);
}
inline ::caffe::PriorBoxParameter_CodeType MultiBoxLossParameter::code_type() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.code_type)
return _internal_code_type();
}
inline void MultiBoxLossParameter::_internal_set_code_type(::caffe::PriorBoxParameter_CodeType value) {
assert(::caffe::PriorBoxParameter_CodeType_IsValid(value));
_has_bits_[0] |= 0x00080000u;
code_type_ = value;
}
inline void MultiBoxLossParameter::set_code_type(::caffe::PriorBoxParameter_CodeType value) {
_internal_set_code_type(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.code_type)
}
// optional bool encode_variance_in_target = 16 [default = false];
inline bool MultiBoxLossParameter::_internal_has_encode_variance_in_target() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_encode_variance_in_target() const {
return _internal_has_encode_variance_in_target();
}
inline void MultiBoxLossParameter::clear_encode_variance_in_target() {
encode_variance_in_target_ = false;
_has_bits_[0] &= ~0x00000020u;
}
inline bool MultiBoxLossParameter::_internal_encode_variance_in_target() const {
return encode_variance_in_target_;
}
inline bool MultiBoxLossParameter::encode_variance_in_target() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.encode_variance_in_target)
return _internal_encode_variance_in_target();
}
inline void MultiBoxLossParameter::_internal_set_encode_variance_in_target(bool value) {
_has_bits_[0] |= 0x00000020u;
encode_variance_in_target_ = value;
}
inline void MultiBoxLossParameter::set_encode_variance_in_target(bool value) {
_internal_set_encode_variance_in_target(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.encode_variance_in_target)
}
// optional bool map_object_to_agnostic = 17 [default = false];
inline bool MultiBoxLossParameter::_internal_has_map_object_to_agnostic() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_map_object_to_agnostic() const {
return _internal_has_map_object_to_agnostic();
}
inline void MultiBoxLossParameter::clear_map_object_to_agnostic() {
map_object_to_agnostic_ = false;
_has_bits_[0] &= ~0x00000040u;
}
inline bool MultiBoxLossParameter::_internal_map_object_to_agnostic() const {
return map_object_to_agnostic_;
}
inline bool MultiBoxLossParameter::map_object_to_agnostic() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.map_object_to_agnostic)
return _internal_map_object_to_agnostic();
}
inline void MultiBoxLossParameter::_internal_set_map_object_to_agnostic(bool value) {
_has_bits_[0] |= 0x00000040u;
map_object_to_agnostic_ = value;
}
inline void MultiBoxLossParameter::set_map_object_to_agnostic(bool value) {
_internal_set_map_object_to_agnostic(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.map_object_to_agnostic)
}
// optional bool ignore_cross_boundary_bbox = 18 [default = false];
inline bool MultiBoxLossParameter::_internal_has_ignore_cross_boundary_bbox() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_ignore_cross_boundary_bbox() const {
return _internal_has_ignore_cross_boundary_bbox();
}
inline void MultiBoxLossParameter::clear_ignore_cross_boundary_bbox() {
ignore_cross_boundary_bbox_ = false;
_has_bits_[0] &= ~0x00000080u;
}
inline bool MultiBoxLossParameter::_internal_ignore_cross_boundary_bbox() const {
return ignore_cross_boundary_bbox_;
}
inline bool MultiBoxLossParameter::ignore_cross_boundary_bbox() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.ignore_cross_boundary_bbox)
return _internal_ignore_cross_boundary_bbox();
}
inline void MultiBoxLossParameter::_internal_set_ignore_cross_boundary_bbox(bool value) {
_has_bits_[0] |= 0x00000080u;
ignore_cross_boundary_bbox_ = value;
}
inline void MultiBoxLossParameter::set_ignore_cross_boundary_bbox(bool value) {
_internal_set_ignore_cross_boundary_bbox(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.ignore_cross_boundary_bbox)
}
// optional bool bp_inside = 19 [default = false];
inline bool MultiBoxLossParameter::_internal_has_bp_inside() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_bp_inside() const {
return _internal_has_bp_inside();
}
inline void MultiBoxLossParameter::clear_bp_inside() {
bp_inside_ = false;
_has_bits_[0] &= ~0x00000100u;
}
inline bool MultiBoxLossParameter::_internal_bp_inside() const {
return bp_inside_;
}
inline bool MultiBoxLossParameter::bp_inside() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.bp_inside)
return _internal_bp_inside();
}
inline void MultiBoxLossParameter::_internal_set_bp_inside(bool value) {
_has_bits_[0] |= 0x00000100u;
bp_inside_ = value;
}
inline void MultiBoxLossParameter::set_bp_inside(bool value) {
_internal_set_bp_inside(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.bp_inside)
}
// optional .caffe.MultiBoxLossParameter.MiningType mining_type = 20 [default = MAX_NEGATIVE];
inline bool MultiBoxLossParameter::_internal_has_mining_type() const {
bool value = (_has_bits_[0] & 0x00100000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_mining_type() const {
return _internal_has_mining_type();
}
inline void MultiBoxLossParameter::clear_mining_type() {
mining_type_ = 1;
_has_bits_[0] &= ~0x00100000u;
}
inline ::caffe::MultiBoxLossParameter_MiningType MultiBoxLossParameter::_internal_mining_type() const {
return static_cast< ::caffe::MultiBoxLossParameter_MiningType >(mining_type_);
}
inline ::caffe::MultiBoxLossParameter_MiningType MultiBoxLossParameter::mining_type() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.mining_type)
return _internal_mining_type();
}
inline void MultiBoxLossParameter::_internal_set_mining_type(::caffe::MultiBoxLossParameter_MiningType value) {
assert(::caffe::MultiBoxLossParameter_MiningType_IsValid(value));
_has_bits_[0] |= 0x00100000u;
mining_type_ = value;
}
inline void MultiBoxLossParameter::set_mining_type(::caffe::MultiBoxLossParameter_MiningType value) {
_internal_set_mining_type(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.mining_type)
}
// optional .caffe.NonMaximumSuppressionParameter nms_param = 21;
inline bool MultiBoxLossParameter::_internal_has_nms_param() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || nms_param_ != nullptr);
return value;
}
inline bool MultiBoxLossParameter::has_nms_param() const {
return _internal_has_nms_param();
}
inline void MultiBoxLossParameter::clear_nms_param() {
if (nms_param_ != nullptr) nms_param_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::NonMaximumSuppressionParameter& MultiBoxLossParameter::_internal_nms_param() const {
const ::caffe::NonMaximumSuppressionParameter* p = nms_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::NonMaximumSuppressionParameter&>(
::caffe::_NonMaximumSuppressionParameter_default_instance_);
}
inline const ::caffe::NonMaximumSuppressionParameter& MultiBoxLossParameter::nms_param() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.nms_param)
return _internal_nms_param();
}
inline void MultiBoxLossParameter::unsafe_arena_set_allocated_nms_param(
::caffe::NonMaximumSuppressionParameter* nms_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(nms_param_);
}
nms_param_ = nms_param;
if (nms_param) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.MultiBoxLossParameter.nms_param)
}
inline ::caffe::NonMaximumSuppressionParameter* MultiBoxLossParameter::release_nms_param() {
_has_bits_[0] &= ~0x00000001u;
::caffe::NonMaximumSuppressionParameter* temp = nms_param_;
nms_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::NonMaximumSuppressionParameter* MultiBoxLossParameter::unsafe_arena_release_nms_param() {
// @@protoc_insertion_point(field_release:caffe.MultiBoxLossParameter.nms_param)
_has_bits_[0] &= ~0x00000001u;
::caffe::NonMaximumSuppressionParameter* temp = nms_param_;
nms_param_ = nullptr;
return temp;
}
inline ::caffe::NonMaximumSuppressionParameter* MultiBoxLossParameter::_internal_mutable_nms_param() {
_has_bits_[0] |= 0x00000001u;
if (nms_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::NonMaximumSuppressionParameter>(GetArenaForAllocation());
nms_param_ = p;
}
return nms_param_;
}
inline ::caffe::NonMaximumSuppressionParameter* MultiBoxLossParameter::mutable_nms_param() {
::caffe::NonMaximumSuppressionParameter* _msg = _internal_mutable_nms_param();
// @@protoc_insertion_point(field_mutable:caffe.MultiBoxLossParameter.nms_param)
return _msg;
}
inline void MultiBoxLossParameter::set_allocated_nms_param(::caffe::NonMaximumSuppressionParameter* nms_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete nms_param_;
}
if (nms_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::NonMaximumSuppressionParameter>::GetOwningArena(nms_param);
if (message_arena != submessage_arena) {
nms_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, nms_param, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
nms_param_ = nms_param;
// @@protoc_insertion_point(field_set_allocated:caffe.MultiBoxLossParameter.nms_param)
}
// optional int32 sample_size = 22 [default = 64];
inline bool MultiBoxLossParameter::_internal_has_sample_size() const {
bool value = (_has_bits_[0] & 0x00200000u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_sample_size() const {
return _internal_has_sample_size();
}
inline void MultiBoxLossParameter::clear_sample_size() {
sample_size_ = 64;
_has_bits_[0] &= ~0x00200000u;
}
inline int32_t MultiBoxLossParameter::_internal_sample_size() const {
return sample_size_;
}
inline int32_t MultiBoxLossParameter::sample_size() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.sample_size)
return _internal_sample_size();
}
inline void MultiBoxLossParameter::_internal_set_sample_size(int32_t value) {
_has_bits_[0] |= 0x00200000u;
sample_size_ = value;
}
inline void MultiBoxLossParameter::set_sample_size(int32_t value) {
_internal_set_sample_size(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.sample_size)
}
// optional bool use_prior_for_nms = 23 [default = false];
inline bool MultiBoxLossParameter::_internal_has_use_prior_for_nms() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool MultiBoxLossParameter::has_use_prior_for_nms() const {
return _internal_has_use_prior_for_nms();
}
inline void MultiBoxLossParameter::clear_use_prior_for_nms() {
use_prior_for_nms_ = false;
_has_bits_[0] &= ~0x00000200u;
}
inline bool MultiBoxLossParameter::_internal_use_prior_for_nms() const {
return use_prior_for_nms_;
}
inline bool MultiBoxLossParameter::use_prior_for_nms() const {
// @@protoc_insertion_point(field_get:caffe.MultiBoxLossParameter.use_prior_for_nms)
return _internal_use_prior_for_nms();
}
inline void MultiBoxLossParameter::_internal_set_use_prior_for_nms(bool value) {
_has_bits_[0] |= 0x00000200u;
use_prior_for_nms_ = value;
}
inline void MultiBoxLossParameter::set_use_prior_for_nms(bool value) {
_internal_set_use_prior_for_nms(value);
// @@protoc_insertion_point(field_set:caffe.MultiBoxLossParameter.use_prior_for_nms)
}
// -------------------------------------------------------------------
// MVNParameter
// optional bool normalize_variance = 1 [default = true];
inline bool MVNParameter::_internal_has_normalize_variance() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool MVNParameter::has_normalize_variance() const {
return _internal_has_normalize_variance();
}
inline void MVNParameter::clear_normalize_variance() {
normalize_variance_ = true;
_has_bits_[0] &= ~0x00000002u;
}
inline bool MVNParameter::_internal_normalize_variance() const {
return normalize_variance_;
}
inline bool MVNParameter::normalize_variance() const {
// @@protoc_insertion_point(field_get:caffe.MVNParameter.normalize_variance)
return _internal_normalize_variance();
}
inline void MVNParameter::_internal_set_normalize_variance(bool value) {
_has_bits_[0] |= 0x00000002u;
normalize_variance_ = value;
}
inline void MVNParameter::set_normalize_variance(bool value) {
_internal_set_normalize_variance(value);
// @@protoc_insertion_point(field_set:caffe.MVNParameter.normalize_variance)
}
// optional bool across_channels = 2 [default = false];
inline bool MVNParameter::_internal_has_across_channels() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool MVNParameter::has_across_channels() const {
return _internal_has_across_channels();
}
inline void MVNParameter::clear_across_channels() {
across_channels_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool MVNParameter::_internal_across_channels() const {
return across_channels_;
}
inline bool MVNParameter::across_channels() const {
// @@protoc_insertion_point(field_get:caffe.MVNParameter.across_channels)
return _internal_across_channels();
}
inline void MVNParameter::_internal_set_across_channels(bool value) {
_has_bits_[0] |= 0x00000001u;
across_channels_ = value;
}
inline void MVNParameter::set_across_channels(bool value) {
_internal_set_across_channels(value);
// @@protoc_insertion_point(field_set:caffe.MVNParameter.across_channels)
}
// optional float eps = 3 [default = 1e-09];
inline bool MVNParameter::_internal_has_eps() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool MVNParameter::has_eps() const {
return _internal_has_eps();
}
inline void MVNParameter::clear_eps() {
eps_ = 1e-09f;
_has_bits_[0] &= ~0x00000004u;
}
inline float MVNParameter::_internal_eps() const {
return eps_;
}
inline float MVNParameter::eps() const {
// @@protoc_insertion_point(field_get:caffe.MVNParameter.eps)
return _internal_eps();
}
inline void MVNParameter::_internal_set_eps(float value) {
_has_bits_[0] |= 0x00000004u;
eps_ = value;
}
inline void MVNParameter::set_eps(float value) {
_internal_set_eps(value);
// @@protoc_insertion_point(field_set:caffe.MVNParameter.eps)
}
// -------------------------------------------------------------------
// NormalizeParameter
// optional bool across_spatial = 1 [default = true];
inline bool NormalizeParameter::_internal_has_across_spatial() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool NormalizeParameter::has_across_spatial() const {
return _internal_has_across_spatial();
}
inline void NormalizeParameter::clear_across_spatial() {
across_spatial_ = true;
_has_bits_[0] &= ~0x00000002u;
}
inline bool NormalizeParameter::_internal_across_spatial() const {
return across_spatial_;
}
inline bool NormalizeParameter::across_spatial() const {
// @@protoc_insertion_point(field_get:caffe.NormalizeParameter.across_spatial)
return _internal_across_spatial();
}
inline void NormalizeParameter::_internal_set_across_spatial(bool value) {
_has_bits_[0] |= 0x00000002u;
across_spatial_ = value;
}
inline void NormalizeParameter::set_across_spatial(bool value) {
_internal_set_across_spatial(value);
// @@protoc_insertion_point(field_set:caffe.NormalizeParameter.across_spatial)
}
// optional .caffe.FillerParameter scale_filler = 2;
inline bool NormalizeParameter::_internal_has_scale_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || scale_filler_ != nullptr);
return value;
}
inline bool NormalizeParameter::has_scale_filler() const {
return _internal_has_scale_filler();
}
inline void NormalizeParameter::clear_scale_filler() {
if (scale_filler_ != nullptr) scale_filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& NormalizeParameter::_internal_scale_filler() const {
const ::caffe::FillerParameter* p = scale_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& NormalizeParameter::scale_filler() const {
// @@protoc_insertion_point(field_get:caffe.NormalizeParameter.scale_filler)
return _internal_scale_filler();
}
inline void NormalizeParameter::unsafe_arena_set_allocated_scale_filler(
::caffe::FillerParameter* scale_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_filler_);
}
scale_filler_ = scale_filler;
if (scale_filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.NormalizeParameter.scale_filler)
}
inline ::caffe::FillerParameter* NormalizeParameter::release_scale_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = scale_filler_;
scale_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* NormalizeParameter::unsafe_arena_release_scale_filler() {
// @@protoc_insertion_point(field_release:caffe.NormalizeParameter.scale_filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = scale_filler_;
scale_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* NormalizeParameter::_internal_mutable_scale_filler() {
_has_bits_[0] |= 0x00000001u;
if (scale_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
scale_filler_ = p;
}
return scale_filler_;
}
inline ::caffe::FillerParameter* NormalizeParameter::mutable_scale_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_scale_filler();
// @@protoc_insertion_point(field_mutable:caffe.NormalizeParameter.scale_filler)
return _msg;
}
inline void NormalizeParameter::set_allocated_scale_filler(::caffe::FillerParameter* scale_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete scale_filler_;
}
if (scale_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(scale_filler);
if (message_arena != submessage_arena) {
scale_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, scale_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
scale_filler_ = scale_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.NormalizeParameter.scale_filler)
}
// optional bool channel_shared = 3 [default = true];
inline bool NormalizeParameter::_internal_has_channel_shared() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool NormalizeParameter::has_channel_shared() const {
return _internal_has_channel_shared();
}
inline void NormalizeParameter::clear_channel_shared() {
channel_shared_ = true;
_has_bits_[0] &= ~0x00000004u;
}
inline bool NormalizeParameter::_internal_channel_shared() const {
return channel_shared_;
}
inline bool NormalizeParameter::channel_shared() const {
// @@protoc_insertion_point(field_get:caffe.NormalizeParameter.channel_shared)
return _internal_channel_shared();
}
inline void NormalizeParameter::_internal_set_channel_shared(bool value) {
_has_bits_[0] |= 0x00000004u;
channel_shared_ = value;
}
inline void NormalizeParameter::set_channel_shared(bool value) {
_internal_set_channel_shared(value);
// @@protoc_insertion_point(field_set:caffe.NormalizeParameter.channel_shared)
}
// optional float eps = 4 [default = 1e-10];
inline bool NormalizeParameter::_internal_has_eps() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool NormalizeParameter::has_eps() const {
return _internal_has_eps();
}
inline void NormalizeParameter::clear_eps() {
eps_ = 1e-10f;
_has_bits_[0] &= ~0x00000008u;
}
inline float NormalizeParameter::_internal_eps() const {
return eps_;
}
inline float NormalizeParameter::eps() const {
// @@protoc_insertion_point(field_get:caffe.NormalizeParameter.eps)
return _internal_eps();
}
inline void NormalizeParameter::_internal_set_eps(float value) {
_has_bits_[0] |= 0x00000008u;
eps_ = value;
}
inline void NormalizeParameter::set_eps(float value) {
_internal_set_eps(value);
// @@protoc_insertion_point(field_set:caffe.NormalizeParameter.eps)
}
// -------------------------------------------------------------------
// ParameterParameter
// optional .caffe.BlobShape shape = 1;
inline bool ParameterParameter::_internal_has_shape() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || shape_ != nullptr);
return value;
}
inline bool ParameterParameter::has_shape() const {
return _internal_has_shape();
}
inline void ParameterParameter::clear_shape() {
if (shape_ != nullptr) shape_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::BlobShape& ParameterParameter::_internal_shape() const {
const ::caffe::BlobShape* p = shape_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::BlobShape&>(
::caffe::_BlobShape_default_instance_);
}
inline const ::caffe::BlobShape& ParameterParameter::shape() const {
// @@protoc_insertion_point(field_get:caffe.ParameterParameter.shape)
return _internal_shape();
}
inline void ParameterParameter::unsafe_arena_set_allocated_shape(
::caffe::BlobShape* shape) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
}
shape_ = shape;
if (shape) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.ParameterParameter.shape)
}
inline ::caffe::BlobShape* ParameterParameter::release_shape() {
_has_bits_[0] &= ~0x00000001u;
::caffe::BlobShape* temp = shape_;
shape_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::BlobShape* ParameterParameter::unsafe_arena_release_shape() {
// @@protoc_insertion_point(field_release:caffe.ParameterParameter.shape)
_has_bits_[0] &= ~0x00000001u;
::caffe::BlobShape* temp = shape_;
shape_ = nullptr;
return temp;
}
inline ::caffe::BlobShape* ParameterParameter::_internal_mutable_shape() {
_has_bits_[0] |= 0x00000001u;
if (shape_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::BlobShape>(GetArenaForAllocation());
shape_ = p;
}
return shape_;
}
inline ::caffe::BlobShape* ParameterParameter::mutable_shape() {
::caffe::BlobShape* _msg = _internal_mutable_shape();
// @@protoc_insertion_point(field_mutable:caffe.ParameterParameter.shape)
return _msg;
}
inline void ParameterParameter::set_allocated_shape(::caffe::BlobShape* shape) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete shape_;
}
if (shape) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::BlobShape>::GetOwningArena(shape);
if (message_arena != submessage_arena) {
shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, shape, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
shape_ = shape;
// @@protoc_insertion_point(field_set_allocated:caffe.ParameterParameter.shape)
}
// -------------------------------------------------------------------
// PermuteParameter
// repeated uint32 order = 1;
inline int PermuteParameter::_internal_order_size() const {
return order_.size();
}
inline int PermuteParameter::order_size() const {
return _internal_order_size();
}
inline void PermuteParameter::clear_order() {
order_.Clear();
}
inline uint32_t PermuteParameter::_internal_order(int index) const {
return order_.Get(index);
}
inline uint32_t PermuteParameter::order(int index) const {
// @@protoc_insertion_point(field_get:caffe.PermuteParameter.order)
return _internal_order(index);
}
inline void PermuteParameter::set_order(int index, uint32_t value) {
order_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.PermuteParameter.order)
}
inline void PermuteParameter::_internal_add_order(uint32_t value) {
order_.Add(value);
}
inline void PermuteParameter::add_order(uint32_t value) {
_internal_add_order(value);
// @@protoc_insertion_point(field_add:caffe.PermuteParameter.order)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
PermuteParameter::_internal_order() const {
return order_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
PermuteParameter::order() const {
// @@protoc_insertion_point(field_list:caffe.PermuteParameter.order)
return _internal_order();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
PermuteParameter::_internal_mutable_order() {
return &order_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
PermuteParameter::mutable_order() {
// @@protoc_insertion_point(field_mutable_list:caffe.PermuteParameter.order)
return _internal_mutable_order();
}
// -------------------------------------------------------------------
// PoolingParameter
// optional bool avg_include_pad = 13 [default = true];
inline bool PoolingParameter::_internal_has_avg_include_pad() const {
bool value = (_has_bits_[0] & 0x00002000u) != 0;
return value;
}
inline bool PoolingParameter::has_avg_include_pad() const {
return _internal_has_avg_include_pad();
}
inline void PoolingParameter::clear_avg_include_pad() {
avg_include_pad_ = true;
_has_bits_[0] &= ~0x00002000u;
}
inline bool PoolingParameter::_internal_avg_include_pad() const {
return avg_include_pad_;
}
inline bool PoolingParameter::avg_include_pad() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.avg_include_pad)
return _internal_avg_include_pad();
}
inline void PoolingParameter::_internal_set_avg_include_pad(bool value) {
_has_bits_[0] |= 0x00002000u;
avg_include_pad_ = value;
}
inline void PoolingParameter::set_avg_include_pad(bool value) {
_internal_set_avg_include_pad(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.avg_include_pad)
}
// optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
inline bool PoolingParameter::_internal_has_pool() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool PoolingParameter::has_pool() const {
return _internal_has_pool();
}
inline void PoolingParameter::clear_pool() {
pool_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::PoolingParameter_PoolMethod PoolingParameter::_internal_pool() const {
return static_cast< ::caffe::PoolingParameter_PoolMethod >(pool_);
}
inline ::caffe::PoolingParameter_PoolMethod PoolingParameter::pool() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.pool)
return _internal_pool();
}
inline void PoolingParameter::_internal_set_pool(::caffe::PoolingParameter_PoolMethod value) {
assert(::caffe::PoolingParameter_PoolMethod_IsValid(value));
_has_bits_[0] |= 0x00000001u;
pool_ = value;
}
inline void PoolingParameter::set_pool(::caffe::PoolingParameter_PoolMethod value) {
_internal_set_pool(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.pool)
}
// optional uint32 pad = 4 [default = 0];
inline bool PoolingParameter::_internal_has_pad() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool PoolingParameter::has_pad() const {
return _internal_has_pad();
}
inline void PoolingParameter::clear_pad() {
pad_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t PoolingParameter::_internal_pad() const {
return pad_;
}
inline uint32_t PoolingParameter::pad() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.pad)
return _internal_pad();
}
inline void PoolingParameter::_internal_set_pad(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
pad_ = value;
}
inline void PoolingParameter::set_pad(uint32_t value) {
_internal_set_pad(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.pad)
}
// optional uint32 pad_h = 9 [default = 0];
inline bool PoolingParameter::_internal_has_pad_h() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool PoolingParameter::has_pad_h() const {
return _internal_has_pad_h();
}
inline void PoolingParameter::clear_pad_h() {
pad_h_ = 0u;
_has_bits_[0] &= ~0x00000080u;
}
inline uint32_t PoolingParameter::_internal_pad_h() const {
return pad_h_;
}
inline uint32_t PoolingParameter::pad_h() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.pad_h)
return _internal_pad_h();
}
inline void PoolingParameter::_internal_set_pad_h(uint32_t value) {
_has_bits_[0] |= 0x00000080u;
pad_h_ = value;
}
inline void PoolingParameter::set_pad_h(uint32_t value) {
_internal_set_pad_h(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.pad_h)
}
// optional uint32 pad_w = 10 [default = 0];
inline bool PoolingParameter::_internal_has_pad_w() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool PoolingParameter::has_pad_w() const {
return _internal_has_pad_w();
}
inline void PoolingParameter::clear_pad_w() {
pad_w_ = 0u;
_has_bits_[0] &= ~0x00000100u;
}
inline uint32_t PoolingParameter::_internal_pad_w() const {
return pad_w_;
}
inline uint32_t PoolingParameter::pad_w() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.pad_w)
return _internal_pad_w();
}
inline void PoolingParameter::_internal_set_pad_w(uint32_t value) {
_has_bits_[0] |= 0x00000100u;
pad_w_ = value;
}
inline void PoolingParameter::set_pad_w(uint32_t value) {
_internal_set_pad_w(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.pad_w)
}
// optional uint32 kernel_size = 2;
inline bool PoolingParameter::_internal_has_kernel_size() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool PoolingParameter::has_kernel_size() const {
return _internal_has_kernel_size();
}
inline void PoolingParameter::clear_kernel_size() {
kernel_size_ = 0u;
_has_bits_[0] &= ~0x00000002u;
}
inline uint32_t PoolingParameter::_internal_kernel_size() const {
return kernel_size_;
}
inline uint32_t PoolingParameter::kernel_size() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.kernel_size)
return _internal_kernel_size();
}
inline void PoolingParameter::_internal_set_kernel_size(uint32_t value) {
_has_bits_[0] |= 0x00000002u;
kernel_size_ = value;
}
inline void PoolingParameter::set_kernel_size(uint32_t value) {
_internal_set_kernel_size(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.kernel_size)
}
// optional uint32 kernel_h = 5;
inline bool PoolingParameter::_internal_has_kernel_h() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool PoolingParameter::has_kernel_h() const {
return _internal_has_kernel_h();
}
inline void PoolingParameter::clear_kernel_h() {
kernel_h_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t PoolingParameter::_internal_kernel_h() const {
return kernel_h_;
}
inline uint32_t PoolingParameter::kernel_h() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.kernel_h)
return _internal_kernel_h();
}
inline void PoolingParameter::_internal_set_kernel_h(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
kernel_h_ = value;
}
inline void PoolingParameter::set_kernel_h(uint32_t value) {
_internal_set_kernel_h(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.kernel_h)
}
// optional uint32 kernel_w = 6;
inline bool PoolingParameter::_internal_has_kernel_w() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool PoolingParameter::has_kernel_w() const {
return _internal_has_kernel_w();
}
inline void PoolingParameter::clear_kernel_w() {
kernel_w_ = 0u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t PoolingParameter::_internal_kernel_w() const {
return kernel_w_;
}
inline uint32_t PoolingParameter::kernel_w() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.kernel_w)
return _internal_kernel_w();
}
inline void PoolingParameter::_internal_set_kernel_w(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
kernel_w_ = value;
}
inline void PoolingParameter::set_kernel_w(uint32_t value) {
_internal_set_kernel_w(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.kernel_w)
}
// optional uint32 stride = 3 [default = 1];
inline bool PoolingParameter::_internal_has_stride() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool PoolingParameter::has_stride() const {
return _internal_has_stride();
}
inline void PoolingParameter::clear_stride() {
stride_ = 1u;
_has_bits_[0] &= ~0x00001000u;
}
inline uint32_t PoolingParameter::_internal_stride() const {
return stride_;
}
inline uint32_t PoolingParameter::stride() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.stride)
return _internal_stride();
}
inline void PoolingParameter::_internal_set_stride(uint32_t value) {
_has_bits_[0] |= 0x00001000u;
stride_ = value;
}
inline void PoolingParameter::set_stride(uint32_t value) {
_internal_set_stride(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.stride)
}
// optional uint32 stride_h = 7;
inline bool PoolingParameter::_internal_has_stride_h() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool PoolingParameter::has_stride_h() const {
return _internal_has_stride_h();
}
inline void PoolingParameter::clear_stride_h() {
stride_h_ = 0u;
_has_bits_[0] &= ~0x00000020u;
}
inline uint32_t PoolingParameter::_internal_stride_h() const {
return stride_h_;
}
inline uint32_t PoolingParameter::stride_h() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.stride_h)
return _internal_stride_h();
}
inline void PoolingParameter::_internal_set_stride_h(uint32_t value) {
_has_bits_[0] |= 0x00000020u;
stride_h_ = value;
}
inline void PoolingParameter::set_stride_h(uint32_t value) {
_internal_set_stride_h(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.stride_h)
}
// optional uint32 stride_w = 8;
inline bool PoolingParameter::_internal_has_stride_w() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool PoolingParameter::has_stride_w() const {
return _internal_has_stride_w();
}
inline void PoolingParameter::clear_stride_w() {
stride_w_ = 0u;
_has_bits_[0] &= ~0x00000040u;
}
inline uint32_t PoolingParameter::_internal_stride_w() const {
return stride_w_;
}
inline uint32_t PoolingParameter::stride_w() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.stride_w)
return _internal_stride_w();
}
inline void PoolingParameter::_internal_set_stride_w(uint32_t value) {
_has_bits_[0] |= 0x00000040u;
stride_w_ = value;
}
inline void PoolingParameter::set_stride_w(uint32_t value) {
_internal_set_stride_w(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.stride_w)
}
// optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
inline bool PoolingParameter::_internal_has_engine() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool PoolingParameter::has_engine() const {
return _internal_has_engine();
}
inline void PoolingParameter::clear_engine() {
engine_ = 0;
_has_bits_[0] &= ~0x00000200u;
}
inline ::caffe::PoolingParameter_Engine PoolingParameter::_internal_engine() const {
return static_cast< ::caffe::PoolingParameter_Engine >(engine_);
}
inline ::caffe::PoolingParameter_Engine PoolingParameter::engine() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.engine)
return _internal_engine();
}
inline void PoolingParameter::_internal_set_engine(::caffe::PoolingParameter_Engine value) {
assert(::caffe::PoolingParameter_Engine_IsValid(value));
_has_bits_[0] |= 0x00000200u;
engine_ = value;
}
inline void PoolingParameter::set_engine(::caffe::PoolingParameter_Engine value) {
_internal_set_engine(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.engine)
}
// optional bool global_pooling = 12 [default = false];
inline bool PoolingParameter::_internal_has_global_pooling() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool PoolingParameter::has_global_pooling() const {
return _internal_has_global_pooling();
}
inline void PoolingParameter::clear_global_pooling() {
global_pooling_ = false;
_has_bits_[0] &= ~0x00000400u;
}
inline bool PoolingParameter::_internal_global_pooling() const {
return global_pooling_;
}
inline bool PoolingParameter::global_pooling() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.global_pooling)
return _internal_global_pooling();
}
inline void PoolingParameter::_internal_set_global_pooling(bool value) {
_has_bits_[0] |= 0x00000400u;
global_pooling_ = value;
}
inline void PoolingParameter::set_global_pooling(bool value) {
_internal_set_global_pooling(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.global_pooling)
}
// optional .caffe.PoolingParameter.RoundMode round_mode = 14 [default = CEIL];
inline bool PoolingParameter::_internal_has_round_mode() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool PoolingParameter::has_round_mode() const {
return _internal_has_round_mode();
}
inline void PoolingParameter::clear_round_mode() {
round_mode_ = 0;
_has_bits_[0] &= ~0x00000800u;
}
inline ::caffe::PoolingParameter_RoundMode PoolingParameter::_internal_round_mode() const {
return static_cast< ::caffe::PoolingParameter_RoundMode >(round_mode_);
}
inline ::caffe::PoolingParameter_RoundMode PoolingParameter::round_mode() const {
// @@protoc_insertion_point(field_get:caffe.PoolingParameter.round_mode)
return _internal_round_mode();
}
inline void PoolingParameter::_internal_set_round_mode(::caffe::PoolingParameter_RoundMode value) {
assert(::caffe::PoolingParameter_RoundMode_IsValid(value));
_has_bits_[0] |= 0x00000800u;
round_mode_ = value;
}
inline void PoolingParameter::set_round_mode(::caffe::PoolingParameter_RoundMode value) {
_internal_set_round_mode(value);
// @@protoc_insertion_point(field_set:caffe.PoolingParameter.round_mode)
}
// -------------------------------------------------------------------
// Pooling3DParameter
// optional .caffe.Pooling3DParameter.PoolMethod pool = 1 [default = MAX];
inline bool Pooling3DParameter::_internal_has_pool() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool Pooling3DParameter::has_pool() const {
return _internal_has_pool();
}
inline void Pooling3DParameter::clear_pool() {
pool_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::Pooling3DParameter_PoolMethod Pooling3DParameter::_internal_pool() const {
return static_cast< ::caffe::Pooling3DParameter_PoolMethod >(pool_);
}
inline ::caffe::Pooling3DParameter_PoolMethod Pooling3DParameter::pool() const {
// @@protoc_insertion_point(field_get:caffe.Pooling3DParameter.pool)
return _internal_pool();
}
inline void Pooling3DParameter::_internal_set_pool(::caffe::Pooling3DParameter_PoolMethod value) {
assert(::caffe::Pooling3DParameter_PoolMethod_IsValid(value));
_has_bits_[0] |= 0x00000001u;
pool_ = value;
}
inline void Pooling3DParameter::set_pool(::caffe::Pooling3DParameter_PoolMethod value) {
_internal_set_pool(value);
// @@protoc_insertion_point(field_set:caffe.Pooling3DParameter.pool)
}
// optional uint32 kernel_size = 2;
inline bool Pooling3DParameter::_internal_has_kernel_size() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool Pooling3DParameter::has_kernel_size() const {
return _internal_has_kernel_size();
}
inline void Pooling3DParameter::clear_kernel_size() {
kernel_size_ = 0u;
_has_bits_[0] &= ~0x00000002u;
}
inline uint32_t Pooling3DParameter::_internal_kernel_size() const {
return kernel_size_;
}
inline uint32_t Pooling3DParameter::kernel_size() const {
// @@protoc_insertion_point(field_get:caffe.Pooling3DParameter.kernel_size)
return _internal_kernel_size();
}
inline void Pooling3DParameter::_internal_set_kernel_size(uint32_t value) {
_has_bits_[0] |= 0x00000002u;
kernel_size_ = value;
}
inline void Pooling3DParameter::set_kernel_size(uint32_t value) {
_internal_set_kernel_size(value);
// @@protoc_insertion_point(field_set:caffe.Pooling3DParameter.kernel_size)
}
// optional uint32 kernel_depth = 3;
inline bool Pooling3DParameter::_internal_has_kernel_depth() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool Pooling3DParameter::has_kernel_depth() const {
return _internal_has_kernel_depth();
}
inline void Pooling3DParameter::clear_kernel_depth() {
kernel_depth_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t Pooling3DParameter::_internal_kernel_depth() const {
return kernel_depth_;
}
inline uint32_t Pooling3DParameter::kernel_depth() const {
// @@protoc_insertion_point(field_get:caffe.Pooling3DParameter.kernel_depth)
return _internal_kernel_depth();
}
inline void Pooling3DParameter::_internal_set_kernel_depth(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
kernel_depth_ = value;
}
inline void Pooling3DParameter::set_kernel_depth(uint32_t value) {
_internal_set_kernel_depth(value);
// @@protoc_insertion_point(field_set:caffe.Pooling3DParameter.kernel_depth)
}
// optional uint32 stride = 4 [default = 1];
inline bool Pooling3DParameter::_internal_has_stride() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool Pooling3DParameter::has_stride() const {
return _internal_has_stride();
}
inline void Pooling3DParameter::clear_stride() {
stride_ = 1u;
_has_bits_[0] &= ~0x00000020u;
}
inline uint32_t Pooling3DParameter::_internal_stride() const {
return stride_;
}
inline uint32_t Pooling3DParameter::stride() const {
// @@protoc_insertion_point(field_get:caffe.Pooling3DParameter.stride)
return _internal_stride();
}
inline void Pooling3DParameter::_internal_set_stride(uint32_t value) {
_has_bits_[0] |= 0x00000020u;
stride_ = value;
}
inline void Pooling3DParameter::set_stride(uint32_t value) {
_internal_set_stride(value);
// @@protoc_insertion_point(field_set:caffe.Pooling3DParameter.stride)
}
// optional uint32 temporal_stride = 5 [default = 1];
inline bool Pooling3DParameter::_internal_has_temporal_stride() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool Pooling3DParameter::has_temporal_stride() const {
return _internal_has_temporal_stride();
}
inline void Pooling3DParameter::clear_temporal_stride() {
temporal_stride_ = 1u;
_has_bits_[0] &= ~0x00000040u;
}
inline uint32_t Pooling3DParameter::_internal_temporal_stride() const {
return temporal_stride_;
}
inline uint32_t Pooling3DParameter::temporal_stride() const {
// @@protoc_insertion_point(field_get:caffe.Pooling3DParameter.temporal_stride)
return _internal_temporal_stride();
}
inline void Pooling3DParameter::_internal_set_temporal_stride(uint32_t value) {
_has_bits_[0] |= 0x00000040u;
temporal_stride_ = value;
}
inline void Pooling3DParameter::set_temporal_stride(uint32_t value) {
_internal_set_temporal_stride(value);
// @@protoc_insertion_point(field_set:caffe.Pooling3DParameter.temporal_stride)
}
// optional uint32 pad = 6 [default = 0];
inline bool Pooling3DParameter::_internal_has_pad() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool Pooling3DParameter::has_pad() const {
return _internal_has_pad();
}
inline void Pooling3DParameter::clear_pad() {
pad_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Pooling3DParameter::_internal_pad() const {
return pad_;
}
inline uint32_t Pooling3DParameter::pad() const {
// @@protoc_insertion_point(field_get:caffe.Pooling3DParameter.pad)
return _internal_pad();
}
inline void Pooling3DParameter::_internal_set_pad(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
pad_ = value;
}
inline void Pooling3DParameter::set_pad(uint32_t value) {
_internal_set_pad(value);
// @@protoc_insertion_point(field_set:caffe.Pooling3DParameter.pad)
}
// optional uint32 temporal_pad = 7 [default = 0];
inline bool Pooling3DParameter::_internal_has_temporal_pad() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool Pooling3DParameter::has_temporal_pad() const {
return _internal_has_temporal_pad();
}
inline void Pooling3DParameter::clear_temporal_pad() {
temporal_pad_ = 0u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t Pooling3DParameter::_internal_temporal_pad() const {
return temporal_pad_;
}
inline uint32_t Pooling3DParameter::temporal_pad() const {
// @@protoc_insertion_point(field_get:caffe.Pooling3DParameter.temporal_pad)
return _internal_temporal_pad();
}
inline void Pooling3DParameter::_internal_set_temporal_pad(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
temporal_pad_ = value;
}
inline void Pooling3DParameter::set_temporal_pad(uint32_t value) {
_internal_set_temporal_pad(value);
// @@protoc_insertion_point(field_set:caffe.Pooling3DParameter.temporal_pad)
}
// -------------------------------------------------------------------
// PowerParameter
// optional float power = 1 [default = 1];
inline bool PowerParameter::_internal_has_power() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool PowerParameter::has_power() const {
return _internal_has_power();
}
inline void PowerParameter::clear_power() {
power_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline float PowerParameter::_internal_power() const {
return power_;
}
inline float PowerParameter::power() const {
// @@protoc_insertion_point(field_get:caffe.PowerParameter.power)
return _internal_power();
}
inline void PowerParameter::_internal_set_power(float value) {
_has_bits_[0] |= 0x00000002u;
power_ = value;
}
inline void PowerParameter::set_power(float value) {
_internal_set_power(value);
// @@protoc_insertion_point(field_set:caffe.PowerParameter.power)
}
// optional float scale = 2 [default = 1];
inline bool PowerParameter::_internal_has_scale() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool PowerParameter::has_scale() const {
return _internal_has_scale();
}
inline void PowerParameter::clear_scale() {
scale_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline float PowerParameter::_internal_scale() const {
return scale_;
}
inline float PowerParameter::scale() const {
// @@protoc_insertion_point(field_get:caffe.PowerParameter.scale)
return _internal_scale();
}
inline void PowerParameter::_internal_set_scale(float value) {
_has_bits_[0] |= 0x00000004u;
scale_ = value;
}
inline void PowerParameter::set_scale(float value) {
_internal_set_scale(value);
// @@protoc_insertion_point(field_set:caffe.PowerParameter.scale)
}
// optional float shift = 3 [default = 0];
inline bool PowerParameter::_internal_has_shift() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool PowerParameter::has_shift() const {
return _internal_has_shift();
}
inline void PowerParameter::clear_shift() {
shift_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float PowerParameter::_internal_shift() const {
return shift_;
}
inline float PowerParameter::shift() const {
// @@protoc_insertion_point(field_get:caffe.PowerParameter.shift)
return _internal_shift();
}
inline void PowerParameter::_internal_set_shift(float value) {
_has_bits_[0] |= 0x00000001u;
shift_ = value;
}
inline void PowerParameter::set_shift(float value) {
_internal_set_shift(value);
// @@protoc_insertion_point(field_set:caffe.PowerParameter.shift)
}
// -------------------------------------------------------------------
// PriorBoxParameter
// repeated float min_size = 1;
inline int PriorBoxParameter::_internal_min_size_size() const {
return min_size_.size();
}
inline int PriorBoxParameter::min_size_size() const {
return _internal_min_size_size();
}
inline void PriorBoxParameter::clear_min_size() {
min_size_.Clear();
}
inline float PriorBoxParameter::_internal_min_size(int index) const {
return min_size_.Get(index);
}
inline float PriorBoxParameter::min_size(int index) const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.min_size)
return _internal_min_size(index);
}
inline void PriorBoxParameter::set_min_size(int index, float value) {
min_size_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.min_size)
}
inline void PriorBoxParameter::_internal_add_min_size(float value) {
min_size_.Add(value);
}
inline void PriorBoxParameter::add_min_size(float value) {
_internal_add_min_size(value);
// @@protoc_insertion_point(field_add:caffe.PriorBoxParameter.min_size)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_min_size() const {
return min_size_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::min_size() const {
// @@protoc_insertion_point(field_list:caffe.PriorBoxParameter.min_size)
return _internal_min_size();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_min_size() {
return &min_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_min_size() {
// @@protoc_insertion_point(field_mutable_list:caffe.PriorBoxParameter.min_size)
return _internal_mutable_min_size();
}
// repeated float max_size = 2;
inline int PriorBoxParameter::_internal_max_size_size() const {
return max_size_.size();
}
inline int PriorBoxParameter::max_size_size() const {
return _internal_max_size_size();
}
inline void PriorBoxParameter::clear_max_size() {
max_size_.Clear();
}
inline float PriorBoxParameter::_internal_max_size(int index) const {
return max_size_.Get(index);
}
inline float PriorBoxParameter::max_size(int index) const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.max_size)
return _internal_max_size(index);
}
inline void PriorBoxParameter::set_max_size(int index, float value) {
max_size_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.max_size)
}
inline void PriorBoxParameter::_internal_add_max_size(float value) {
max_size_.Add(value);
}
inline void PriorBoxParameter::add_max_size(float value) {
_internal_add_max_size(value);
// @@protoc_insertion_point(field_add:caffe.PriorBoxParameter.max_size)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_max_size() const {
return max_size_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::max_size() const {
// @@protoc_insertion_point(field_list:caffe.PriorBoxParameter.max_size)
return _internal_max_size();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_max_size() {
return &max_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_max_size() {
// @@protoc_insertion_point(field_mutable_list:caffe.PriorBoxParameter.max_size)
return _internal_mutable_max_size();
}
// repeated float aspect_ratio = 3;
inline int PriorBoxParameter::_internal_aspect_ratio_size() const {
return aspect_ratio_.size();
}
inline int PriorBoxParameter::aspect_ratio_size() const {
return _internal_aspect_ratio_size();
}
inline void PriorBoxParameter::clear_aspect_ratio() {
aspect_ratio_.Clear();
}
inline float PriorBoxParameter::_internal_aspect_ratio(int index) const {
return aspect_ratio_.Get(index);
}
inline float PriorBoxParameter::aspect_ratio(int index) const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.aspect_ratio)
return _internal_aspect_ratio(index);
}
inline void PriorBoxParameter::set_aspect_ratio(int index, float value) {
aspect_ratio_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.aspect_ratio)
}
inline void PriorBoxParameter::_internal_add_aspect_ratio(float value) {
aspect_ratio_.Add(value);
}
inline void PriorBoxParameter::add_aspect_ratio(float value) {
_internal_add_aspect_ratio(value);
// @@protoc_insertion_point(field_add:caffe.PriorBoxParameter.aspect_ratio)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_aspect_ratio() const {
return aspect_ratio_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::aspect_ratio() const {
// @@protoc_insertion_point(field_list:caffe.PriorBoxParameter.aspect_ratio)
return _internal_aspect_ratio();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_aspect_ratio() {
return &aspect_ratio_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_aspect_ratio() {
// @@protoc_insertion_point(field_mutable_list:caffe.PriorBoxParameter.aspect_ratio)
return _internal_mutable_aspect_ratio();
}
// optional bool flip = 4 [default = true];
inline bool PriorBoxParameter::_internal_has_flip() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool PriorBoxParameter::has_flip() const {
return _internal_has_flip();
}
inline void PriorBoxParameter::clear_flip() {
flip_ = true;
_has_bits_[0] &= ~0x00000080u;
}
inline bool PriorBoxParameter::_internal_flip() const {
return flip_;
}
inline bool PriorBoxParameter::flip() const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.flip)
return _internal_flip();
}
inline void PriorBoxParameter::_internal_set_flip(bool value) {
_has_bits_[0] |= 0x00000080u;
flip_ = value;
}
inline void PriorBoxParameter::set_flip(bool value) {
_internal_set_flip(value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.flip)
}
// optional bool clip = 5 [default = false];
inline bool PriorBoxParameter::_internal_has_clip() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool PriorBoxParameter::has_clip() const {
return _internal_has_clip();
}
inline void PriorBoxParameter::clear_clip() {
clip_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool PriorBoxParameter::_internal_clip() const {
return clip_;
}
inline bool PriorBoxParameter::clip() const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.clip)
return _internal_clip();
}
inline void PriorBoxParameter::_internal_set_clip(bool value) {
_has_bits_[0] |= 0x00000001u;
clip_ = value;
}
inline void PriorBoxParameter::set_clip(bool value) {
_internal_set_clip(value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.clip)
}
// repeated float variance = 6;
inline int PriorBoxParameter::_internal_variance_size() const {
return variance_.size();
}
inline int PriorBoxParameter::variance_size() const {
return _internal_variance_size();
}
inline void PriorBoxParameter::clear_variance() {
variance_.Clear();
}
inline float PriorBoxParameter::_internal_variance(int index) const {
return variance_.Get(index);
}
inline float PriorBoxParameter::variance(int index) const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.variance)
return _internal_variance(index);
}
inline void PriorBoxParameter::set_variance(int index, float value) {
variance_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.variance)
}
inline void PriorBoxParameter::_internal_add_variance(float value) {
variance_.Add(value);
}
inline void PriorBoxParameter::add_variance(float value) {
_internal_add_variance(value);
// @@protoc_insertion_point(field_add:caffe.PriorBoxParameter.variance)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_variance() const {
return variance_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::variance() const {
// @@protoc_insertion_point(field_list:caffe.PriorBoxParameter.variance)
return _internal_variance();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_variance() {
return &variance_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_variance() {
// @@protoc_insertion_point(field_mutable_list:caffe.PriorBoxParameter.variance)
return _internal_mutable_variance();
}
// optional uint32 img_size = 7;
inline bool PriorBoxParameter::_internal_has_img_size() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool PriorBoxParameter::has_img_size() const {
return _internal_has_img_size();
}
inline void PriorBoxParameter::clear_img_size() {
img_size_ = 0u;
_has_bits_[0] &= ~0x00000002u;
}
inline uint32_t PriorBoxParameter::_internal_img_size() const {
return img_size_;
}
inline uint32_t PriorBoxParameter::img_size() const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.img_size)
return _internal_img_size();
}
inline void PriorBoxParameter::_internal_set_img_size(uint32_t value) {
_has_bits_[0] |= 0x00000002u;
img_size_ = value;
}
inline void PriorBoxParameter::set_img_size(uint32_t value) {
_internal_set_img_size(value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.img_size)
}
// optional uint32 img_h = 8;
inline bool PriorBoxParameter::_internal_has_img_h() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool PriorBoxParameter::has_img_h() const {
return _internal_has_img_h();
}
inline void PriorBoxParameter::clear_img_h() {
img_h_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t PriorBoxParameter::_internal_img_h() const {
return img_h_;
}
inline uint32_t PriorBoxParameter::img_h() const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.img_h)
return _internal_img_h();
}
inline void PriorBoxParameter::_internal_set_img_h(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
img_h_ = value;
}
inline void PriorBoxParameter::set_img_h(uint32_t value) {
_internal_set_img_h(value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.img_h)
}
// optional uint32 img_w = 9;
inline bool PriorBoxParameter::_internal_has_img_w() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool PriorBoxParameter::has_img_w() const {
return _internal_has_img_w();
}
inline void PriorBoxParameter::clear_img_w() {
img_w_ = 0u;
_has_bits_[0] &= ~0x00000008u;
}
inline uint32_t PriorBoxParameter::_internal_img_w() const {
return img_w_;
}
inline uint32_t PriorBoxParameter::img_w() const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.img_w)
return _internal_img_w();
}
inline void PriorBoxParameter::_internal_set_img_w(uint32_t value) {
_has_bits_[0] |= 0x00000008u;
img_w_ = value;
}
inline void PriorBoxParameter::set_img_w(uint32_t value) {
_internal_set_img_w(value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.img_w)
}
// optional float step = 10;
inline bool PriorBoxParameter::_internal_has_step() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool PriorBoxParameter::has_step() const {
return _internal_has_step();
}
inline void PriorBoxParameter::clear_step() {
step_ = 0;
_has_bits_[0] &= ~0x00000010u;
}
inline float PriorBoxParameter::_internal_step() const {
return step_;
}
inline float PriorBoxParameter::step() const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.step)
return _internal_step();
}
inline void PriorBoxParameter::_internal_set_step(float value) {
_has_bits_[0] |= 0x00000010u;
step_ = value;
}
inline void PriorBoxParameter::set_step(float value) {
_internal_set_step(value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.step)
}
// optional float step_h = 11;
inline bool PriorBoxParameter::_internal_has_step_h() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool PriorBoxParameter::has_step_h() const {
return _internal_has_step_h();
}
inline void PriorBoxParameter::clear_step_h() {
step_h_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline float PriorBoxParameter::_internal_step_h() const {
return step_h_;
}
inline float PriorBoxParameter::step_h() const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.step_h)
return _internal_step_h();
}
inline void PriorBoxParameter::_internal_set_step_h(float value) {
_has_bits_[0] |= 0x00000020u;
step_h_ = value;
}
inline void PriorBoxParameter::set_step_h(float value) {
_internal_set_step_h(value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.step_h)
}
// optional float step_w = 12;
inline bool PriorBoxParameter::_internal_has_step_w() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool PriorBoxParameter::has_step_w() const {
return _internal_has_step_w();
}
inline void PriorBoxParameter::clear_step_w() {
step_w_ = 0;
_has_bits_[0] &= ~0x00000040u;
}
inline float PriorBoxParameter::_internal_step_w() const {
return step_w_;
}
inline float PriorBoxParameter::step_w() const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.step_w)
return _internal_step_w();
}
inline void PriorBoxParameter::_internal_set_step_w(float value) {
_has_bits_[0] |= 0x00000040u;
step_w_ = value;
}
inline void PriorBoxParameter::set_step_w(float value) {
_internal_set_step_w(value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.step_w)
}
// optional float offset = 13 [default = 0.5];
inline bool PriorBoxParameter::_internal_has_offset() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool PriorBoxParameter::has_offset() const {
return _internal_has_offset();
}
inline void PriorBoxParameter::clear_offset() {
offset_ = 0.5f;
_has_bits_[0] &= ~0x00000100u;
}
inline float PriorBoxParameter::_internal_offset() const {
return offset_;
}
inline float PriorBoxParameter::offset() const {
// @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.offset)
return _internal_offset();
}
inline void PriorBoxParameter::_internal_set_offset(float value) {
_has_bits_[0] |= 0x00000100u;
offset_ = value;
}
inline void PriorBoxParameter::set_offset(float value) {
_internal_set_offset(value);
// @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.offset)
}
// -------------------------------------------------------------------
// PythonParameter
// optional string module = 1;
inline bool PythonParameter::_internal_has_module() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool PythonParameter::has_module() const {
return _internal_has_module();
}
inline void PythonParameter::clear_module() {
module_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PythonParameter::module() const {
// @@protoc_insertion_point(field_get:caffe.PythonParameter.module)
return _internal_module();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PythonParameter::set_module(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
module_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.PythonParameter.module)
}
inline std::string* PythonParameter::mutable_module() {
std::string* _s = _internal_mutable_module();
// @@protoc_insertion_point(field_mutable:caffe.PythonParameter.module)
return _s;
}
inline const std::string& PythonParameter::_internal_module() const {
return module_.Get();
}
inline void PythonParameter::_internal_set_module(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
module_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* PythonParameter::_internal_mutable_module() {
_has_bits_[0] |= 0x00000001u;
return module_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* PythonParameter::release_module() {
// @@protoc_insertion_point(field_release:caffe.PythonParameter.module)
if (!_internal_has_module()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = module_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (module_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void PythonParameter::set_allocated_module(std::string* module) {
if (module != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
module_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), module,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (module_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.PythonParameter.module)
}
// optional string layer = 2;
inline bool PythonParameter::_internal_has_layer() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool PythonParameter::has_layer() const {
return _internal_has_layer();
}
inline void PythonParameter::clear_layer() {
layer_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PythonParameter::layer() const {
// @@protoc_insertion_point(field_get:caffe.PythonParameter.layer)
return _internal_layer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PythonParameter::set_layer(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
layer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.PythonParameter.layer)
}
inline std::string* PythonParameter::mutable_layer() {
std::string* _s = _internal_mutable_layer();
// @@protoc_insertion_point(field_mutable:caffe.PythonParameter.layer)
return _s;
}
inline const std::string& PythonParameter::_internal_layer() const {
return layer_.Get();
}
inline void PythonParameter::_internal_set_layer(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
layer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* PythonParameter::_internal_mutable_layer() {
_has_bits_[0] |= 0x00000002u;
return layer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* PythonParameter::release_layer() {
// @@protoc_insertion_point(field_release:caffe.PythonParameter.layer)
if (!_internal_has_layer()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = layer_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (layer_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
layer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void PythonParameter::set_allocated_layer(std::string* layer) {
if (layer != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
layer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), layer,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (layer_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
layer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.PythonParameter.layer)
}
// optional string param_str = 3 [default = ""];
inline bool PythonParameter::_internal_has_param_str() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool PythonParameter::has_param_str() const {
return _internal_has_param_str();
}
inline void PythonParameter::clear_param_str() {
param_str_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& PythonParameter::param_str() const {
// @@protoc_insertion_point(field_get:caffe.PythonParameter.param_str)
return _internal_param_str();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PythonParameter::set_param_str(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
param_str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.PythonParameter.param_str)
}
inline std::string* PythonParameter::mutable_param_str() {
std::string* _s = _internal_mutable_param_str();
// @@protoc_insertion_point(field_mutable:caffe.PythonParameter.param_str)
return _s;
}
inline const std::string& PythonParameter::_internal_param_str() const {
return param_str_.Get();
}
inline void PythonParameter::_internal_set_param_str(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
param_str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* PythonParameter::_internal_mutable_param_str() {
_has_bits_[0] |= 0x00000004u;
return param_str_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* PythonParameter::release_param_str() {
// @@protoc_insertion_point(field_release:caffe.PythonParameter.param_str)
if (!_internal_has_param_str()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = param_str_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (param_str_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
param_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void PythonParameter::set_allocated_param_str(std::string* param_str) {
if (param_str != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
param_str_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), param_str,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (param_str_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
param_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.PythonParameter.param_str)
}
// optional bool share_in_parallel = 4 [default = false];
inline bool PythonParameter::_internal_has_share_in_parallel() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool PythonParameter::has_share_in_parallel() const {
return _internal_has_share_in_parallel();
}
inline void PythonParameter::clear_share_in_parallel() {
share_in_parallel_ = false;
_has_bits_[0] &= ~0x00000008u;
}
inline bool PythonParameter::_internal_share_in_parallel() const {
return share_in_parallel_;
}
inline bool PythonParameter::share_in_parallel() const {
// @@protoc_insertion_point(field_get:caffe.PythonParameter.share_in_parallel)
return _internal_share_in_parallel();
}
inline void PythonParameter::_internal_set_share_in_parallel(bool value) {
_has_bits_[0] |= 0x00000008u;
share_in_parallel_ = value;
}
inline void PythonParameter::set_share_in_parallel(bool value) {
_internal_set_share_in_parallel(value);
// @@protoc_insertion_point(field_set:caffe.PythonParameter.share_in_parallel)
}
// -------------------------------------------------------------------
// RecurrentParameter
// optional uint32 num_output = 1 [default = 0];
inline bool RecurrentParameter::_internal_has_num_output() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool RecurrentParameter::has_num_output() const {
return _internal_has_num_output();
}
inline void RecurrentParameter::clear_num_output() {
num_output_ = 0u;
_has_bits_[0] &= ~0x00000004u;
}
inline uint32_t RecurrentParameter::_internal_num_output() const {
return num_output_;
}
inline uint32_t RecurrentParameter::num_output() const {
// @@protoc_insertion_point(field_get:caffe.RecurrentParameter.num_output)
return _internal_num_output();
}
inline void RecurrentParameter::_internal_set_num_output(uint32_t value) {
_has_bits_[0] |= 0x00000004u;
num_output_ = value;
}
inline void RecurrentParameter::set_num_output(uint32_t value) {
_internal_set_num_output(value);
// @@protoc_insertion_point(field_set:caffe.RecurrentParameter.num_output)
}
// optional .caffe.FillerParameter weight_filler = 2;
inline bool RecurrentParameter::_internal_has_weight_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || weight_filler_ != nullptr);
return value;
}
inline bool RecurrentParameter::has_weight_filler() const {
return _internal_has_weight_filler();
}
inline void RecurrentParameter::clear_weight_filler() {
if (weight_filler_ != nullptr) weight_filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& RecurrentParameter::_internal_weight_filler() const {
const ::caffe::FillerParameter* p = weight_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& RecurrentParameter::weight_filler() const {
// @@protoc_insertion_point(field_get:caffe.RecurrentParameter.weight_filler)
return _internal_weight_filler();
}
inline void RecurrentParameter::unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_);
}
weight_filler_ = weight_filler;
if (weight_filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.RecurrentParameter.weight_filler)
}
inline ::caffe::FillerParameter* RecurrentParameter::release_weight_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* RecurrentParameter::unsafe_arena_release_weight_filler() {
// @@protoc_insertion_point(field_release:caffe.RecurrentParameter.weight_filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* RecurrentParameter::_internal_mutable_weight_filler() {
_has_bits_[0] |= 0x00000001u;
if (weight_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
weight_filler_ = p;
}
return weight_filler_;
}
inline ::caffe::FillerParameter* RecurrentParameter::mutable_weight_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
// @@protoc_insertion_point(field_mutable:caffe.RecurrentParameter.weight_filler)
return _msg;
}
inline void RecurrentParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete weight_filler_;
}
if (weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(weight_filler);
if (message_arena != submessage_arena) {
weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.RecurrentParameter.weight_filler)
}
// optional .caffe.FillerParameter bias_filler = 3;
inline bool RecurrentParameter::_internal_has_bias_filler() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || bias_filler_ != nullptr);
return value;
}
inline bool RecurrentParameter::has_bias_filler() const {
return _internal_has_bias_filler();
}
inline void RecurrentParameter::clear_bias_filler() {
if (bias_filler_ != nullptr) bias_filler_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::FillerParameter& RecurrentParameter::_internal_bias_filler() const {
const ::caffe::FillerParameter* p = bias_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& RecurrentParameter::bias_filler() const {
// @@protoc_insertion_point(field_get:caffe.RecurrentParameter.bias_filler)
return _internal_bias_filler();
}
inline void RecurrentParameter::unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_);
}
bias_filler_ = bias_filler;
if (bias_filler) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.RecurrentParameter.bias_filler)
}
inline ::caffe::FillerParameter* RecurrentParameter::release_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* RecurrentParameter::unsafe_arena_release_bias_filler() {
// @@protoc_insertion_point(field_release:caffe.RecurrentParameter.bias_filler)
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* RecurrentParameter::_internal_mutable_bias_filler() {
_has_bits_[0] |= 0x00000002u;
if (bias_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
bias_filler_ = p;
}
return bias_filler_;
}
inline ::caffe::FillerParameter* RecurrentParameter::mutable_bias_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
// @@protoc_insertion_point(field_mutable:caffe.RecurrentParameter.bias_filler)
return _msg;
}
inline void RecurrentParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_filler_;
}
if (bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(bias_filler);
if (message_arena != submessage_arena) {
bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.RecurrentParameter.bias_filler)
}
// optional bool debug_info = 4 [default = false];
inline bool RecurrentParameter::_internal_has_debug_info() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool RecurrentParameter::has_debug_info() const {
return _internal_has_debug_info();
}
inline void RecurrentParameter::clear_debug_info() {
debug_info_ = false;
_has_bits_[0] &= ~0x00000008u;
}
inline bool RecurrentParameter::_internal_debug_info() const {
return debug_info_;
}
inline bool RecurrentParameter::debug_info() const {
// @@protoc_insertion_point(field_get:caffe.RecurrentParameter.debug_info)
return _internal_debug_info();
}
inline void RecurrentParameter::_internal_set_debug_info(bool value) {
_has_bits_[0] |= 0x00000008u;
debug_info_ = value;
}
inline void RecurrentParameter::set_debug_info(bool value) {
_internal_set_debug_info(value);
// @@protoc_insertion_point(field_set:caffe.RecurrentParameter.debug_info)
}
// optional bool expose_hidden = 5 [default = false];
inline bool RecurrentParameter::_internal_has_expose_hidden() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool RecurrentParameter::has_expose_hidden() const {
return _internal_has_expose_hidden();
}
inline void RecurrentParameter::clear_expose_hidden() {
expose_hidden_ = false;
_has_bits_[0] &= ~0x00000010u;
}
inline bool RecurrentParameter::_internal_expose_hidden() const {
return expose_hidden_;
}
inline bool RecurrentParameter::expose_hidden() const {
// @@protoc_insertion_point(field_get:caffe.RecurrentParameter.expose_hidden)
return _internal_expose_hidden();
}
inline void RecurrentParameter::_internal_set_expose_hidden(bool value) {
_has_bits_[0] |= 0x00000010u;
expose_hidden_ = value;
}
inline void RecurrentParameter::set_expose_hidden(bool value) {
_internal_set_expose_hidden(value);
// @@protoc_insertion_point(field_set:caffe.RecurrentParameter.expose_hidden)
}
// -------------------------------------------------------------------
// ReductionParameter
// optional .caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
inline bool ReductionParameter::_internal_has_operation() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ReductionParameter::has_operation() const {
return _internal_has_operation();
}
inline void ReductionParameter::clear_operation() {
operation_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline ::caffe::ReductionParameter_ReductionOp ReductionParameter::_internal_operation() const {
return static_cast< ::caffe::ReductionParameter_ReductionOp >(operation_);
}
inline ::caffe::ReductionParameter_ReductionOp ReductionParameter::operation() const {
// @@protoc_insertion_point(field_get:caffe.ReductionParameter.operation)
return _internal_operation();
}
inline void ReductionParameter::_internal_set_operation(::caffe::ReductionParameter_ReductionOp value) {
assert(::caffe::ReductionParameter_ReductionOp_IsValid(value));
_has_bits_[0] |= 0x00000002u;
operation_ = value;
}
inline void ReductionParameter::set_operation(::caffe::ReductionParameter_ReductionOp value) {
_internal_set_operation(value);
// @@protoc_insertion_point(field_set:caffe.ReductionParameter.operation)
}
// optional int32 axis = 2 [default = 0];
inline bool ReductionParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ReductionParameter::has_axis() const {
return _internal_has_axis();
}
inline void ReductionParameter::clear_axis() {
axis_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t ReductionParameter::_internal_axis() const {
return axis_;
}
inline int32_t ReductionParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.ReductionParameter.axis)
return _internal_axis();
}
inline void ReductionParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000001u;
axis_ = value;
}
inline void ReductionParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.ReductionParameter.axis)
}
// optional float coeff = 3 [default = 1];
inline bool ReductionParameter::_internal_has_coeff() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ReductionParameter::has_coeff() const {
return _internal_has_coeff();
}
inline void ReductionParameter::clear_coeff() {
coeff_ = 1;
_has_bits_[0] &= ~0x00000004u;
}
inline float ReductionParameter::_internal_coeff() const {
return coeff_;
}
inline float ReductionParameter::coeff() const {
// @@protoc_insertion_point(field_get:caffe.ReductionParameter.coeff)
return _internal_coeff();
}
inline void ReductionParameter::_internal_set_coeff(float value) {
_has_bits_[0] |= 0x00000004u;
coeff_ = value;
}
inline void ReductionParameter::set_coeff(float value) {
_internal_set_coeff(value);
// @@protoc_insertion_point(field_set:caffe.ReductionParameter.coeff)
}
// -------------------------------------------------------------------
// ReLUParameter
// optional float negative_slope = 1 [default = 0];
inline bool ReLUParameter::_internal_has_negative_slope() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ReLUParameter::has_negative_slope() const {
return _internal_has_negative_slope();
}
inline void ReLUParameter::clear_negative_slope() {
negative_slope_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float ReLUParameter::_internal_negative_slope() const {
return negative_slope_;
}
inline float ReLUParameter::negative_slope() const {
// @@protoc_insertion_point(field_get:caffe.ReLUParameter.negative_slope)
return _internal_negative_slope();
}
inline void ReLUParameter::_internal_set_negative_slope(float value) {
_has_bits_[0] |= 0x00000001u;
negative_slope_ = value;
}
inline void ReLUParameter::set_negative_slope(float value) {
_internal_set_negative_slope(value);
// @@protoc_insertion_point(field_set:caffe.ReLUParameter.negative_slope)
}
// optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
inline bool ReLUParameter::_internal_has_engine() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ReLUParameter::has_engine() const {
return _internal_has_engine();
}
inline void ReLUParameter::clear_engine() {
engine_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::caffe::ReLUParameter_Engine ReLUParameter::_internal_engine() const {
return static_cast< ::caffe::ReLUParameter_Engine >(engine_);
}
inline ::caffe::ReLUParameter_Engine ReLUParameter::engine() const {
// @@protoc_insertion_point(field_get:caffe.ReLUParameter.engine)
return _internal_engine();
}
inline void ReLUParameter::_internal_set_engine(::caffe::ReLUParameter_Engine value) {
assert(::caffe::ReLUParameter_Engine_IsValid(value));
_has_bits_[0] |= 0x00000002u;
engine_ = value;
}
inline void ReLUParameter::set_engine(::caffe::ReLUParameter_Engine value) {
_internal_set_engine(value);
// @@protoc_insertion_point(field_set:caffe.ReLUParameter.engine)
}
// -------------------------------------------------------------------
// ReshapeParameter
// optional .caffe.BlobShape shape = 1;
inline bool ReshapeParameter::_internal_has_shape() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || shape_ != nullptr);
return value;
}
inline bool ReshapeParameter::has_shape() const {
return _internal_has_shape();
}
inline void ReshapeParameter::clear_shape() {
if (shape_ != nullptr) shape_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::BlobShape& ReshapeParameter::_internal_shape() const {
const ::caffe::BlobShape* p = shape_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::BlobShape&>(
::caffe::_BlobShape_default_instance_);
}
inline const ::caffe::BlobShape& ReshapeParameter::shape() const {
// @@protoc_insertion_point(field_get:caffe.ReshapeParameter.shape)
return _internal_shape();
}
inline void ReshapeParameter::unsafe_arena_set_allocated_shape(
::caffe::BlobShape* shape) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
}
shape_ = shape;
if (shape) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.ReshapeParameter.shape)
}
inline ::caffe::BlobShape* ReshapeParameter::release_shape() {
_has_bits_[0] &= ~0x00000001u;
::caffe::BlobShape* temp = shape_;
shape_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::BlobShape* ReshapeParameter::unsafe_arena_release_shape() {
// @@protoc_insertion_point(field_release:caffe.ReshapeParameter.shape)
_has_bits_[0] &= ~0x00000001u;
::caffe::BlobShape* temp = shape_;
shape_ = nullptr;
return temp;
}
inline ::caffe::BlobShape* ReshapeParameter::_internal_mutable_shape() {
_has_bits_[0] |= 0x00000001u;
if (shape_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::BlobShape>(GetArenaForAllocation());
shape_ = p;
}
return shape_;
}
inline ::caffe::BlobShape* ReshapeParameter::mutable_shape() {
::caffe::BlobShape* _msg = _internal_mutable_shape();
// @@protoc_insertion_point(field_mutable:caffe.ReshapeParameter.shape)
return _msg;
}
inline void ReshapeParameter::set_allocated_shape(::caffe::BlobShape* shape) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete shape_;
}
if (shape) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::BlobShape>::GetOwningArena(shape);
if (message_arena != submessage_arena) {
shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, shape, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
shape_ = shape;
// @@protoc_insertion_point(field_set_allocated:caffe.ReshapeParameter.shape)
}
// optional int32 axis = 2 [default = 0];
inline bool ReshapeParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ReshapeParameter::has_axis() const {
return _internal_has_axis();
}
inline void ReshapeParameter::clear_axis() {
axis_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t ReshapeParameter::_internal_axis() const {
return axis_;
}
inline int32_t ReshapeParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.ReshapeParameter.axis)
return _internal_axis();
}
inline void ReshapeParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000002u;
axis_ = value;
}
inline void ReshapeParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.ReshapeParameter.axis)
}
// optional int32 num_axes = 3 [default = -1];
inline bool ReshapeParameter::_internal_has_num_axes() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ReshapeParameter::has_num_axes() const {
return _internal_has_num_axes();
}
inline void ReshapeParameter::clear_num_axes() {
num_axes_ = -1;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t ReshapeParameter::_internal_num_axes() const {
return num_axes_;
}
inline int32_t ReshapeParameter::num_axes() const {
// @@protoc_insertion_point(field_get:caffe.ReshapeParameter.num_axes)
return _internal_num_axes();
}
inline void ReshapeParameter::_internal_set_num_axes(int32_t value) {
_has_bits_[0] |= 0x00000004u;
num_axes_ = value;
}
inline void ReshapeParameter::set_num_axes(int32_t value) {
_internal_set_num_axes(value);
// @@protoc_insertion_point(field_set:caffe.ReshapeParameter.num_axes)
}
// -------------------------------------------------------------------
// ScaleParameter
// optional int32 axis = 1 [default = 1];
inline bool ScaleParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool ScaleParameter::has_axis() const {
return _internal_has_axis();
}
inline void ScaleParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000008u;
}
inline int32_t ScaleParameter::_internal_axis() const {
return axis_;
}
inline int32_t ScaleParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.ScaleParameter.axis)
return _internal_axis();
}
inline void ScaleParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000008u;
axis_ = value;
}
inline void ScaleParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.ScaleParameter.axis)
}
// optional int32 num_axes = 2 [default = 1];
inline bool ScaleParameter::_internal_has_num_axes() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool ScaleParameter::has_num_axes() const {
return _internal_has_num_axes();
}
inline void ScaleParameter::clear_num_axes() {
num_axes_ = 1;
_has_bits_[0] &= ~0x00000010u;
}
inline int32_t ScaleParameter::_internal_num_axes() const {
return num_axes_;
}
inline int32_t ScaleParameter::num_axes() const {
// @@protoc_insertion_point(field_get:caffe.ScaleParameter.num_axes)
return _internal_num_axes();
}
inline void ScaleParameter::_internal_set_num_axes(int32_t value) {
_has_bits_[0] |= 0x00000010u;
num_axes_ = value;
}
inline void ScaleParameter::set_num_axes(int32_t value) {
_internal_set_num_axes(value);
// @@protoc_insertion_point(field_set:caffe.ScaleParameter.num_axes)
}
// optional .caffe.FillerParameter filler = 3;
inline bool ScaleParameter::_internal_has_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || filler_ != nullptr);
return value;
}
inline bool ScaleParameter::has_filler() const {
return _internal_has_filler();
}
inline void ScaleParameter::clear_filler() {
if (filler_ != nullptr) filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& ScaleParameter::_internal_filler() const {
const ::caffe::FillerParameter* p = filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& ScaleParameter::filler() const {
// @@protoc_insertion_point(field_get:caffe.ScaleParameter.filler)
return _internal_filler();
}
inline void ScaleParameter::unsafe_arena_set_allocated_filler(
::caffe::FillerParameter* filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filler_);
}
filler_ = filler;
if (filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.ScaleParameter.filler)
}
inline ::caffe::FillerParameter* ScaleParameter::release_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = filler_;
filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* ScaleParameter::unsafe_arena_release_filler() {
// @@protoc_insertion_point(field_release:caffe.ScaleParameter.filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = filler_;
filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* ScaleParameter::_internal_mutable_filler() {
_has_bits_[0] |= 0x00000001u;
if (filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
filler_ = p;
}
return filler_;
}
inline ::caffe::FillerParameter* ScaleParameter::mutable_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_filler();
// @@protoc_insertion_point(field_mutable:caffe.ScaleParameter.filler)
return _msg;
}
inline void ScaleParameter::set_allocated_filler(::caffe::FillerParameter* filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete filler_;
}
if (filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(filler);
if (message_arena != submessage_arena) {
filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
filler_ = filler;
// @@protoc_insertion_point(field_set_allocated:caffe.ScaleParameter.filler)
}
// optional bool bias_term = 4 [default = false];
inline bool ScaleParameter::_internal_has_bias_term() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ScaleParameter::has_bias_term() const {
return _internal_has_bias_term();
}
inline void ScaleParameter::clear_bias_term() {
bias_term_ = false;
_has_bits_[0] &= ~0x00000004u;
}
inline bool ScaleParameter::_internal_bias_term() const {
return bias_term_;
}
inline bool ScaleParameter::bias_term() const {
// @@protoc_insertion_point(field_get:caffe.ScaleParameter.bias_term)
return _internal_bias_term();
}
inline void ScaleParameter::_internal_set_bias_term(bool value) {
_has_bits_[0] |= 0x00000004u;
bias_term_ = value;
}
inline void ScaleParameter::set_bias_term(bool value) {
_internal_set_bias_term(value);
// @@protoc_insertion_point(field_set:caffe.ScaleParameter.bias_term)
}
// optional .caffe.FillerParameter bias_filler = 5;
inline bool ScaleParameter::_internal_has_bias_filler() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || bias_filler_ != nullptr);
return value;
}
inline bool ScaleParameter::has_bias_filler() const {
return _internal_has_bias_filler();
}
inline void ScaleParameter::clear_bias_filler() {
if (bias_filler_ != nullptr) bias_filler_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::FillerParameter& ScaleParameter::_internal_bias_filler() const {
const ::caffe::FillerParameter* p = bias_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& ScaleParameter::bias_filler() const {
// @@protoc_insertion_point(field_get:caffe.ScaleParameter.bias_filler)
return _internal_bias_filler();
}
inline void ScaleParameter::unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_);
}
bias_filler_ = bias_filler;
if (bias_filler) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.ScaleParameter.bias_filler)
}
inline ::caffe::FillerParameter* ScaleParameter::release_bias_filler() {
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* ScaleParameter::unsafe_arena_release_bias_filler() {
// @@protoc_insertion_point(field_release:caffe.ScaleParameter.bias_filler)
_has_bits_[0] &= ~0x00000002u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* ScaleParameter::_internal_mutable_bias_filler() {
_has_bits_[0] |= 0x00000002u;
if (bias_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
bias_filler_ = p;
}
return bias_filler_;
}
inline ::caffe::FillerParameter* ScaleParameter::mutable_bias_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
// @@protoc_insertion_point(field_mutable:caffe.ScaleParameter.bias_filler)
return _msg;
}
inline void ScaleParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_filler_;
}
if (bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(bias_filler);
if (message_arena != submessage_arena) {
bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.ScaleParameter.bias_filler)
}
// -------------------------------------------------------------------
// SigmoidParameter
// optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
inline bool SigmoidParameter::_internal_has_engine() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SigmoidParameter::has_engine() const {
return _internal_has_engine();
}
inline void SigmoidParameter::clear_engine() {
engine_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::SigmoidParameter_Engine SigmoidParameter::_internal_engine() const {
return static_cast< ::caffe::SigmoidParameter_Engine >(engine_);
}
inline ::caffe::SigmoidParameter_Engine SigmoidParameter::engine() const {
// @@protoc_insertion_point(field_get:caffe.SigmoidParameter.engine)
return _internal_engine();
}
inline void SigmoidParameter::_internal_set_engine(::caffe::SigmoidParameter_Engine value) {
assert(::caffe::SigmoidParameter_Engine_IsValid(value));
_has_bits_[0] |= 0x00000001u;
engine_ = value;
}
inline void SigmoidParameter::set_engine(::caffe::SigmoidParameter_Engine value) {
_internal_set_engine(value);
// @@protoc_insertion_point(field_set:caffe.SigmoidParameter.engine)
}
// -------------------------------------------------------------------
// SliceParameter
// optional int32 axis = 3 [default = 1];
inline bool SliceParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool SliceParameter::has_axis() const {
return _internal_has_axis();
}
inline void SliceParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t SliceParameter::_internal_axis() const {
return axis_;
}
inline int32_t SliceParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.SliceParameter.axis)
return _internal_axis();
}
inline void SliceParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000002u;
axis_ = value;
}
inline void SliceParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.SliceParameter.axis)
}
// repeated uint32 slice_point = 2;
inline int SliceParameter::_internal_slice_point_size() const {
return slice_point_.size();
}
inline int SliceParameter::slice_point_size() const {
return _internal_slice_point_size();
}
inline void SliceParameter::clear_slice_point() {
slice_point_.Clear();
}
inline uint32_t SliceParameter::_internal_slice_point(int index) const {
return slice_point_.Get(index);
}
inline uint32_t SliceParameter::slice_point(int index) const {
// @@protoc_insertion_point(field_get:caffe.SliceParameter.slice_point)
return _internal_slice_point(index);
}
inline void SliceParameter::set_slice_point(int index, uint32_t value) {
slice_point_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.SliceParameter.slice_point)
}
inline void SliceParameter::_internal_add_slice_point(uint32_t value) {
slice_point_.Add(value);
}
inline void SliceParameter::add_slice_point(uint32_t value) {
_internal_add_slice_point(value);
// @@protoc_insertion_point(field_add:caffe.SliceParameter.slice_point)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SliceParameter::_internal_slice_point() const {
return slice_point_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SliceParameter::slice_point() const {
// @@protoc_insertion_point(field_list:caffe.SliceParameter.slice_point)
return _internal_slice_point();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SliceParameter::_internal_mutable_slice_point() {
return &slice_point_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SliceParameter::mutable_slice_point() {
// @@protoc_insertion_point(field_mutable_list:caffe.SliceParameter.slice_point)
return _internal_mutable_slice_point();
}
// optional uint32 slice_dim = 1 [default = 1];
inline bool SliceParameter::_internal_has_slice_dim() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SliceParameter::has_slice_dim() const {
return _internal_has_slice_dim();
}
inline void SliceParameter::clear_slice_dim() {
slice_dim_ = 1u;
_has_bits_[0] &= ~0x00000001u;
}
inline uint32_t SliceParameter::_internal_slice_dim() const {
return slice_dim_;
}
inline uint32_t SliceParameter::slice_dim() const {
// @@protoc_insertion_point(field_get:caffe.SliceParameter.slice_dim)
return _internal_slice_dim();
}
inline void SliceParameter::_internal_set_slice_dim(uint32_t value) {
_has_bits_[0] |= 0x00000001u;
slice_dim_ = value;
}
inline void SliceParameter::set_slice_dim(uint32_t value) {
_internal_set_slice_dim(value);
// @@protoc_insertion_point(field_set:caffe.SliceParameter.slice_dim)
}
// -------------------------------------------------------------------
// SoftmaxParameter
// optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
inline bool SoftmaxParameter::_internal_has_engine() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SoftmaxParameter::has_engine() const {
return _internal_has_engine();
}
inline void SoftmaxParameter::clear_engine() {
engine_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::SoftmaxParameter_Engine SoftmaxParameter::_internal_engine() const {
return static_cast< ::caffe::SoftmaxParameter_Engine >(engine_);
}
inline ::caffe::SoftmaxParameter_Engine SoftmaxParameter::engine() const {
// @@protoc_insertion_point(field_get:caffe.SoftmaxParameter.engine)
return _internal_engine();
}
inline void SoftmaxParameter::_internal_set_engine(::caffe::SoftmaxParameter_Engine value) {
assert(::caffe::SoftmaxParameter_Engine_IsValid(value));
_has_bits_[0] |= 0x00000001u;
engine_ = value;
}
inline void SoftmaxParameter::set_engine(::caffe::SoftmaxParameter_Engine value) {
_internal_set_engine(value);
// @@protoc_insertion_point(field_set:caffe.SoftmaxParameter.engine)
}
// optional int32 axis = 2 [default = 1];
inline bool SoftmaxParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool SoftmaxParameter::has_axis() const {
return _internal_has_axis();
}
inline void SoftmaxParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t SoftmaxParameter::_internal_axis() const {
return axis_;
}
inline int32_t SoftmaxParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.SoftmaxParameter.axis)
return _internal_axis();
}
inline void SoftmaxParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000002u;
axis_ = value;
}
inline void SoftmaxParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.SoftmaxParameter.axis)
}
// -------------------------------------------------------------------
// TanHParameter
// optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
inline bool TanHParameter::_internal_has_engine() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool TanHParameter::has_engine() const {
return _internal_has_engine();
}
inline void TanHParameter::clear_engine() {
engine_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::caffe::TanHParameter_Engine TanHParameter::_internal_engine() const {
return static_cast< ::caffe::TanHParameter_Engine >(engine_);
}
inline ::caffe::TanHParameter_Engine TanHParameter::engine() const {
// @@protoc_insertion_point(field_get:caffe.TanHParameter.engine)
return _internal_engine();
}
inline void TanHParameter::_internal_set_engine(::caffe::TanHParameter_Engine value) {
assert(::caffe::TanHParameter_Engine_IsValid(value));
_has_bits_[0] |= 0x00000001u;
engine_ = value;
}
inline void TanHParameter::set_engine(::caffe::TanHParameter_Engine value) {
_internal_set_engine(value);
// @@protoc_insertion_point(field_set:caffe.TanHParameter.engine)
}
// -------------------------------------------------------------------
// TileParameter
// optional int32 axis = 1 [default = 1];
inline bool TileParameter::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool TileParameter::has_axis() const {
return _internal_has_axis();
}
inline void TileParameter::clear_axis() {
axis_ = 1;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t TileParameter::_internal_axis() const {
return axis_;
}
inline int32_t TileParameter::axis() const {
// @@protoc_insertion_point(field_get:caffe.TileParameter.axis)
return _internal_axis();
}
inline void TileParameter::_internal_set_axis(int32_t value) {
_has_bits_[0] |= 0x00000002u;
axis_ = value;
}
inline void TileParameter::set_axis(int32_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:caffe.TileParameter.axis)
}
// optional int32 tiles = 2;
inline bool TileParameter::_internal_has_tiles() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool TileParameter::has_tiles() const {
return _internal_has_tiles();
}
inline void TileParameter::clear_tiles() {
tiles_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline int32_t TileParameter::_internal_tiles() const {
return tiles_;
}
inline int32_t TileParameter::tiles() const {
// @@protoc_insertion_point(field_get:caffe.TileParameter.tiles)
return _internal_tiles();
}
inline void TileParameter::_internal_set_tiles(int32_t value) {
_has_bits_[0] |= 0x00000001u;
tiles_ = value;
}
inline void TileParameter::set_tiles(int32_t value) {
_internal_set_tiles(value);
// @@protoc_insertion_point(field_set:caffe.TileParameter.tiles)
}
// -------------------------------------------------------------------
// ThresholdParameter
// optional float threshold = 1 [default = 0];
inline bool ThresholdParameter::_internal_has_threshold() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ThresholdParameter::has_threshold() const {
return _internal_has_threshold();
}
inline void ThresholdParameter::clear_threshold() {
threshold_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float ThresholdParameter::_internal_threshold() const {
return threshold_;
}
inline float ThresholdParameter::threshold() const {
// @@protoc_insertion_point(field_get:caffe.ThresholdParameter.threshold)
return _internal_threshold();
}
inline void ThresholdParameter::_internal_set_threshold(float value) {
_has_bits_[0] |= 0x00000001u;
threshold_ = value;
}
inline void ThresholdParameter::set_threshold(float value) {
_internal_set_threshold(value);
// @@protoc_insertion_point(field_set:caffe.ThresholdParameter.threshold)
}
// -------------------------------------------------------------------
// WindowDataParameter
// optional string source = 1;
inline bool WindowDataParameter::_internal_has_source() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool WindowDataParameter::has_source() const {
return _internal_has_source();
}
inline void WindowDataParameter::clear_source() {
source_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& WindowDataParameter::source() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.source)
return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WindowDataParameter::set_source(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.source)
}
inline std::string* WindowDataParameter::mutable_source() {
std::string* _s = _internal_mutable_source();
// @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.source)
return _s;
}
inline const std::string& WindowDataParameter::_internal_source() const {
return source_.Get();
}
inline void WindowDataParameter::_internal_set_source(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::_internal_mutable_source() {
_has_bits_[0] |= 0x00000001u;
return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::release_source() {
// @@protoc_insertion_point(field_release:caffe.WindowDataParameter.source)
if (!_internal_has_source()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void WindowDataParameter::set_allocated_source(std::string* source) {
if (source != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.source)
}
// optional float scale = 2 [default = 1];
inline bool WindowDataParameter::_internal_has_scale() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool WindowDataParameter::has_scale() const {
return _internal_has_scale();
}
inline void WindowDataParameter::clear_scale() {
scale_ = 1;
_has_bits_[0] &= ~0x00000200u;
}
inline float WindowDataParameter::_internal_scale() const {
return scale_;
}
inline float WindowDataParameter::scale() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.scale)
return _internal_scale();
}
inline void WindowDataParameter::_internal_set_scale(float value) {
_has_bits_[0] |= 0x00000200u;
scale_ = value;
}
inline void WindowDataParameter::set_scale(float value) {
_internal_set_scale(value);
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.scale)
}
// optional string mean_file = 3;
inline bool WindowDataParameter::_internal_has_mean_file() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool WindowDataParameter::has_mean_file() const {
return _internal_has_mean_file();
}
inline void WindowDataParameter::clear_mean_file() {
mean_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& WindowDataParameter::mean_file() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.mean_file)
return _internal_mean_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WindowDataParameter::set_mean_file(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.mean_file)
}
inline std::string* WindowDataParameter::mutable_mean_file() {
std::string* _s = _internal_mutable_mean_file();
// @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.mean_file)
return _s;
}
inline const std::string& WindowDataParameter::_internal_mean_file() const {
return mean_file_.Get();
}
inline void WindowDataParameter::_internal_set_mean_file(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::_internal_mutable_mean_file() {
_has_bits_[0] |= 0x00000002u;
return mean_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::release_mean_file() {
// @@protoc_insertion_point(field_release:caffe.WindowDataParameter.mean_file)
if (!_internal_has_mean_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = mean_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void WindowDataParameter::set_allocated_mean_file(std::string* mean_file) {
if (mean_file != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
mean_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mean_file,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (mean_file_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.mean_file)
}
// optional uint32 batch_size = 4;
inline bool WindowDataParameter::_internal_has_batch_size() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool WindowDataParameter::has_batch_size() const {
return _internal_has_batch_size();
}
inline void WindowDataParameter::clear_batch_size() {
batch_size_ = 0u;
_has_bits_[0] &= ~0x00000010u;
}
inline uint32_t WindowDataParameter::_internal_batch_size() const {
return batch_size_;
}
inline uint32_t WindowDataParameter::batch_size() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.batch_size)
return _internal_batch_size();
}
inline void WindowDataParameter::_internal_set_batch_size(uint32_t value) {
_has_bits_[0] |= 0x00000010u;
batch_size_ = value;
}
inline void WindowDataParameter::set_batch_size(uint32_t value) {
_internal_set_batch_size(value);
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.batch_size)
}
// optional uint32 crop_size = 5 [default = 0];
inline bool WindowDataParameter::_internal_has_crop_size() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool WindowDataParameter::has_crop_size() const {
return _internal_has_crop_size();
}
inline void WindowDataParameter::clear_crop_size() {
crop_size_ = 0u;
_has_bits_[0] &= ~0x00000020u;
}
inline uint32_t WindowDataParameter::_internal_crop_size() const {
return crop_size_;
}
inline uint32_t WindowDataParameter::crop_size() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.crop_size)
return _internal_crop_size();
}
inline void WindowDataParameter::_internal_set_crop_size(uint32_t value) {
_has_bits_[0] |= 0x00000020u;
crop_size_ = value;
}
inline void WindowDataParameter::set_crop_size(uint32_t value) {
_internal_set_crop_size(value);
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.crop_size)
}
// optional bool mirror = 6 [default = false];
inline bool WindowDataParameter::_internal_has_mirror() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool WindowDataParameter::has_mirror() const {
return _internal_has_mirror();
}
inline void WindowDataParameter::clear_mirror() {
mirror_ = false;
_has_bits_[0] &= ~0x00000040u;
}
inline bool WindowDataParameter::_internal_mirror() const {
return mirror_;
}
inline bool WindowDataParameter::mirror() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.mirror)
return _internal_mirror();
}
inline void WindowDataParameter::_internal_set_mirror(bool value) {
_has_bits_[0] |= 0x00000040u;
mirror_ = value;
}
inline void WindowDataParameter::set_mirror(bool value) {
_internal_set_mirror(value);
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.mirror)
}
// optional float fg_threshold = 7 [default = 0.5];
inline bool WindowDataParameter::_internal_has_fg_threshold() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool WindowDataParameter::has_fg_threshold() const {
return _internal_has_fg_threshold();
}
inline void WindowDataParameter::clear_fg_threshold() {
fg_threshold_ = 0.5f;
_has_bits_[0] &= ~0x00000400u;
}
inline float WindowDataParameter::_internal_fg_threshold() const {
return fg_threshold_;
}
inline float WindowDataParameter::fg_threshold() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.fg_threshold)
return _internal_fg_threshold();
}
inline void WindowDataParameter::_internal_set_fg_threshold(float value) {
_has_bits_[0] |= 0x00000400u;
fg_threshold_ = value;
}
inline void WindowDataParameter::set_fg_threshold(float value) {
_internal_set_fg_threshold(value);
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.fg_threshold)
}
// optional float bg_threshold = 8 [default = 0.5];
inline bool WindowDataParameter::_internal_has_bg_threshold() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool WindowDataParameter::has_bg_threshold() const {
return _internal_has_bg_threshold();
}
inline void WindowDataParameter::clear_bg_threshold() {
bg_threshold_ = 0.5f;
_has_bits_[0] &= ~0x00000800u;
}
inline float WindowDataParameter::_internal_bg_threshold() const {
return bg_threshold_;
}
inline float WindowDataParameter::bg_threshold() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.bg_threshold)
return _internal_bg_threshold();
}
inline void WindowDataParameter::_internal_set_bg_threshold(float value) {
_has_bits_[0] |= 0x00000800u;
bg_threshold_ = value;
}
inline void WindowDataParameter::set_bg_threshold(float value) {
_internal_set_bg_threshold(value);
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.bg_threshold)
}
// optional float fg_fraction = 9 [default = 0.25];
inline bool WindowDataParameter::_internal_has_fg_fraction() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool WindowDataParameter::has_fg_fraction() const {
return _internal_has_fg_fraction();
}
inline void WindowDataParameter::clear_fg_fraction() {
fg_fraction_ = 0.25f;
_has_bits_[0] &= ~0x00001000u;
}
inline float WindowDataParameter::_internal_fg_fraction() const {
return fg_fraction_;
}
inline float WindowDataParameter::fg_fraction() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.fg_fraction)
return _internal_fg_fraction();
}
inline void WindowDataParameter::_internal_set_fg_fraction(float value) {
_has_bits_[0] |= 0x00001000u;
fg_fraction_ = value;
}
inline void WindowDataParameter::set_fg_fraction(float value) {
_internal_set_fg_fraction(value);
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.fg_fraction)
}
// optional uint32 context_pad = 10 [default = 0];
inline bool WindowDataParameter::_internal_has_context_pad() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool WindowDataParameter::has_context_pad() const {
return _internal_has_context_pad();
}
inline void WindowDataParameter::clear_context_pad() {
context_pad_ = 0u;
_has_bits_[0] &= ~0x00000100u;
}
inline uint32_t WindowDataParameter::_internal_context_pad() const {
return context_pad_;
}
inline uint32_t WindowDataParameter::context_pad() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.context_pad)
return _internal_context_pad();
}
inline void WindowDataParameter::_internal_set_context_pad(uint32_t value) {
_has_bits_[0] |= 0x00000100u;
context_pad_ = value;
}
inline void WindowDataParameter::set_context_pad(uint32_t value) {
_internal_set_context_pad(value);
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.context_pad)
}
// optional string crop_mode = 11 [default = "warp"];
inline bool WindowDataParameter::_internal_has_crop_mode() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool WindowDataParameter::has_crop_mode() const {
return _internal_has_crop_mode();
}
inline void WindowDataParameter::clear_crop_mode() {
crop_mode_.ClearToDefault(::caffe::WindowDataParameter::_i_give_permission_to_break_this_code_default_crop_mode_, GetArenaForAllocation());
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& WindowDataParameter::crop_mode() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.crop_mode)
if (crop_mode_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_crop_mode_.get();
return _internal_crop_mode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WindowDataParameter::set_crop_mode(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.crop_mode)
}
inline std::string* WindowDataParameter::mutable_crop_mode() {
std::string* _s = _internal_mutable_crop_mode();
// @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.crop_mode)
return _s;
}
inline const std::string& WindowDataParameter::_internal_crop_mode() const {
return crop_mode_.Get();
}
inline void WindowDataParameter::_internal_set_crop_mode(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::_internal_mutable_crop_mode() {
_has_bits_[0] |= 0x00000004u;
return crop_mode_.Mutable(::caffe::WindowDataParameter::_i_give_permission_to_break_this_code_default_crop_mode_, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::release_crop_mode() {
// @@protoc_insertion_point(field_release:caffe.WindowDataParameter.crop_mode)
if (!_internal_has_crop_mode()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = crop_mode_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
return p;
}
inline void WindowDataParameter::set_allocated_crop_mode(std::string* crop_mode) {
if (crop_mode != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
crop_mode_.SetAllocated(nullptr, crop_mode,
GetArenaForAllocation());
// @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.crop_mode)
}
// optional bool cache_images = 12 [default = false];
inline bool WindowDataParameter::_internal_has_cache_images() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool WindowDataParameter::has_cache_images() const {
return _internal_has_cache_images();
}
inline void WindowDataParameter::clear_cache_images() {
cache_images_ = false;
_has_bits_[0] &= ~0x00000080u;
}
inline bool WindowDataParameter::_internal_cache_images() const {
return cache_images_;
}
inline bool WindowDataParameter::cache_images() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.cache_images)
return _internal_cache_images();
}
inline void WindowDataParameter::_internal_set_cache_images(bool value) {
_has_bits_[0] |= 0x00000080u;
cache_images_ = value;
}
inline void WindowDataParameter::set_cache_images(bool value) {
_internal_set_cache_images(value);
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.cache_images)
}
// optional string root_folder = 13 [default = ""];
inline bool WindowDataParameter::_internal_has_root_folder() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool WindowDataParameter::has_root_folder() const {
return _internal_has_root_folder();
}
inline void WindowDataParameter::clear_root_folder() {
root_folder_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& WindowDataParameter::root_folder() const {
// @@protoc_insertion_point(field_get:caffe.WindowDataParameter.root_folder)
return _internal_root_folder();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WindowDataParameter::set_root_folder(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000008u;
root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.WindowDataParameter.root_folder)
}
inline std::string* WindowDataParameter::mutable_root_folder() {
std::string* _s = _internal_mutable_root_folder();
// @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.root_folder)
return _s;
}
inline const std::string& WindowDataParameter::_internal_root_folder() const {
return root_folder_.Get();
}
inline void WindowDataParameter::_internal_set_root_folder(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::_internal_mutable_root_folder() {
_has_bits_[0] |= 0x00000008u;
return root_folder_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::release_root_folder() {
// @@protoc_insertion_point(field_release:caffe.WindowDataParameter.root_folder)
if (!_internal_has_root_folder()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
auto* p = root_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (root_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void WindowDataParameter::set_allocated_root_folder(std::string* root_folder) {
if (root_folder != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
root_folder_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), root_folder,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (root_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.root_folder)
}
// -------------------------------------------------------------------
// SPPParameter
// optional uint32 pyramid_height = 1;
inline bool SPPParameter::_internal_has_pyramid_height() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SPPParameter::has_pyramid_height() const {
return _internal_has_pyramid_height();
}
inline void SPPParameter::clear_pyramid_height() {
pyramid_height_ = 0u;
_has_bits_[0] &= ~0x00000001u;
}
inline uint32_t SPPParameter::_internal_pyramid_height() const {
return pyramid_height_;
}
inline uint32_t SPPParameter::pyramid_height() const {
// @@protoc_insertion_point(field_get:caffe.SPPParameter.pyramid_height)
return _internal_pyramid_height();
}
inline void SPPParameter::_internal_set_pyramid_height(uint32_t value) {
_has_bits_[0] |= 0x00000001u;
pyramid_height_ = value;
}
inline void SPPParameter::set_pyramid_height(uint32_t value) {
_internal_set_pyramid_height(value);
// @@protoc_insertion_point(field_set:caffe.SPPParameter.pyramid_height)
}
// optional .caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
inline bool SPPParameter::_internal_has_pool() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool SPPParameter::has_pool() const {
return _internal_has_pool();
}
inline void SPPParameter::clear_pool() {
pool_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::caffe::SPPParameter_PoolMethod SPPParameter::_internal_pool() const {
return static_cast< ::caffe::SPPParameter_PoolMethod >(pool_);
}
inline ::caffe::SPPParameter_PoolMethod SPPParameter::pool() const {
// @@protoc_insertion_point(field_get:caffe.SPPParameter.pool)
return _internal_pool();
}
inline void SPPParameter::_internal_set_pool(::caffe::SPPParameter_PoolMethod value) {
assert(::caffe::SPPParameter_PoolMethod_IsValid(value));
_has_bits_[0] |= 0x00000002u;
pool_ = value;
}
inline void SPPParameter::set_pool(::caffe::SPPParameter_PoolMethod value) {
_internal_set_pool(value);
// @@protoc_insertion_point(field_set:caffe.SPPParameter.pool)
}
// optional .caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
inline bool SPPParameter::_internal_has_engine() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool SPPParameter::has_engine() const {
return _internal_has_engine();
}
inline void SPPParameter::clear_engine() {
engine_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline ::caffe::SPPParameter_Engine SPPParameter::_internal_engine() const {
return static_cast< ::caffe::SPPParameter_Engine >(engine_);
}
inline ::caffe::SPPParameter_Engine SPPParameter::engine() const {
// @@protoc_insertion_point(field_get:caffe.SPPParameter.engine)
return _internal_engine();
}
inline void SPPParameter::_internal_set_engine(::caffe::SPPParameter_Engine value) {
assert(::caffe::SPPParameter_Engine_IsValid(value));
_has_bits_[0] |= 0x00000004u;
engine_ = value;
}
inline void SPPParameter::set_engine(::caffe::SPPParameter_Engine value) {
_internal_set_engine(value);
// @@protoc_insertion_point(field_set:caffe.SPPParameter.engine)
}
// -------------------------------------------------------------------
// V1LayerParameter
// repeated string bottom = 2;
inline int V1LayerParameter::_internal_bottom_size() const {
return bottom_.size();
}
inline int V1LayerParameter::bottom_size() const {
return _internal_bottom_size();
}
inline void V1LayerParameter::clear_bottom() {
bottom_.Clear();
}
inline std::string* V1LayerParameter::add_bottom() {
std::string* _s = _internal_add_bottom();
// @@protoc_insertion_point(field_add_mutable:caffe.V1LayerParameter.bottom)
return _s;
}
inline const std::string& V1LayerParameter::_internal_bottom(int index) const {
return bottom_.Get(index);
}
inline const std::string& V1LayerParameter::bottom(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.bottom)
return _internal_bottom(index);
}
inline std::string* V1LayerParameter::mutable_bottom(int index) {
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.bottom)
return bottom_.Mutable(index);
}
inline void V1LayerParameter::set_bottom(int index, const std::string& value) {
bottom_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::set_bottom(int index, std::string&& value) {
bottom_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::set_bottom(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
bottom_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::set_bottom(int index, const char* value, size_t size) {
bottom_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.bottom)
}
inline std::string* V1LayerParameter::_internal_add_bottom() {
return bottom_.Add();
}
inline void V1LayerParameter::add_bottom(const std::string& value) {
bottom_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::add_bottom(std::string&& value) {
bottom_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::add_bottom(const char* value) {
GOOGLE_DCHECK(value != nullptr);
bottom_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::add_bottom(const char* value, size_t size) {
bottom_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.bottom)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
V1LayerParameter::bottom() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.bottom)
return bottom_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
V1LayerParameter::mutable_bottom() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.bottom)
return &bottom_;
}
// repeated string top = 3;
inline int V1LayerParameter::_internal_top_size() const {
return top_.size();
}
inline int V1LayerParameter::top_size() const {
return _internal_top_size();
}
inline void V1LayerParameter::clear_top() {
top_.Clear();
}
inline std::string* V1LayerParameter::add_top() {
std::string* _s = _internal_add_top();
// @@protoc_insertion_point(field_add_mutable:caffe.V1LayerParameter.top)
return _s;
}
inline const std::string& V1LayerParameter::_internal_top(int index) const {
return top_.Get(index);
}
inline const std::string& V1LayerParameter::top(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.top)
return _internal_top(index);
}
inline std::string* V1LayerParameter::mutable_top(int index) {
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.top)
return top_.Mutable(index);
}
inline void V1LayerParameter::set_top(int index, const std::string& value) {
top_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::set_top(int index, std::string&& value) {
top_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::set_top(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
top_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::set_top(int index, const char* value, size_t size) {
top_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.top)
}
inline std::string* V1LayerParameter::_internal_add_top() {
return top_.Add();
}
inline void V1LayerParameter::add_top(const std::string& value) {
top_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::add_top(std::string&& value) {
top_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::add_top(const char* value) {
GOOGLE_DCHECK(value != nullptr);
top_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::add_top(const char* value, size_t size) {
top_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.top)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
V1LayerParameter::top() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.top)
return top_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
V1LayerParameter::mutable_top() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.top)
return &top_;
}
// optional string name = 4;
inline bool V1LayerParameter::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool V1LayerParameter::has_name() const {
return _internal_has_name();
}
inline void V1LayerParameter::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& V1LayerParameter::name() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V1LayerParameter::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.name)
}
inline std::string* V1LayerParameter::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.name)
return _s;
}
inline const std::string& V1LayerParameter::_internal_name() const {
return name_.Get();
}
inline void V1LayerParameter::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* V1LayerParameter::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* V1LayerParameter::release_name() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void V1LayerParameter::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.name)
}
// repeated .caffe.NetStateRule include = 32;
inline int V1LayerParameter::_internal_include_size() const {
return include_.size();
}
inline int V1LayerParameter::include_size() const {
return _internal_include_size();
}
inline void V1LayerParameter::clear_include() {
include_.Clear();
}
inline ::caffe::NetStateRule* V1LayerParameter::mutable_include(int index) {
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.include)
return include_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >*
V1LayerParameter::mutable_include() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.include)
return &include_;
}
inline const ::caffe::NetStateRule& V1LayerParameter::_internal_include(int index) const {
return include_.Get(index);
}
inline const ::caffe::NetStateRule& V1LayerParameter::include(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.include)
return _internal_include(index);
}
inline ::caffe::NetStateRule* V1LayerParameter::_internal_add_include() {
return include_.Add();
}
inline ::caffe::NetStateRule* V1LayerParameter::add_include() {
::caffe::NetStateRule* _add = _internal_add_include();
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.include)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >&
V1LayerParameter::include() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.include)
return include_;
}
// repeated .caffe.NetStateRule exclude = 33;
inline int V1LayerParameter::_internal_exclude_size() const {
return exclude_.size();
}
inline int V1LayerParameter::exclude_size() const {
return _internal_exclude_size();
}
inline void V1LayerParameter::clear_exclude() {
exclude_.Clear();
}
inline ::caffe::NetStateRule* V1LayerParameter::mutable_exclude(int index) {
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.exclude)
return exclude_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >*
V1LayerParameter::mutable_exclude() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.exclude)
return &exclude_;
}
inline const ::caffe::NetStateRule& V1LayerParameter::_internal_exclude(int index) const {
return exclude_.Get(index);
}
inline const ::caffe::NetStateRule& V1LayerParameter::exclude(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.exclude)
return _internal_exclude(index);
}
inline ::caffe::NetStateRule* V1LayerParameter::_internal_add_exclude() {
return exclude_.Add();
}
inline ::caffe::NetStateRule* V1LayerParameter::add_exclude() {
::caffe::NetStateRule* _add = _internal_add_exclude();
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.exclude)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::NetStateRule >&
V1LayerParameter::exclude() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.exclude)
return exclude_;
}
// optional .caffe.V1LayerParameter.LayerType type = 5;
inline bool V1LayerParameter::_internal_has_type() const {
bool value = (_has_bits_[1] & 0x00000001u) != 0;
return value;
}
inline bool V1LayerParameter::has_type() const {
return _internal_has_type();
}
inline void V1LayerParameter::clear_type() {
type_ = 0;
_has_bits_[1] &= ~0x00000001u;
}
inline ::caffe::V1LayerParameter_LayerType V1LayerParameter::_internal_type() const {
return static_cast< ::caffe::V1LayerParameter_LayerType >(type_);
}
inline ::caffe::V1LayerParameter_LayerType V1LayerParameter::type() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.type)
return _internal_type();
}
inline void V1LayerParameter::_internal_set_type(::caffe::V1LayerParameter_LayerType value) {
assert(::caffe::V1LayerParameter_LayerType_IsValid(value));
_has_bits_[1] |= 0x00000001u;
type_ = value;
}
inline void V1LayerParameter::set_type(::caffe::V1LayerParameter_LayerType value) {
_internal_set_type(value);
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.type)
}
// repeated .caffe.BlobProto blobs = 6;
inline int V1LayerParameter::_internal_blobs_size() const {
return blobs_.size();
}
inline int V1LayerParameter::blobs_size() const {
return _internal_blobs_size();
}
inline void V1LayerParameter::clear_blobs() {
blobs_.Clear();
}
inline ::caffe::BlobProto* V1LayerParameter::mutable_blobs(int index) {
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.blobs)
return blobs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
V1LayerParameter::mutable_blobs() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.blobs)
return &blobs_;
}
inline const ::caffe::BlobProto& V1LayerParameter::_internal_blobs(int index) const {
return blobs_.Get(index);
}
inline const ::caffe::BlobProto& V1LayerParameter::blobs(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.blobs)
return _internal_blobs(index);
}
inline ::caffe::BlobProto* V1LayerParameter::_internal_add_blobs() {
return blobs_.Add();
}
inline ::caffe::BlobProto* V1LayerParameter::add_blobs() {
::caffe::BlobProto* _add = _internal_add_blobs();
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.blobs)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
V1LayerParameter::blobs() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blobs)
return blobs_;
}
// repeated string param = 1001;
inline int V1LayerParameter::_internal_param_size() const {
return param_.size();
}
inline int V1LayerParameter::param_size() const {
return _internal_param_size();
}
inline void V1LayerParameter::clear_param() {
param_.Clear();
}
inline std::string* V1LayerParameter::add_param() {
std::string* _s = _internal_add_param();
// @@protoc_insertion_point(field_add_mutable:caffe.V1LayerParameter.param)
return _s;
}
inline const std::string& V1LayerParameter::_internal_param(int index) const {
return param_.Get(index);
}
inline const std::string& V1LayerParameter::param(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.param)
return _internal_param(index);
}
inline std::string* V1LayerParameter::mutable_param(int index) {
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.param)
return param_.Mutable(index);
}
inline void V1LayerParameter::set_param(int index, const std::string& value) {
param_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::set_param(int index, std::string&& value) {
param_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::set_param(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
param_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::set_param(int index, const char* value, size_t size) {
param_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.param)
}
inline std::string* V1LayerParameter::_internal_add_param() {
return param_.Add();
}
inline void V1LayerParameter::add_param(const std::string& value) {
param_.Add()->assign(value);
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::add_param(std::string&& value) {
param_.Add(std::move(value));
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::add_param(const char* value) {
GOOGLE_DCHECK(value != nullptr);
param_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::add_param(const char* value, size_t size) {
param_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.param)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
V1LayerParameter::param() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.param)
return param_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
V1LayerParameter::mutable_param() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.param)
return &param_;
}
// repeated .caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
inline int V1LayerParameter::_internal_blob_share_mode_size() const {
return blob_share_mode_.size();
}
inline int V1LayerParameter::blob_share_mode_size() const {
return _internal_blob_share_mode_size();
}
inline void V1LayerParameter::clear_blob_share_mode() {
blob_share_mode_.Clear();
}
inline ::caffe::V1LayerParameter_DimCheckMode V1LayerParameter::_internal_blob_share_mode(int index) const {
return static_cast< ::caffe::V1LayerParameter_DimCheckMode >(blob_share_mode_.Get(index));
}
inline ::caffe::V1LayerParameter_DimCheckMode V1LayerParameter::blob_share_mode(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.blob_share_mode)
return _internal_blob_share_mode(index);
}
inline void V1LayerParameter::set_blob_share_mode(int index, ::caffe::V1LayerParameter_DimCheckMode value) {
assert(::caffe::V1LayerParameter_DimCheckMode_IsValid(value));
blob_share_mode_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.blob_share_mode)
}
inline void V1LayerParameter::_internal_add_blob_share_mode(::caffe::V1LayerParameter_DimCheckMode value) {
assert(::caffe::V1LayerParameter_DimCheckMode_IsValid(value));
blob_share_mode_.Add(value);
}
inline void V1LayerParameter::add_blob_share_mode(::caffe::V1LayerParameter_DimCheckMode value) {
_internal_add_blob_share_mode(value);
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.blob_share_mode)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
V1LayerParameter::blob_share_mode() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blob_share_mode)
return blob_share_mode_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
V1LayerParameter::_internal_mutable_blob_share_mode() {
return &blob_share_mode_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
V1LayerParameter::mutable_blob_share_mode() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.blob_share_mode)
return _internal_mutable_blob_share_mode();
}
// repeated float blobs_lr = 7;
inline int V1LayerParameter::_internal_blobs_lr_size() const {
return blobs_lr_.size();
}
inline int V1LayerParameter::blobs_lr_size() const {
return _internal_blobs_lr_size();
}
inline void V1LayerParameter::clear_blobs_lr() {
blobs_lr_.Clear();
}
inline float V1LayerParameter::_internal_blobs_lr(int index) const {
return blobs_lr_.Get(index);
}
inline float V1LayerParameter::blobs_lr(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.blobs_lr)
return _internal_blobs_lr(index);
}
inline void V1LayerParameter::set_blobs_lr(int index, float value) {
blobs_lr_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.blobs_lr)
}
inline void V1LayerParameter::_internal_add_blobs_lr(float value) {
blobs_lr_.Add(value);
}
inline void V1LayerParameter::add_blobs_lr(float value) {
_internal_add_blobs_lr(value);
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.blobs_lr)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::_internal_blobs_lr() const {
return blobs_lr_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::blobs_lr() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blobs_lr)
return _internal_blobs_lr();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::_internal_mutable_blobs_lr() {
return &blobs_lr_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::mutable_blobs_lr() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.blobs_lr)
return _internal_mutable_blobs_lr();
}
// repeated float weight_decay = 8;
inline int V1LayerParameter::_internal_weight_decay_size() const {
return weight_decay_.size();
}
inline int V1LayerParameter::weight_decay_size() const {
return _internal_weight_decay_size();
}
inline void V1LayerParameter::clear_weight_decay() {
weight_decay_.Clear();
}
inline float V1LayerParameter::_internal_weight_decay(int index) const {
return weight_decay_.Get(index);
}
inline float V1LayerParameter::weight_decay(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.weight_decay)
return _internal_weight_decay(index);
}
inline void V1LayerParameter::set_weight_decay(int index, float value) {
weight_decay_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.weight_decay)
}
inline void V1LayerParameter::_internal_add_weight_decay(float value) {
weight_decay_.Add(value);
}
inline void V1LayerParameter::add_weight_decay(float value) {
_internal_add_weight_decay(value);
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.weight_decay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::_internal_weight_decay() const {
return weight_decay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::weight_decay() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.weight_decay)
return _internal_weight_decay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::_internal_mutable_weight_decay() {
return &weight_decay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::mutable_weight_decay() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.weight_decay)
return _internal_mutable_weight_decay();
}
// repeated float loss_weight = 35;
inline int V1LayerParameter::_internal_loss_weight_size() const {
return loss_weight_.size();
}
inline int V1LayerParameter::loss_weight_size() const {
return _internal_loss_weight_size();
}
inline void V1LayerParameter::clear_loss_weight() {
loss_weight_.Clear();
}
inline float V1LayerParameter::_internal_loss_weight(int index) const {
return loss_weight_.Get(index);
}
inline float V1LayerParameter::loss_weight(int index) const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.loss_weight)
return _internal_loss_weight(index);
}
inline void V1LayerParameter::set_loss_weight(int index, float value) {
loss_weight_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.V1LayerParameter.loss_weight)
}
inline void V1LayerParameter::_internal_add_loss_weight(float value) {
loss_weight_.Add(value);
}
inline void V1LayerParameter::add_loss_weight(float value) {
_internal_add_loss_weight(value);
// @@protoc_insertion_point(field_add:caffe.V1LayerParameter.loss_weight)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::_internal_loss_weight() const {
return loss_weight_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::loss_weight() const {
// @@protoc_insertion_point(field_list:caffe.V1LayerParameter.loss_weight)
return _internal_loss_weight();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::_internal_mutable_loss_weight() {
return &loss_weight_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::mutable_loss_weight() {
// @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.loss_weight)
return _internal_mutable_loss_weight();
}
// optional .caffe.AccuracyParameter accuracy_param = 27;
inline bool V1LayerParameter::_internal_has_accuracy_param() const {
bool value = (_has_bits_[0] & 0x00100000u) != 0;
PROTOBUF_ASSUME(!value || accuracy_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_accuracy_param() const {
return _internal_has_accuracy_param();
}
inline void V1LayerParameter::clear_accuracy_param() {
if (accuracy_param_ != nullptr) accuracy_param_->Clear();
_has_bits_[0] &= ~0x00100000u;
}
inline const ::caffe::AccuracyParameter& V1LayerParameter::_internal_accuracy_param() const {
const ::caffe::AccuracyParameter* p = accuracy_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::AccuracyParameter&>(
::caffe::_AccuracyParameter_default_instance_);
}
inline const ::caffe::AccuracyParameter& V1LayerParameter::accuracy_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.accuracy_param)
return _internal_accuracy_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_accuracy_param(
::caffe::AccuracyParameter* accuracy_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(accuracy_param_);
}
accuracy_param_ = accuracy_param;
if (accuracy_param) {
_has_bits_[0] |= 0x00100000u;
} else {
_has_bits_[0] &= ~0x00100000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.accuracy_param)
}
inline ::caffe::AccuracyParameter* V1LayerParameter::release_accuracy_param() {
_has_bits_[0] &= ~0x00100000u;
::caffe::AccuracyParameter* temp = accuracy_param_;
accuracy_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::AccuracyParameter* V1LayerParameter::unsafe_arena_release_accuracy_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.accuracy_param)
_has_bits_[0] &= ~0x00100000u;
::caffe::AccuracyParameter* temp = accuracy_param_;
accuracy_param_ = nullptr;
return temp;
}
inline ::caffe::AccuracyParameter* V1LayerParameter::_internal_mutable_accuracy_param() {
_has_bits_[0] |= 0x00100000u;
if (accuracy_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::AccuracyParameter>(GetArenaForAllocation());
accuracy_param_ = p;
}
return accuracy_param_;
}
inline ::caffe::AccuracyParameter* V1LayerParameter::mutable_accuracy_param() {
::caffe::AccuracyParameter* _msg = _internal_mutable_accuracy_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.accuracy_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete accuracy_param_;
}
if (accuracy_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::AccuracyParameter>::GetOwningArena(accuracy_param);
if (message_arena != submessage_arena) {
accuracy_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, accuracy_param, submessage_arena);
}
_has_bits_[0] |= 0x00100000u;
} else {
_has_bits_[0] &= ~0x00100000u;
}
accuracy_param_ = accuracy_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.accuracy_param)
}
// optional .caffe.ArgMaxParameter argmax_param = 23;
inline bool V1LayerParameter::_internal_has_argmax_param() const {
bool value = (_has_bits_[0] & 0x00010000u) != 0;
PROTOBUF_ASSUME(!value || argmax_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_argmax_param() const {
return _internal_has_argmax_param();
}
inline void V1LayerParameter::clear_argmax_param() {
if (argmax_param_ != nullptr) argmax_param_->Clear();
_has_bits_[0] &= ~0x00010000u;
}
inline const ::caffe::ArgMaxParameter& V1LayerParameter::_internal_argmax_param() const {
const ::caffe::ArgMaxParameter* p = argmax_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ArgMaxParameter&>(
::caffe::_ArgMaxParameter_default_instance_);
}
inline const ::caffe::ArgMaxParameter& V1LayerParameter::argmax_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.argmax_param)
return _internal_argmax_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_argmax_param(
::caffe::ArgMaxParameter* argmax_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(argmax_param_);
}
argmax_param_ = argmax_param;
if (argmax_param) {
_has_bits_[0] |= 0x00010000u;
} else {
_has_bits_[0] &= ~0x00010000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.argmax_param)
}
inline ::caffe::ArgMaxParameter* V1LayerParameter::release_argmax_param() {
_has_bits_[0] &= ~0x00010000u;
::caffe::ArgMaxParameter* temp = argmax_param_;
argmax_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ArgMaxParameter* V1LayerParameter::unsafe_arena_release_argmax_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.argmax_param)
_has_bits_[0] &= ~0x00010000u;
::caffe::ArgMaxParameter* temp = argmax_param_;
argmax_param_ = nullptr;
return temp;
}
inline ::caffe::ArgMaxParameter* V1LayerParameter::_internal_mutable_argmax_param() {
_has_bits_[0] |= 0x00010000u;
if (argmax_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ArgMaxParameter>(GetArenaForAllocation());
argmax_param_ = p;
}
return argmax_param_;
}
inline ::caffe::ArgMaxParameter* V1LayerParameter::mutable_argmax_param() {
::caffe::ArgMaxParameter* _msg = _internal_mutable_argmax_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.argmax_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete argmax_param_;
}
if (argmax_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ArgMaxParameter>::GetOwningArena(argmax_param);
if (message_arena != submessage_arena) {
argmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, argmax_param, submessage_arena);
}
_has_bits_[0] |= 0x00010000u;
} else {
_has_bits_[0] &= ~0x00010000u;
}
argmax_param_ = argmax_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.argmax_param)
}
// optional .caffe.ConcatParameter concat_param = 9;
inline bool V1LayerParameter::_internal_has_concat_param() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
PROTOBUF_ASSUME(!value || concat_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_concat_param() const {
return _internal_has_concat_param();
}
inline void V1LayerParameter::clear_concat_param() {
if (concat_param_ != nullptr) concat_param_->Clear();
_has_bits_[0] &= ~0x00000004u;
}
inline const ::caffe::ConcatParameter& V1LayerParameter::_internal_concat_param() const {
const ::caffe::ConcatParameter* p = concat_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ConcatParameter&>(
::caffe::_ConcatParameter_default_instance_);
}
inline const ::caffe::ConcatParameter& V1LayerParameter::concat_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.concat_param)
return _internal_concat_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_concat_param(
::caffe::ConcatParameter* concat_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(concat_param_);
}
concat_param_ = concat_param;
if (concat_param) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.concat_param)
}
inline ::caffe::ConcatParameter* V1LayerParameter::release_concat_param() {
_has_bits_[0] &= ~0x00000004u;
::caffe::ConcatParameter* temp = concat_param_;
concat_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ConcatParameter* V1LayerParameter::unsafe_arena_release_concat_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.concat_param)
_has_bits_[0] &= ~0x00000004u;
::caffe::ConcatParameter* temp = concat_param_;
concat_param_ = nullptr;
return temp;
}
inline ::caffe::ConcatParameter* V1LayerParameter::_internal_mutable_concat_param() {
_has_bits_[0] |= 0x00000004u;
if (concat_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ConcatParameter>(GetArenaForAllocation());
concat_param_ = p;
}
return concat_param_;
}
inline ::caffe::ConcatParameter* V1LayerParameter::mutable_concat_param() {
::caffe::ConcatParameter* _msg = _internal_mutable_concat_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.concat_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_concat_param(::caffe::ConcatParameter* concat_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete concat_param_;
}
if (concat_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ConcatParameter>::GetOwningArena(concat_param);
if (message_arena != submessage_arena) {
concat_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, concat_param, submessage_arena);
}
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
concat_param_ = concat_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.concat_param)
}
// optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40;
inline bool V1LayerParameter::_internal_has_contrastive_loss_param() const {
bool value = (_has_bits_[0] & 0x20000000u) != 0;
PROTOBUF_ASSUME(!value || contrastive_loss_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_contrastive_loss_param() const {
return _internal_has_contrastive_loss_param();
}
inline void V1LayerParameter::clear_contrastive_loss_param() {
if (contrastive_loss_param_ != nullptr) contrastive_loss_param_->Clear();
_has_bits_[0] &= ~0x20000000u;
}
inline const ::caffe::ContrastiveLossParameter& V1LayerParameter::_internal_contrastive_loss_param() const {
const ::caffe::ContrastiveLossParameter* p = contrastive_loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ContrastiveLossParameter&>(
::caffe::_ContrastiveLossParameter_default_instance_);
}
inline const ::caffe::ContrastiveLossParameter& V1LayerParameter::contrastive_loss_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.contrastive_loss_param)
return _internal_contrastive_loss_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_contrastive_loss_param(
::caffe::ContrastiveLossParameter* contrastive_loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(contrastive_loss_param_);
}
contrastive_loss_param_ = contrastive_loss_param;
if (contrastive_loss_param) {
_has_bits_[0] |= 0x20000000u;
} else {
_has_bits_[0] &= ~0x20000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.contrastive_loss_param)
}
inline ::caffe::ContrastiveLossParameter* V1LayerParameter::release_contrastive_loss_param() {
_has_bits_[0] &= ~0x20000000u;
::caffe::ContrastiveLossParameter* temp = contrastive_loss_param_;
contrastive_loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ContrastiveLossParameter* V1LayerParameter::unsafe_arena_release_contrastive_loss_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.contrastive_loss_param)
_has_bits_[0] &= ~0x20000000u;
::caffe::ContrastiveLossParameter* temp = contrastive_loss_param_;
contrastive_loss_param_ = nullptr;
return temp;
}
inline ::caffe::ContrastiveLossParameter* V1LayerParameter::_internal_mutable_contrastive_loss_param() {
_has_bits_[0] |= 0x20000000u;
if (contrastive_loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ContrastiveLossParameter>(GetArenaForAllocation());
contrastive_loss_param_ = p;
}
return contrastive_loss_param_;
}
inline ::caffe::ContrastiveLossParameter* V1LayerParameter::mutable_contrastive_loss_param() {
::caffe::ContrastiveLossParameter* _msg = _internal_mutable_contrastive_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.contrastive_loss_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete contrastive_loss_param_;
}
if (contrastive_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ContrastiveLossParameter>::GetOwningArena(contrastive_loss_param);
if (message_arena != submessage_arena) {
contrastive_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, contrastive_loss_param, submessage_arena);
}
_has_bits_[0] |= 0x20000000u;
} else {
_has_bits_[0] &= ~0x20000000u;
}
contrastive_loss_param_ = contrastive_loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.contrastive_loss_param)
}
// optional .caffe.ConvolutionParameter convolution_param = 10;
inline bool V1LayerParameter::_internal_has_convolution_param() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
PROTOBUF_ASSUME(!value || convolution_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_convolution_param() const {
return _internal_has_convolution_param();
}
inline void V1LayerParameter::clear_convolution_param() {
if (convolution_param_ != nullptr) convolution_param_->Clear();
_has_bits_[0] &= ~0x00000008u;
}
inline const ::caffe::ConvolutionParameter& V1LayerParameter::_internal_convolution_param() const {
const ::caffe::ConvolutionParameter* p = convolution_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ConvolutionParameter&>(
::caffe::_ConvolutionParameter_default_instance_);
}
inline const ::caffe::ConvolutionParameter& V1LayerParameter::convolution_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.convolution_param)
return _internal_convolution_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_convolution_param(
::caffe::ConvolutionParameter* convolution_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(convolution_param_);
}
convolution_param_ = convolution_param;
if (convolution_param) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.convolution_param)
}
inline ::caffe::ConvolutionParameter* V1LayerParameter::release_convolution_param() {
_has_bits_[0] &= ~0x00000008u;
::caffe::ConvolutionParameter* temp = convolution_param_;
convolution_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ConvolutionParameter* V1LayerParameter::unsafe_arena_release_convolution_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.convolution_param)
_has_bits_[0] &= ~0x00000008u;
::caffe::ConvolutionParameter* temp = convolution_param_;
convolution_param_ = nullptr;
return temp;
}
inline ::caffe::ConvolutionParameter* V1LayerParameter::_internal_mutable_convolution_param() {
_has_bits_[0] |= 0x00000008u;
if (convolution_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ConvolutionParameter>(GetArenaForAllocation());
convolution_param_ = p;
}
return convolution_param_;
}
inline ::caffe::ConvolutionParameter* V1LayerParameter::mutable_convolution_param() {
::caffe::ConvolutionParameter* _msg = _internal_mutable_convolution_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.convolution_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete convolution_param_;
}
if (convolution_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ConvolutionParameter>::GetOwningArena(convolution_param);
if (message_arena != submessage_arena) {
convolution_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, convolution_param, submessage_arena);
}
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
convolution_param_ = convolution_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.convolution_param)
}
// optional .caffe.DataParameter data_param = 11;
inline bool V1LayerParameter::_internal_has_data_param() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
PROTOBUF_ASSUME(!value || data_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_data_param() const {
return _internal_has_data_param();
}
inline void V1LayerParameter::clear_data_param() {
if (data_param_ != nullptr) data_param_->Clear();
_has_bits_[0] &= ~0x00000010u;
}
inline const ::caffe::DataParameter& V1LayerParameter::_internal_data_param() const {
const ::caffe::DataParameter* p = data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::DataParameter&>(
::caffe::_DataParameter_default_instance_);
}
inline const ::caffe::DataParameter& V1LayerParameter::data_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.data_param)
return _internal_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_data_param(
::caffe::DataParameter* data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(data_param_);
}
data_param_ = data_param;
if (data_param) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.data_param)
}
inline ::caffe::DataParameter* V1LayerParameter::release_data_param() {
_has_bits_[0] &= ~0x00000010u;
::caffe::DataParameter* temp = data_param_;
data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::DataParameter* V1LayerParameter::unsafe_arena_release_data_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.data_param)
_has_bits_[0] &= ~0x00000010u;
::caffe::DataParameter* temp = data_param_;
data_param_ = nullptr;
return temp;
}
inline ::caffe::DataParameter* V1LayerParameter::_internal_mutable_data_param() {
_has_bits_[0] |= 0x00000010u;
if (data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::DataParameter>(GetArenaForAllocation());
data_param_ = p;
}
return data_param_;
}
inline ::caffe::DataParameter* V1LayerParameter::mutable_data_param() {
::caffe::DataParameter* _msg = _internal_mutable_data_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.data_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_data_param(::caffe::DataParameter* data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete data_param_;
}
if (data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::DataParameter>::GetOwningArena(data_param);
if (message_arena != submessage_arena) {
data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, data_param, submessage_arena);
}
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
data_param_ = data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.data_param)
}
// optional .caffe.DropoutParameter dropout_param = 12;
inline bool V1LayerParameter::_internal_has_dropout_param() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
PROTOBUF_ASSUME(!value || dropout_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_dropout_param() const {
return _internal_has_dropout_param();
}
inline void V1LayerParameter::clear_dropout_param() {
if (dropout_param_ != nullptr) dropout_param_->Clear();
_has_bits_[0] &= ~0x00000020u;
}
inline const ::caffe::DropoutParameter& V1LayerParameter::_internal_dropout_param() const {
const ::caffe::DropoutParameter* p = dropout_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::DropoutParameter&>(
::caffe::_DropoutParameter_default_instance_);
}
inline const ::caffe::DropoutParameter& V1LayerParameter::dropout_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.dropout_param)
return _internal_dropout_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_dropout_param(
::caffe::DropoutParameter* dropout_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dropout_param_);
}
dropout_param_ = dropout_param;
if (dropout_param) {
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.dropout_param)
}
inline ::caffe::DropoutParameter* V1LayerParameter::release_dropout_param() {
_has_bits_[0] &= ~0x00000020u;
::caffe::DropoutParameter* temp = dropout_param_;
dropout_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::DropoutParameter* V1LayerParameter::unsafe_arena_release_dropout_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.dropout_param)
_has_bits_[0] &= ~0x00000020u;
::caffe::DropoutParameter* temp = dropout_param_;
dropout_param_ = nullptr;
return temp;
}
inline ::caffe::DropoutParameter* V1LayerParameter::_internal_mutable_dropout_param() {
_has_bits_[0] |= 0x00000020u;
if (dropout_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::DropoutParameter>(GetArenaForAllocation());
dropout_param_ = p;
}
return dropout_param_;
}
inline ::caffe::DropoutParameter* V1LayerParameter::mutable_dropout_param() {
::caffe::DropoutParameter* _msg = _internal_mutable_dropout_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.dropout_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete dropout_param_;
}
if (dropout_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::DropoutParameter>::GetOwningArena(dropout_param);
if (message_arena != submessage_arena) {
dropout_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, dropout_param, submessage_arena);
}
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
dropout_param_ = dropout_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.dropout_param)
}
// optional .caffe.DummyDataParameter dummy_data_param = 26;
inline bool V1LayerParameter::_internal_has_dummy_data_param() const {
bool value = (_has_bits_[0] & 0x00080000u) != 0;
PROTOBUF_ASSUME(!value || dummy_data_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_dummy_data_param() const {
return _internal_has_dummy_data_param();
}
inline void V1LayerParameter::clear_dummy_data_param() {
if (dummy_data_param_ != nullptr) dummy_data_param_->Clear();
_has_bits_[0] &= ~0x00080000u;
}
inline const ::caffe::DummyDataParameter& V1LayerParameter::_internal_dummy_data_param() const {
const ::caffe::DummyDataParameter* p = dummy_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::DummyDataParameter&>(
::caffe::_DummyDataParameter_default_instance_);
}
inline const ::caffe::DummyDataParameter& V1LayerParameter::dummy_data_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.dummy_data_param)
return _internal_dummy_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_dummy_data_param(
::caffe::DummyDataParameter* dummy_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dummy_data_param_);
}
dummy_data_param_ = dummy_data_param;
if (dummy_data_param) {
_has_bits_[0] |= 0x00080000u;
} else {
_has_bits_[0] &= ~0x00080000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.dummy_data_param)
}
inline ::caffe::DummyDataParameter* V1LayerParameter::release_dummy_data_param() {
_has_bits_[0] &= ~0x00080000u;
::caffe::DummyDataParameter* temp = dummy_data_param_;
dummy_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::DummyDataParameter* V1LayerParameter::unsafe_arena_release_dummy_data_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.dummy_data_param)
_has_bits_[0] &= ~0x00080000u;
::caffe::DummyDataParameter* temp = dummy_data_param_;
dummy_data_param_ = nullptr;
return temp;
}
inline ::caffe::DummyDataParameter* V1LayerParameter::_internal_mutable_dummy_data_param() {
_has_bits_[0] |= 0x00080000u;
if (dummy_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::DummyDataParameter>(GetArenaForAllocation());
dummy_data_param_ = p;
}
return dummy_data_param_;
}
inline ::caffe::DummyDataParameter* V1LayerParameter::mutable_dummy_data_param() {
::caffe::DummyDataParameter* _msg = _internal_mutable_dummy_data_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.dummy_data_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete dummy_data_param_;
}
if (dummy_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::DummyDataParameter>::GetOwningArena(dummy_data_param);
if (message_arena != submessage_arena) {
dummy_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, dummy_data_param, submessage_arena);
}
_has_bits_[0] |= 0x00080000u;
} else {
_has_bits_[0] &= ~0x00080000u;
}
dummy_data_param_ = dummy_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.dummy_data_param)
}
// optional .caffe.EltwiseParameter eltwise_param = 24;
inline bool V1LayerParameter::_internal_has_eltwise_param() const {
bool value = (_has_bits_[0] & 0x00020000u) != 0;
PROTOBUF_ASSUME(!value || eltwise_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_eltwise_param() const {
return _internal_has_eltwise_param();
}
inline void V1LayerParameter::clear_eltwise_param() {
if (eltwise_param_ != nullptr) eltwise_param_->Clear();
_has_bits_[0] &= ~0x00020000u;
}
inline const ::caffe::EltwiseParameter& V1LayerParameter::_internal_eltwise_param() const {
const ::caffe::EltwiseParameter* p = eltwise_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::EltwiseParameter&>(
::caffe::_EltwiseParameter_default_instance_);
}
inline const ::caffe::EltwiseParameter& V1LayerParameter::eltwise_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.eltwise_param)
return _internal_eltwise_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_eltwise_param(
::caffe::EltwiseParameter* eltwise_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(eltwise_param_);
}
eltwise_param_ = eltwise_param;
if (eltwise_param) {
_has_bits_[0] |= 0x00020000u;
} else {
_has_bits_[0] &= ~0x00020000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.eltwise_param)
}
inline ::caffe::EltwiseParameter* V1LayerParameter::release_eltwise_param() {
_has_bits_[0] &= ~0x00020000u;
::caffe::EltwiseParameter* temp = eltwise_param_;
eltwise_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::EltwiseParameter* V1LayerParameter::unsafe_arena_release_eltwise_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.eltwise_param)
_has_bits_[0] &= ~0x00020000u;
::caffe::EltwiseParameter* temp = eltwise_param_;
eltwise_param_ = nullptr;
return temp;
}
inline ::caffe::EltwiseParameter* V1LayerParameter::_internal_mutable_eltwise_param() {
_has_bits_[0] |= 0x00020000u;
if (eltwise_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::EltwiseParameter>(GetArenaForAllocation());
eltwise_param_ = p;
}
return eltwise_param_;
}
inline ::caffe::EltwiseParameter* V1LayerParameter::mutable_eltwise_param() {
::caffe::EltwiseParameter* _msg = _internal_mutable_eltwise_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.eltwise_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete eltwise_param_;
}
if (eltwise_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::EltwiseParameter>::GetOwningArena(eltwise_param);
if (message_arena != submessage_arena) {
eltwise_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, eltwise_param, submessage_arena);
}
_has_bits_[0] |= 0x00020000u;
} else {
_has_bits_[0] &= ~0x00020000u;
}
eltwise_param_ = eltwise_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.eltwise_param)
}
// optional .caffe.ExpParameter exp_param = 41;
inline bool V1LayerParameter::_internal_has_exp_param() const {
bool value = (_has_bits_[0] & 0x40000000u) != 0;
PROTOBUF_ASSUME(!value || exp_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_exp_param() const {
return _internal_has_exp_param();
}
inline void V1LayerParameter::clear_exp_param() {
if (exp_param_ != nullptr) exp_param_->Clear();
_has_bits_[0] &= ~0x40000000u;
}
inline const ::caffe::ExpParameter& V1LayerParameter::_internal_exp_param() const {
const ::caffe::ExpParameter* p = exp_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ExpParameter&>(
::caffe::_ExpParameter_default_instance_);
}
inline const ::caffe::ExpParameter& V1LayerParameter::exp_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.exp_param)
return _internal_exp_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_exp_param(
::caffe::ExpParameter* exp_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(exp_param_);
}
exp_param_ = exp_param;
if (exp_param) {
_has_bits_[0] |= 0x40000000u;
} else {
_has_bits_[0] &= ~0x40000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.exp_param)
}
inline ::caffe::ExpParameter* V1LayerParameter::release_exp_param() {
_has_bits_[0] &= ~0x40000000u;
::caffe::ExpParameter* temp = exp_param_;
exp_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ExpParameter* V1LayerParameter::unsafe_arena_release_exp_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.exp_param)
_has_bits_[0] &= ~0x40000000u;
::caffe::ExpParameter* temp = exp_param_;
exp_param_ = nullptr;
return temp;
}
inline ::caffe::ExpParameter* V1LayerParameter::_internal_mutable_exp_param() {
_has_bits_[0] |= 0x40000000u;
if (exp_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ExpParameter>(GetArenaForAllocation());
exp_param_ = p;
}
return exp_param_;
}
inline ::caffe::ExpParameter* V1LayerParameter::mutable_exp_param() {
::caffe::ExpParameter* _msg = _internal_mutable_exp_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.exp_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_exp_param(::caffe::ExpParameter* exp_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete exp_param_;
}
if (exp_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ExpParameter>::GetOwningArena(exp_param);
if (message_arena != submessage_arena) {
exp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, exp_param, submessage_arena);
}
_has_bits_[0] |= 0x40000000u;
} else {
_has_bits_[0] &= ~0x40000000u;
}
exp_param_ = exp_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.exp_param)
}
// optional .caffe.HDF5DataParameter hdf5_data_param = 13;
inline bool V1LayerParameter::_internal_has_hdf5_data_param() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
PROTOBUF_ASSUME(!value || hdf5_data_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_hdf5_data_param() const {
return _internal_has_hdf5_data_param();
}
inline void V1LayerParameter::clear_hdf5_data_param() {
if (hdf5_data_param_ != nullptr) hdf5_data_param_->Clear();
_has_bits_[0] &= ~0x00000040u;
}
inline const ::caffe::HDF5DataParameter& V1LayerParameter::_internal_hdf5_data_param() const {
const ::caffe::HDF5DataParameter* p = hdf5_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::HDF5DataParameter&>(
::caffe::_HDF5DataParameter_default_instance_);
}
inline const ::caffe::HDF5DataParameter& V1LayerParameter::hdf5_data_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.hdf5_data_param)
return _internal_hdf5_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_hdf5_data_param(
::caffe::HDF5DataParameter* hdf5_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_data_param_);
}
hdf5_data_param_ = hdf5_data_param;
if (hdf5_data_param) {
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.hdf5_data_param)
}
inline ::caffe::HDF5DataParameter* V1LayerParameter::release_hdf5_data_param() {
_has_bits_[0] &= ~0x00000040u;
::caffe::HDF5DataParameter* temp = hdf5_data_param_;
hdf5_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::HDF5DataParameter* V1LayerParameter::unsafe_arena_release_hdf5_data_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.hdf5_data_param)
_has_bits_[0] &= ~0x00000040u;
::caffe::HDF5DataParameter* temp = hdf5_data_param_;
hdf5_data_param_ = nullptr;
return temp;
}
inline ::caffe::HDF5DataParameter* V1LayerParameter::_internal_mutable_hdf5_data_param() {
_has_bits_[0] |= 0x00000040u;
if (hdf5_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::HDF5DataParameter>(GetArenaForAllocation());
hdf5_data_param_ = p;
}
return hdf5_data_param_;
}
inline ::caffe::HDF5DataParameter* V1LayerParameter::mutable_hdf5_data_param() {
::caffe::HDF5DataParameter* _msg = _internal_mutable_hdf5_data_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.hdf5_data_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete hdf5_data_param_;
}
if (hdf5_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::HDF5DataParameter>::GetOwningArena(hdf5_data_param);
if (message_arena != submessage_arena) {
hdf5_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, hdf5_data_param, submessage_arena);
}
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
hdf5_data_param_ = hdf5_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.hdf5_data_param)
}
// optional .caffe.HDF5OutputParameter hdf5_output_param = 14;
inline bool V1LayerParameter::_internal_has_hdf5_output_param() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
PROTOBUF_ASSUME(!value || hdf5_output_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_hdf5_output_param() const {
return _internal_has_hdf5_output_param();
}
inline void V1LayerParameter::clear_hdf5_output_param() {
if (hdf5_output_param_ != nullptr) hdf5_output_param_->Clear();
_has_bits_[0] &= ~0x00000080u;
}
inline const ::caffe::HDF5OutputParameter& V1LayerParameter::_internal_hdf5_output_param() const {
const ::caffe::HDF5OutputParameter* p = hdf5_output_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::HDF5OutputParameter&>(
::caffe::_HDF5OutputParameter_default_instance_);
}
inline const ::caffe::HDF5OutputParameter& V1LayerParameter::hdf5_output_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.hdf5_output_param)
return _internal_hdf5_output_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_hdf5_output_param(
::caffe::HDF5OutputParameter* hdf5_output_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_output_param_);
}
hdf5_output_param_ = hdf5_output_param;
if (hdf5_output_param) {
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.hdf5_output_param)
}
inline ::caffe::HDF5OutputParameter* V1LayerParameter::release_hdf5_output_param() {
_has_bits_[0] &= ~0x00000080u;
::caffe::HDF5OutputParameter* temp = hdf5_output_param_;
hdf5_output_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::HDF5OutputParameter* V1LayerParameter::unsafe_arena_release_hdf5_output_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.hdf5_output_param)
_has_bits_[0] &= ~0x00000080u;
::caffe::HDF5OutputParameter* temp = hdf5_output_param_;
hdf5_output_param_ = nullptr;
return temp;
}
inline ::caffe::HDF5OutputParameter* V1LayerParameter::_internal_mutable_hdf5_output_param() {
_has_bits_[0] |= 0x00000080u;
if (hdf5_output_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::HDF5OutputParameter>(GetArenaForAllocation());
hdf5_output_param_ = p;
}
return hdf5_output_param_;
}
inline ::caffe::HDF5OutputParameter* V1LayerParameter::mutable_hdf5_output_param() {
::caffe::HDF5OutputParameter* _msg = _internal_mutable_hdf5_output_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.hdf5_output_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete hdf5_output_param_;
}
if (hdf5_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::HDF5OutputParameter>::GetOwningArena(hdf5_output_param);
if (message_arena != submessage_arena) {
hdf5_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, hdf5_output_param, submessage_arena);
}
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
hdf5_output_param_ = hdf5_output_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.hdf5_output_param)
}
// optional .caffe.HingeLossParameter hinge_loss_param = 29;
inline bool V1LayerParameter::_internal_has_hinge_loss_param() const {
bool value = (_has_bits_[0] & 0x00200000u) != 0;
PROTOBUF_ASSUME(!value || hinge_loss_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_hinge_loss_param() const {
return _internal_has_hinge_loss_param();
}
inline void V1LayerParameter::clear_hinge_loss_param() {
if (hinge_loss_param_ != nullptr) hinge_loss_param_->Clear();
_has_bits_[0] &= ~0x00200000u;
}
inline const ::caffe::HingeLossParameter& V1LayerParameter::_internal_hinge_loss_param() const {
const ::caffe::HingeLossParameter* p = hinge_loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::HingeLossParameter&>(
::caffe::_HingeLossParameter_default_instance_);
}
inline const ::caffe::HingeLossParameter& V1LayerParameter::hinge_loss_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.hinge_loss_param)
return _internal_hinge_loss_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_hinge_loss_param(
::caffe::HingeLossParameter* hinge_loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hinge_loss_param_);
}
hinge_loss_param_ = hinge_loss_param;
if (hinge_loss_param) {
_has_bits_[0] |= 0x00200000u;
} else {
_has_bits_[0] &= ~0x00200000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.hinge_loss_param)
}
inline ::caffe::HingeLossParameter* V1LayerParameter::release_hinge_loss_param() {
_has_bits_[0] &= ~0x00200000u;
::caffe::HingeLossParameter* temp = hinge_loss_param_;
hinge_loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::HingeLossParameter* V1LayerParameter::unsafe_arena_release_hinge_loss_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.hinge_loss_param)
_has_bits_[0] &= ~0x00200000u;
::caffe::HingeLossParameter* temp = hinge_loss_param_;
hinge_loss_param_ = nullptr;
return temp;
}
inline ::caffe::HingeLossParameter* V1LayerParameter::_internal_mutable_hinge_loss_param() {
_has_bits_[0] |= 0x00200000u;
if (hinge_loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::HingeLossParameter>(GetArenaForAllocation());
hinge_loss_param_ = p;
}
return hinge_loss_param_;
}
inline ::caffe::HingeLossParameter* V1LayerParameter::mutable_hinge_loss_param() {
::caffe::HingeLossParameter* _msg = _internal_mutable_hinge_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.hinge_loss_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete hinge_loss_param_;
}
if (hinge_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::HingeLossParameter>::GetOwningArena(hinge_loss_param);
if (message_arena != submessage_arena) {
hinge_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, hinge_loss_param, submessage_arena);
}
_has_bits_[0] |= 0x00200000u;
} else {
_has_bits_[0] &= ~0x00200000u;
}
hinge_loss_param_ = hinge_loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.hinge_loss_param)
}
// optional .caffe.ImageDataParameter image_data_param = 15;
inline bool V1LayerParameter::_internal_has_image_data_param() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
PROTOBUF_ASSUME(!value || image_data_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_image_data_param() const {
return _internal_has_image_data_param();
}
inline void V1LayerParameter::clear_image_data_param() {
if (image_data_param_ != nullptr) image_data_param_->Clear();
_has_bits_[0] &= ~0x00000100u;
}
inline const ::caffe::ImageDataParameter& V1LayerParameter::_internal_image_data_param() const {
const ::caffe::ImageDataParameter* p = image_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ImageDataParameter&>(
::caffe::_ImageDataParameter_default_instance_);
}
inline const ::caffe::ImageDataParameter& V1LayerParameter::image_data_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.image_data_param)
return _internal_image_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_image_data_param(
::caffe::ImageDataParameter* image_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(image_data_param_);
}
image_data_param_ = image_data_param;
if (image_data_param) {
_has_bits_[0] |= 0x00000100u;
} else {
_has_bits_[0] &= ~0x00000100u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.image_data_param)
}
inline ::caffe::ImageDataParameter* V1LayerParameter::release_image_data_param() {
_has_bits_[0] &= ~0x00000100u;
::caffe::ImageDataParameter* temp = image_data_param_;
image_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ImageDataParameter* V1LayerParameter::unsafe_arena_release_image_data_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.image_data_param)
_has_bits_[0] &= ~0x00000100u;
::caffe::ImageDataParameter* temp = image_data_param_;
image_data_param_ = nullptr;
return temp;
}
inline ::caffe::ImageDataParameter* V1LayerParameter::_internal_mutable_image_data_param() {
_has_bits_[0] |= 0x00000100u;
if (image_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ImageDataParameter>(GetArenaForAllocation());
image_data_param_ = p;
}
return image_data_param_;
}
inline ::caffe::ImageDataParameter* V1LayerParameter::mutable_image_data_param() {
::caffe::ImageDataParameter* _msg = _internal_mutable_image_data_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.image_data_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete image_data_param_;
}
if (image_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ImageDataParameter>::GetOwningArena(image_data_param);
if (message_arena != submessage_arena) {
image_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, image_data_param, submessage_arena);
}
_has_bits_[0] |= 0x00000100u;
} else {
_has_bits_[0] &= ~0x00000100u;
}
image_data_param_ = image_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.image_data_param)
}
// optional .caffe.InfogainLossParameter infogain_loss_param = 16;
inline bool V1LayerParameter::_internal_has_infogain_loss_param() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
PROTOBUF_ASSUME(!value || infogain_loss_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_infogain_loss_param() const {
return _internal_has_infogain_loss_param();
}
inline void V1LayerParameter::clear_infogain_loss_param() {
if (infogain_loss_param_ != nullptr) infogain_loss_param_->Clear();
_has_bits_[0] &= ~0x00000200u;
}
inline const ::caffe::InfogainLossParameter& V1LayerParameter::_internal_infogain_loss_param() const {
const ::caffe::InfogainLossParameter* p = infogain_loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::InfogainLossParameter&>(
::caffe::_InfogainLossParameter_default_instance_);
}
inline const ::caffe::InfogainLossParameter& V1LayerParameter::infogain_loss_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.infogain_loss_param)
return _internal_infogain_loss_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_infogain_loss_param(
::caffe::InfogainLossParameter* infogain_loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(infogain_loss_param_);
}
infogain_loss_param_ = infogain_loss_param;
if (infogain_loss_param) {
_has_bits_[0] |= 0x00000200u;
} else {
_has_bits_[0] &= ~0x00000200u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.infogain_loss_param)
}
inline ::caffe::InfogainLossParameter* V1LayerParameter::release_infogain_loss_param() {
_has_bits_[0] &= ~0x00000200u;
::caffe::InfogainLossParameter* temp = infogain_loss_param_;
infogain_loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::InfogainLossParameter* V1LayerParameter::unsafe_arena_release_infogain_loss_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.infogain_loss_param)
_has_bits_[0] &= ~0x00000200u;
::caffe::InfogainLossParameter* temp = infogain_loss_param_;
infogain_loss_param_ = nullptr;
return temp;
}
inline ::caffe::InfogainLossParameter* V1LayerParameter::_internal_mutable_infogain_loss_param() {
_has_bits_[0] |= 0x00000200u;
if (infogain_loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::InfogainLossParameter>(GetArenaForAllocation());
infogain_loss_param_ = p;
}
return infogain_loss_param_;
}
inline ::caffe::InfogainLossParameter* V1LayerParameter::mutable_infogain_loss_param() {
::caffe::InfogainLossParameter* _msg = _internal_mutable_infogain_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.infogain_loss_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete infogain_loss_param_;
}
if (infogain_loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::InfogainLossParameter>::GetOwningArena(infogain_loss_param);
if (message_arena != submessage_arena) {
infogain_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, infogain_loss_param, submessage_arena);
}
_has_bits_[0] |= 0x00000200u;
} else {
_has_bits_[0] &= ~0x00000200u;
}
infogain_loss_param_ = infogain_loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.infogain_loss_param)
}
// optional .caffe.InnerProductParameter inner_product_param = 17;
inline bool V1LayerParameter::_internal_has_inner_product_param() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
PROTOBUF_ASSUME(!value || inner_product_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_inner_product_param() const {
return _internal_has_inner_product_param();
}
inline void V1LayerParameter::clear_inner_product_param() {
if (inner_product_param_ != nullptr) inner_product_param_->Clear();
_has_bits_[0] &= ~0x00000400u;
}
inline const ::caffe::InnerProductParameter& V1LayerParameter::_internal_inner_product_param() const {
const ::caffe::InnerProductParameter* p = inner_product_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::InnerProductParameter&>(
::caffe::_InnerProductParameter_default_instance_);
}
inline const ::caffe::InnerProductParameter& V1LayerParameter::inner_product_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.inner_product_param)
return _internal_inner_product_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_inner_product_param(
::caffe::InnerProductParameter* inner_product_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(inner_product_param_);
}
inner_product_param_ = inner_product_param;
if (inner_product_param) {
_has_bits_[0] |= 0x00000400u;
} else {
_has_bits_[0] &= ~0x00000400u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.inner_product_param)
}
inline ::caffe::InnerProductParameter* V1LayerParameter::release_inner_product_param() {
_has_bits_[0] &= ~0x00000400u;
::caffe::InnerProductParameter* temp = inner_product_param_;
inner_product_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::InnerProductParameter* V1LayerParameter::unsafe_arena_release_inner_product_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.inner_product_param)
_has_bits_[0] &= ~0x00000400u;
::caffe::InnerProductParameter* temp = inner_product_param_;
inner_product_param_ = nullptr;
return temp;
}
inline ::caffe::InnerProductParameter* V1LayerParameter::_internal_mutable_inner_product_param() {
_has_bits_[0] |= 0x00000400u;
if (inner_product_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::InnerProductParameter>(GetArenaForAllocation());
inner_product_param_ = p;
}
return inner_product_param_;
}
inline ::caffe::InnerProductParameter* V1LayerParameter::mutable_inner_product_param() {
::caffe::InnerProductParameter* _msg = _internal_mutable_inner_product_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.inner_product_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete inner_product_param_;
}
if (inner_product_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::InnerProductParameter>::GetOwningArena(inner_product_param);
if (message_arena != submessage_arena) {
inner_product_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, inner_product_param, submessage_arena);
}
_has_bits_[0] |= 0x00000400u;
} else {
_has_bits_[0] &= ~0x00000400u;
}
inner_product_param_ = inner_product_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.inner_product_param)
}
// optional .caffe.LRNParameter lrn_param = 18;
inline bool V1LayerParameter::_internal_has_lrn_param() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
PROTOBUF_ASSUME(!value || lrn_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_lrn_param() const {
return _internal_has_lrn_param();
}
inline void V1LayerParameter::clear_lrn_param() {
if (lrn_param_ != nullptr) lrn_param_->Clear();
_has_bits_[0] &= ~0x00000800u;
}
inline const ::caffe::LRNParameter& V1LayerParameter::_internal_lrn_param() const {
const ::caffe::LRNParameter* p = lrn_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::LRNParameter&>(
::caffe::_LRNParameter_default_instance_);
}
inline const ::caffe::LRNParameter& V1LayerParameter::lrn_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.lrn_param)
return _internal_lrn_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_lrn_param(
::caffe::LRNParameter* lrn_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lrn_param_);
}
lrn_param_ = lrn_param;
if (lrn_param) {
_has_bits_[0] |= 0x00000800u;
} else {
_has_bits_[0] &= ~0x00000800u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.lrn_param)
}
inline ::caffe::LRNParameter* V1LayerParameter::release_lrn_param() {
_has_bits_[0] &= ~0x00000800u;
::caffe::LRNParameter* temp = lrn_param_;
lrn_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::LRNParameter* V1LayerParameter::unsafe_arena_release_lrn_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.lrn_param)
_has_bits_[0] &= ~0x00000800u;
::caffe::LRNParameter* temp = lrn_param_;
lrn_param_ = nullptr;
return temp;
}
inline ::caffe::LRNParameter* V1LayerParameter::_internal_mutable_lrn_param() {
_has_bits_[0] |= 0x00000800u;
if (lrn_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::LRNParameter>(GetArenaForAllocation());
lrn_param_ = p;
}
return lrn_param_;
}
inline ::caffe::LRNParameter* V1LayerParameter::mutable_lrn_param() {
::caffe::LRNParameter* _msg = _internal_mutable_lrn_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.lrn_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_lrn_param(::caffe::LRNParameter* lrn_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete lrn_param_;
}
if (lrn_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::LRNParameter>::GetOwningArena(lrn_param);
if (message_arena != submessage_arena) {
lrn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, lrn_param, submessage_arena);
}
_has_bits_[0] |= 0x00000800u;
} else {
_has_bits_[0] &= ~0x00000800u;
}
lrn_param_ = lrn_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.lrn_param)
}
// optional .caffe.MemoryDataParameter memory_data_param = 22;
inline bool V1LayerParameter::_internal_has_memory_data_param() const {
bool value = (_has_bits_[0] & 0x00008000u) != 0;
PROTOBUF_ASSUME(!value || memory_data_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_memory_data_param() const {
return _internal_has_memory_data_param();
}
inline void V1LayerParameter::clear_memory_data_param() {
if (memory_data_param_ != nullptr) memory_data_param_->Clear();
_has_bits_[0] &= ~0x00008000u;
}
inline const ::caffe::MemoryDataParameter& V1LayerParameter::_internal_memory_data_param() const {
const ::caffe::MemoryDataParameter* p = memory_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::MemoryDataParameter&>(
::caffe::_MemoryDataParameter_default_instance_);
}
inline const ::caffe::MemoryDataParameter& V1LayerParameter::memory_data_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.memory_data_param)
return _internal_memory_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_memory_data_param(
::caffe::MemoryDataParameter* memory_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(memory_data_param_);
}
memory_data_param_ = memory_data_param;
if (memory_data_param) {
_has_bits_[0] |= 0x00008000u;
} else {
_has_bits_[0] &= ~0x00008000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.memory_data_param)
}
inline ::caffe::MemoryDataParameter* V1LayerParameter::release_memory_data_param() {
_has_bits_[0] &= ~0x00008000u;
::caffe::MemoryDataParameter* temp = memory_data_param_;
memory_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::MemoryDataParameter* V1LayerParameter::unsafe_arena_release_memory_data_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.memory_data_param)
_has_bits_[0] &= ~0x00008000u;
::caffe::MemoryDataParameter* temp = memory_data_param_;
memory_data_param_ = nullptr;
return temp;
}
inline ::caffe::MemoryDataParameter* V1LayerParameter::_internal_mutable_memory_data_param() {
_has_bits_[0] |= 0x00008000u;
if (memory_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::MemoryDataParameter>(GetArenaForAllocation());
memory_data_param_ = p;
}
return memory_data_param_;
}
inline ::caffe::MemoryDataParameter* V1LayerParameter::mutable_memory_data_param() {
::caffe::MemoryDataParameter* _msg = _internal_mutable_memory_data_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.memory_data_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete memory_data_param_;
}
if (memory_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::MemoryDataParameter>::GetOwningArena(memory_data_param);
if (message_arena != submessage_arena) {
memory_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, memory_data_param, submessage_arena);
}
_has_bits_[0] |= 0x00008000u;
} else {
_has_bits_[0] &= ~0x00008000u;
}
memory_data_param_ = memory_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.memory_data_param)
}
// optional .caffe.MVNParameter mvn_param = 34;
inline bool V1LayerParameter::_internal_has_mvn_param() const {
bool value = (_has_bits_[0] & 0x01000000u) != 0;
PROTOBUF_ASSUME(!value || mvn_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_mvn_param() const {
return _internal_has_mvn_param();
}
inline void V1LayerParameter::clear_mvn_param() {
if (mvn_param_ != nullptr) mvn_param_->Clear();
_has_bits_[0] &= ~0x01000000u;
}
inline const ::caffe::MVNParameter& V1LayerParameter::_internal_mvn_param() const {
const ::caffe::MVNParameter* p = mvn_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::MVNParameter&>(
::caffe::_MVNParameter_default_instance_);
}
inline const ::caffe::MVNParameter& V1LayerParameter::mvn_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.mvn_param)
return _internal_mvn_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_mvn_param(
::caffe::MVNParameter* mvn_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mvn_param_);
}
mvn_param_ = mvn_param;
if (mvn_param) {
_has_bits_[0] |= 0x01000000u;
} else {
_has_bits_[0] &= ~0x01000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.mvn_param)
}
inline ::caffe::MVNParameter* V1LayerParameter::release_mvn_param() {
_has_bits_[0] &= ~0x01000000u;
::caffe::MVNParameter* temp = mvn_param_;
mvn_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::MVNParameter* V1LayerParameter::unsafe_arena_release_mvn_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.mvn_param)
_has_bits_[0] &= ~0x01000000u;
::caffe::MVNParameter* temp = mvn_param_;
mvn_param_ = nullptr;
return temp;
}
inline ::caffe::MVNParameter* V1LayerParameter::_internal_mutable_mvn_param() {
_has_bits_[0] |= 0x01000000u;
if (mvn_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::MVNParameter>(GetArenaForAllocation());
mvn_param_ = p;
}
return mvn_param_;
}
inline ::caffe::MVNParameter* V1LayerParameter::mutable_mvn_param() {
::caffe::MVNParameter* _msg = _internal_mutable_mvn_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.mvn_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_mvn_param(::caffe::MVNParameter* mvn_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete mvn_param_;
}
if (mvn_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::MVNParameter>::GetOwningArena(mvn_param);
if (message_arena != submessage_arena) {
mvn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, mvn_param, submessage_arena);
}
_has_bits_[0] |= 0x01000000u;
} else {
_has_bits_[0] &= ~0x01000000u;
}
mvn_param_ = mvn_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.mvn_param)
}
// optional .caffe.PoolingParameter pooling_param = 19;
inline bool V1LayerParameter::_internal_has_pooling_param() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
PROTOBUF_ASSUME(!value || pooling_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_pooling_param() const {
return _internal_has_pooling_param();
}
inline void V1LayerParameter::clear_pooling_param() {
if (pooling_param_ != nullptr) pooling_param_->Clear();
_has_bits_[0] &= ~0x00001000u;
}
inline const ::caffe::PoolingParameter& V1LayerParameter::_internal_pooling_param() const {
const ::caffe::PoolingParameter* p = pooling_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::PoolingParameter&>(
::caffe::_PoolingParameter_default_instance_);
}
inline const ::caffe::PoolingParameter& V1LayerParameter::pooling_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.pooling_param)
return _internal_pooling_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_pooling_param(
::caffe::PoolingParameter* pooling_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pooling_param_);
}
pooling_param_ = pooling_param;
if (pooling_param) {
_has_bits_[0] |= 0x00001000u;
} else {
_has_bits_[0] &= ~0x00001000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.pooling_param)
}
inline ::caffe::PoolingParameter* V1LayerParameter::release_pooling_param() {
_has_bits_[0] &= ~0x00001000u;
::caffe::PoolingParameter* temp = pooling_param_;
pooling_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::PoolingParameter* V1LayerParameter::unsafe_arena_release_pooling_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.pooling_param)
_has_bits_[0] &= ~0x00001000u;
::caffe::PoolingParameter* temp = pooling_param_;
pooling_param_ = nullptr;
return temp;
}
inline ::caffe::PoolingParameter* V1LayerParameter::_internal_mutable_pooling_param() {
_has_bits_[0] |= 0x00001000u;
if (pooling_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::PoolingParameter>(GetArenaForAllocation());
pooling_param_ = p;
}
return pooling_param_;
}
inline ::caffe::PoolingParameter* V1LayerParameter::mutable_pooling_param() {
::caffe::PoolingParameter* _msg = _internal_mutable_pooling_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.pooling_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete pooling_param_;
}
if (pooling_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::PoolingParameter>::GetOwningArena(pooling_param);
if (message_arena != submessage_arena) {
pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, pooling_param, submessage_arena);
}
_has_bits_[0] |= 0x00001000u;
} else {
_has_bits_[0] &= ~0x00001000u;
}
pooling_param_ = pooling_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.pooling_param)
}
// optional .caffe.PowerParameter power_param = 21;
inline bool V1LayerParameter::_internal_has_power_param() const {
bool value = (_has_bits_[0] & 0x00004000u) != 0;
PROTOBUF_ASSUME(!value || power_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_power_param() const {
return _internal_has_power_param();
}
inline void V1LayerParameter::clear_power_param() {
if (power_param_ != nullptr) power_param_->Clear();
_has_bits_[0] &= ~0x00004000u;
}
inline const ::caffe::PowerParameter& V1LayerParameter::_internal_power_param() const {
const ::caffe::PowerParameter* p = power_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::PowerParameter&>(
::caffe::_PowerParameter_default_instance_);
}
inline const ::caffe::PowerParameter& V1LayerParameter::power_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.power_param)
return _internal_power_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_power_param(
::caffe::PowerParameter* power_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(power_param_);
}
power_param_ = power_param;
if (power_param) {
_has_bits_[0] |= 0x00004000u;
} else {
_has_bits_[0] &= ~0x00004000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.power_param)
}
inline ::caffe::PowerParameter* V1LayerParameter::release_power_param() {
_has_bits_[0] &= ~0x00004000u;
::caffe::PowerParameter* temp = power_param_;
power_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::PowerParameter* V1LayerParameter::unsafe_arena_release_power_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.power_param)
_has_bits_[0] &= ~0x00004000u;
::caffe::PowerParameter* temp = power_param_;
power_param_ = nullptr;
return temp;
}
inline ::caffe::PowerParameter* V1LayerParameter::_internal_mutable_power_param() {
_has_bits_[0] |= 0x00004000u;
if (power_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::PowerParameter>(GetArenaForAllocation());
power_param_ = p;
}
return power_param_;
}
inline ::caffe::PowerParameter* V1LayerParameter::mutable_power_param() {
::caffe::PowerParameter* _msg = _internal_mutable_power_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.power_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_power_param(::caffe::PowerParameter* power_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete power_param_;
}
if (power_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::PowerParameter>::GetOwningArena(power_param);
if (message_arena != submessage_arena) {
power_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, power_param, submessage_arena);
}
_has_bits_[0] |= 0x00004000u;
} else {
_has_bits_[0] &= ~0x00004000u;
}
power_param_ = power_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.power_param)
}
// optional .caffe.ReLUParameter relu_param = 30;
inline bool V1LayerParameter::_internal_has_relu_param() const {
bool value = (_has_bits_[0] & 0x00400000u) != 0;
PROTOBUF_ASSUME(!value || relu_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_relu_param() const {
return _internal_has_relu_param();
}
inline void V1LayerParameter::clear_relu_param() {
if (relu_param_ != nullptr) relu_param_->Clear();
_has_bits_[0] &= ~0x00400000u;
}
inline const ::caffe::ReLUParameter& V1LayerParameter::_internal_relu_param() const {
const ::caffe::ReLUParameter* p = relu_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ReLUParameter&>(
::caffe::_ReLUParameter_default_instance_);
}
inline const ::caffe::ReLUParameter& V1LayerParameter::relu_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.relu_param)
return _internal_relu_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_relu_param(
::caffe::ReLUParameter* relu_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relu_param_);
}
relu_param_ = relu_param;
if (relu_param) {
_has_bits_[0] |= 0x00400000u;
} else {
_has_bits_[0] &= ~0x00400000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.relu_param)
}
inline ::caffe::ReLUParameter* V1LayerParameter::release_relu_param() {
_has_bits_[0] &= ~0x00400000u;
::caffe::ReLUParameter* temp = relu_param_;
relu_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ReLUParameter* V1LayerParameter::unsafe_arena_release_relu_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.relu_param)
_has_bits_[0] &= ~0x00400000u;
::caffe::ReLUParameter* temp = relu_param_;
relu_param_ = nullptr;
return temp;
}
inline ::caffe::ReLUParameter* V1LayerParameter::_internal_mutable_relu_param() {
_has_bits_[0] |= 0x00400000u;
if (relu_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ReLUParameter>(GetArenaForAllocation());
relu_param_ = p;
}
return relu_param_;
}
inline ::caffe::ReLUParameter* V1LayerParameter::mutable_relu_param() {
::caffe::ReLUParameter* _msg = _internal_mutable_relu_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.relu_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_relu_param(::caffe::ReLUParameter* relu_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete relu_param_;
}
if (relu_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ReLUParameter>::GetOwningArena(relu_param);
if (message_arena != submessage_arena) {
relu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, relu_param, submessage_arena);
}
_has_bits_[0] |= 0x00400000u;
} else {
_has_bits_[0] &= ~0x00400000u;
}
relu_param_ = relu_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.relu_param)
}
// optional .caffe.SigmoidParameter sigmoid_param = 38;
inline bool V1LayerParameter::_internal_has_sigmoid_param() const {
bool value = (_has_bits_[0] & 0x08000000u) != 0;
PROTOBUF_ASSUME(!value || sigmoid_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_sigmoid_param() const {
return _internal_has_sigmoid_param();
}
inline void V1LayerParameter::clear_sigmoid_param() {
if (sigmoid_param_ != nullptr) sigmoid_param_->Clear();
_has_bits_[0] &= ~0x08000000u;
}
inline const ::caffe::SigmoidParameter& V1LayerParameter::_internal_sigmoid_param() const {
const ::caffe::SigmoidParameter* p = sigmoid_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SigmoidParameter&>(
::caffe::_SigmoidParameter_default_instance_);
}
inline const ::caffe::SigmoidParameter& V1LayerParameter::sigmoid_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.sigmoid_param)
return _internal_sigmoid_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_sigmoid_param(
::caffe::SigmoidParameter* sigmoid_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sigmoid_param_);
}
sigmoid_param_ = sigmoid_param;
if (sigmoid_param) {
_has_bits_[0] |= 0x08000000u;
} else {
_has_bits_[0] &= ~0x08000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.sigmoid_param)
}
inline ::caffe::SigmoidParameter* V1LayerParameter::release_sigmoid_param() {
_has_bits_[0] &= ~0x08000000u;
::caffe::SigmoidParameter* temp = sigmoid_param_;
sigmoid_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SigmoidParameter* V1LayerParameter::unsafe_arena_release_sigmoid_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.sigmoid_param)
_has_bits_[0] &= ~0x08000000u;
::caffe::SigmoidParameter* temp = sigmoid_param_;
sigmoid_param_ = nullptr;
return temp;
}
inline ::caffe::SigmoidParameter* V1LayerParameter::_internal_mutable_sigmoid_param() {
_has_bits_[0] |= 0x08000000u;
if (sigmoid_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SigmoidParameter>(GetArenaForAllocation());
sigmoid_param_ = p;
}
return sigmoid_param_;
}
inline ::caffe::SigmoidParameter* V1LayerParameter::mutable_sigmoid_param() {
::caffe::SigmoidParameter* _msg = _internal_mutable_sigmoid_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.sigmoid_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete sigmoid_param_;
}
if (sigmoid_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SigmoidParameter>::GetOwningArena(sigmoid_param);
if (message_arena != submessage_arena) {
sigmoid_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, sigmoid_param, submessage_arena);
}
_has_bits_[0] |= 0x08000000u;
} else {
_has_bits_[0] &= ~0x08000000u;
}
sigmoid_param_ = sigmoid_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.sigmoid_param)
}
// optional .caffe.SoftmaxParameter softmax_param = 39;
inline bool V1LayerParameter::_internal_has_softmax_param() const {
bool value = (_has_bits_[0] & 0x10000000u) != 0;
PROTOBUF_ASSUME(!value || softmax_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_softmax_param() const {
return _internal_has_softmax_param();
}
inline void V1LayerParameter::clear_softmax_param() {
if (softmax_param_ != nullptr) softmax_param_->Clear();
_has_bits_[0] &= ~0x10000000u;
}
inline const ::caffe::SoftmaxParameter& V1LayerParameter::_internal_softmax_param() const {
const ::caffe::SoftmaxParameter* p = softmax_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SoftmaxParameter&>(
::caffe::_SoftmaxParameter_default_instance_);
}
inline const ::caffe::SoftmaxParameter& V1LayerParameter::softmax_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.softmax_param)
return _internal_softmax_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_softmax_param(
::caffe::SoftmaxParameter* softmax_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(softmax_param_);
}
softmax_param_ = softmax_param;
if (softmax_param) {
_has_bits_[0] |= 0x10000000u;
} else {
_has_bits_[0] &= ~0x10000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.softmax_param)
}
inline ::caffe::SoftmaxParameter* V1LayerParameter::release_softmax_param() {
_has_bits_[0] &= ~0x10000000u;
::caffe::SoftmaxParameter* temp = softmax_param_;
softmax_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SoftmaxParameter* V1LayerParameter::unsafe_arena_release_softmax_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.softmax_param)
_has_bits_[0] &= ~0x10000000u;
::caffe::SoftmaxParameter* temp = softmax_param_;
softmax_param_ = nullptr;
return temp;
}
inline ::caffe::SoftmaxParameter* V1LayerParameter::_internal_mutable_softmax_param() {
_has_bits_[0] |= 0x10000000u;
if (softmax_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SoftmaxParameter>(GetArenaForAllocation());
softmax_param_ = p;
}
return softmax_param_;
}
inline ::caffe::SoftmaxParameter* V1LayerParameter::mutable_softmax_param() {
::caffe::SoftmaxParameter* _msg = _internal_mutable_softmax_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.softmax_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete softmax_param_;
}
if (softmax_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SoftmaxParameter>::GetOwningArena(softmax_param);
if (message_arena != submessage_arena) {
softmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, softmax_param, submessage_arena);
}
_has_bits_[0] |= 0x10000000u;
} else {
_has_bits_[0] &= ~0x10000000u;
}
softmax_param_ = softmax_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.softmax_param)
}
// optional .caffe.SliceParameter slice_param = 31;
inline bool V1LayerParameter::_internal_has_slice_param() const {
bool value = (_has_bits_[0] & 0x00800000u) != 0;
PROTOBUF_ASSUME(!value || slice_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_slice_param() const {
return _internal_has_slice_param();
}
inline void V1LayerParameter::clear_slice_param() {
if (slice_param_ != nullptr) slice_param_->Clear();
_has_bits_[0] &= ~0x00800000u;
}
inline const ::caffe::SliceParameter& V1LayerParameter::_internal_slice_param() const {
const ::caffe::SliceParameter* p = slice_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::SliceParameter&>(
::caffe::_SliceParameter_default_instance_);
}
inline const ::caffe::SliceParameter& V1LayerParameter::slice_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.slice_param)
return _internal_slice_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_slice_param(
::caffe::SliceParameter* slice_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(slice_param_);
}
slice_param_ = slice_param;
if (slice_param) {
_has_bits_[0] |= 0x00800000u;
} else {
_has_bits_[0] &= ~0x00800000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.slice_param)
}
inline ::caffe::SliceParameter* V1LayerParameter::release_slice_param() {
_has_bits_[0] &= ~0x00800000u;
::caffe::SliceParameter* temp = slice_param_;
slice_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::SliceParameter* V1LayerParameter::unsafe_arena_release_slice_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.slice_param)
_has_bits_[0] &= ~0x00800000u;
::caffe::SliceParameter* temp = slice_param_;
slice_param_ = nullptr;
return temp;
}
inline ::caffe::SliceParameter* V1LayerParameter::_internal_mutable_slice_param() {
_has_bits_[0] |= 0x00800000u;
if (slice_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::SliceParameter>(GetArenaForAllocation());
slice_param_ = p;
}
return slice_param_;
}
inline ::caffe::SliceParameter* V1LayerParameter::mutable_slice_param() {
::caffe::SliceParameter* _msg = _internal_mutable_slice_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.slice_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_slice_param(::caffe::SliceParameter* slice_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete slice_param_;
}
if (slice_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::SliceParameter>::GetOwningArena(slice_param);
if (message_arena != submessage_arena) {
slice_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, slice_param, submessage_arena);
}
_has_bits_[0] |= 0x00800000u;
} else {
_has_bits_[0] &= ~0x00800000u;
}
slice_param_ = slice_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.slice_param)
}
// optional .caffe.TanHParameter tanh_param = 37;
inline bool V1LayerParameter::_internal_has_tanh_param() const {
bool value = (_has_bits_[0] & 0x04000000u) != 0;
PROTOBUF_ASSUME(!value || tanh_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_tanh_param() const {
return _internal_has_tanh_param();
}
inline void V1LayerParameter::clear_tanh_param() {
if (tanh_param_ != nullptr) tanh_param_->Clear();
_has_bits_[0] &= ~0x04000000u;
}
inline const ::caffe::TanHParameter& V1LayerParameter::_internal_tanh_param() const {
const ::caffe::TanHParameter* p = tanh_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::TanHParameter&>(
::caffe::_TanHParameter_default_instance_);
}
inline const ::caffe::TanHParameter& V1LayerParameter::tanh_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.tanh_param)
return _internal_tanh_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_tanh_param(
::caffe::TanHParameter* tanh_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tanh_param_);
}
tanh_param_ = tanh_param;
if (tanh_param) {
_has_bits_[0] |= 0x04000000u;
} else {
_has_bits_[0] &= ~0x04000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.tanh_param)
}
inline ::caffe::TanHParameter* V1LayerParameter::release_tanh_param() {
_has_bits_[0] &= ~0x04000000u;
::caffe::TanHParameter* temp = tanh_param_;
tanh_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::TanHParameter* V1LayerParameter::unsafe_arena_release_tanh_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.tanh_param)
_has_bits_[0] &= ~0x04000000u;
::caffe::TanHParameter* temp = tanh_param_;
tanh_param_ = nullptr;
return temp;
}
inline ::caffe::TanHParameter* V1LayerParameter::_internal_mutable_tanh_param() {
_has_bits_[0] |= 0x04000000u;
if (tanh_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::TanHParameter>(GetArenaForAllocation());
tanh_param_ = p;
}
return tanh_param_;
}
inline ::caffe::TanHParameter* V1LayerParameter::mutable_tanh_param() {
::caffe::TanHParameter* _msg = _internal_mutable_tanh_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.tanh_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_tanh_param(::caffe::TanHParameter* tanh_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete tanh_param_;
}
if (tanh_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::TanHParameter>::GetOwningArena(tanh_param);
if (message_arena != submessage_arena) {
tanh_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, tanh_param, submessage_arena);
}
_has_bits_[0] |= 0x04000000u;
} else {
_has_bits_[0] &= ~0x04000000u;
}
tanh_param_ = tanh_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.tanh_param)
}
// optional .caffe.ThresholdParameter threshold_param = 25;
inline bool V1LayerParameter::_internal_has_threshold_param() const {
bool value = (_has_bits_[0] & 0x00040000u) != 0;
PROTOBUF_ASSUME(!value || threshold_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_threshold_param() const {
return _internal_has_threshold_param();
}
inline void V1LayerParameter::clear_threshold_param() {
if (threshold_param_ != nullptr) threshold_param_->Clear();
_has_bits_[0] &= ~0x00040000u;
}
inline const ::caffe::ThresholdParameter& V1LayerParameter::_internal_threshold_param() const {
const ::caffe::ThresholdParameter* p = threshold_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::ThresholdParameter&>(
::caffe::_ThresholdParameter_default_instance_);
}
inline const ::caffe::ThresholdParameter& V1LayerParameter::threshold_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.threshold_param)
return _internal_threshold_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_threshold_param(
::caffe::ThresholdParameter* threshold_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(threshold_param_);
}
threshold_param_ = threshold_param;
if (threshold_param) {
_has_bits_[0] |= 0x00040000u;
} else {
_has_bits_[0] &= ~0x00040000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.threshold_param)
}
inline ::caffe::ThresholdParameter* V1LayerParameter::release_threshold_param() {
_has_bits_[0] &= ~0x00040000u;
::caffe::ThresholdParameter* temp = threshold_param_;
threshold_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::ThresholdParameter* V1LayerParameter::unsafe_arena_release_threshold_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.threshold_param)
_has_bits_[0] &= ~0x00040000u;
::caffe::ThresholdParameter* temp = threshold_param_;
threshold_param_ = nullptr;
return temp;
}
inline ::caffe::ThresholdParameter* V1LayerParameter::_internal_mutable_threshold_param() {
_has_bits_[0] |= 0x00040000u;
if (threshold_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::ThresholdParameter>(GetArenaForAllocation());
threshold_param_ = p;
}
return threshold_param_;
}
inline ::caffe::ThresholdParameter* V1LayerParameter::mutable_threshold_param() {
::caffe::ThresholdParameter* _msg = _internal_mutable_threshold_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.threshold_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete threshold_param_;
}
if (threshold_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::ThresholdParameter>::GetOwningArena(threshold_param);
if (message_arena != submessage_arena) {
threshold_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, threshold_param, submessage_arena);
}
_has_bits_[0] |= 0x00040000u;
} else {
_has_bits_[0] &= ~0x00040000u;
}
threshold_param_ = threshold_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.threshold_param)
}
// optional .caffe.WindowDataParameter window_data_param = 20;
inline bool V1LayerParameter::_internal_has_window_data_param() const {
bool value = (_has_bits_[0] & 0x00002000u) != 0;
PROTOBUF_ASSUME(!value || window_data_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_window_data_param() const {
return _internal_has_window_data_param();
}
inline void V1LayerParameter::clear_window_data_param() {
if (window_data_param_ != nullptr) window_data_param_->Clear();
_has_bits_[0] &= ~0x00002000u;
}
inline const ::caffe::WindowDataParameter& V1LayerParameter::_internal_window_data_param() const {
const ::caffe::WindowDataParameter* p = window_data_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::WindowDataParameter&>(
::caffe::_WindowDataParameter_default_instance_);
}
inline const ::caffe::WindowDataParameter& V1LayerParameter::window_data_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.window_data_param)
return _internal_window_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_window_data_param(
::caffe::WindowDataParameter* window_data_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(window_data_param_);
}
window_data_param_ = window_data_param;
if (window_data_param) {
_has_bits_[0] |= 0x00002000u;
} else {
_has_bits_[0] &= ~0x00002000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.window_data_param)
}
inline ::caffe::WindowDataParameter* V1LayerParameter::release_window_data_param() {
_has_bits_[0] &= ~0x00002000u;
::caffe::WindowDataParameter* temp = window_data_param_;
window_data_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::WindowDataParameter* V1LayerParameter::unsafe_arena_release_window_data_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.window_data_param)
_has_bits_[0] &= ~0x00002000u;
::caffe::WindowDataParameter* temp = window_data_param_;
window_data_param_ = nullptr;
return temp;
}
inline ::caffe::WindowDataParameter* V1LayerParameter::_internal_mutable_window_data_param() {
_has_bits_[0] |= 0x00002000u;
if (window_data_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::WindowDataParameter>(GetArenaForAllocation());
window_data_param_ = p;
}
return window_data_param_;
}
inline ::caffe::WindowDataParameter* V1LayerParameter::mutable_window_data_param() {
::caffe::WindowDataParameter* _msg = _internal_mutable_window_data_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.window_data_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete window_data_param_;
}
if (window_data_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::WindowDataParameter>::GetOwningArena(window_data_param);
if (message_arena != submessage_arena) {
window_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, window_data_param, submessage_arena);
}
_has_bits_[0] |= 0x00002000u;
} else {
_has_bits_[0] &= ~0x00002000u;
}
window_data_param_ = window_data_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.window_data_param)
}
// optional .caffe.TransformationParameter transform_param = 36;
inline bool V1LayerParameter::_internal_has_transform_param() const {
bool value = (_has_bits_[0] & 0x02000000u) != 0;
PROTOBUF_ASSUME(!value || transform_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_transform_param() const {
return _internal_has_transform_param();
}
inline void V1LayerParameter::clear_transform_param() {
if (transform_param_ != nullptr) transform_param_->Clear();
_has_bits_[0] &= ~0x02000000u;
}
inline const ::caffe::TransformationParameter& V1LayerParameter::_internal_transform_param() const {
const ::caffe::TransformationParameter* p = transform_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::TransformationParameter&>(
::caffe::_TransformationParameter_default_instance_);
}
inline const ::caffe::TransformationParameter& V1LayerParameter::transform_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.transform_param)
return _internal_transform_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_transform_param(
::caffe::TransformationParameter* transform_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(transform_param_);
}
transform_param_ = transform_param;
if (transform_param) {
_has_bits_[0] |= 0x02000000u;
} else {
_has_bits_[0] &= ~0x02000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.transform_param)
}
inline ::caffe::TransformationParameter* V1LayerParameter::release_transform_param() {
_has_bits_[0] &= ~0x02000000u;
::caffe::TransformationParameter* temp = transform_param_;
transform_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::TransformationParameter* V1LayerParameter::unsafe_arena_release_transform_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.transform_param)
_has_bits_[0] &= ~0x02000000u;
::caffe::TransformationParameter* temp = transform_param_;
transform_param_ = nullptr;
return temp;
}
inline ::caffe::TransformationParameter* V1LayerParameter::_internal_mutable_transform_param() {
_has_bits_[0] |= 0x02000000u;
if (transform_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::TransformationParameter>(GetArenaForAllocation());
transform_param_ = p;
}
return transform_param_;
}
inline ::caffe::TransformationParameter* V1LayerParameter::mutable_transform_param() {
::caffe::TransformationParameter* _msg = _internal_mutable_transform_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.transform_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_transform_param(::caffe::TransformationParameter* transform_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete transform_param_;
}
if (transform_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::TransformationParameter>::GetOwningArena(transform_param);
if (message_arena != submessage_arena) {
transform_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, transform_param, submessage_arena);
}
_has_bits_[0] |= 0x02000000u;
} else {
_has_bits_[0] &= ~0x02000000u;
}
transform_param_ = transform_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.transform_param)
}
// optional .caffe.LossParameter loss_param = 42;
inline bool V1LayerParameter::_internal_has_loss_param() const {
bool value = (_has_bits_[0] & 0x80000000u) != 0;
PROTOBUF_ASSUME(!value || loss_param_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_loss_param() const {
return _internal_has_loss_param();
}
inline void V1LayerParameter::clear_loss_param() {
if (loss_param_ != nullptr) loss_param_->Clear();
_has_bits_[0] &= ~0x80000000u;
}
inline const ::caffe::LossParameter& V1LayerParameter::_internal_loss_param() const {
const ::caffe::LossParameter* p = loss_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::LossParameter&>(
::caffe::_LossParameter_default_instance_);
}
inline const ::caffe::LossParameter& V1LayerParameter::loss_param() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.loss_param)
return _internal_loss_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_loss_param(
::caffe::LossParameter* loss_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(loss_param_);
}
loss_param_ = loss_param;
if (loss_param) {
_has_bits_[0] |= 0x80000000u;
} else {
_has_bits_[0] &= ~0x80000000u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.loss_param)
}
inline ::caffe::LossParameter* V1LayerParameter::release_loss_param() {
_has_bits_[0] &= ~0x80000000u;
::caffe::LossParameter* temp = loss_param_;
loss_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::LossParameter* V1LayerParameter::unsafe_arena_release_loss_param() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.loss_param)
_has_bits_[0] &= ~0x80000000u;
::caffe::LossParameter* temp = loss_param_;
loss_param_ = nullptr;
return temp;
}
inline ::caffe::LossParameter* V1LayerParameter::_internal_mutable_loss_param() {
_has_bits_[0] |= 0x80000000u;
if (loss_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::LossParameter>(GetArenaForAllocation());
loss_param_ = p;
}
return loss_param_;
}
inline ::caffe::LossParameter* V1LayerParameter::mutable_loss_param() {
::caffe::LossParameter* _msg = _internal_mutable_loss_param();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.loss_param)
return _msg;
}
inline void V1LayerParameter::set_allocated_loss_param(::caffe::LossParameter* loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete loss_param_;
}
if (loss_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::LossParameter>::GetOwningArena(loss_param);
if (message_arena != submessage_arena) {
loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, loss_param, submessage_arena);
}
_has_bits_[0] |= 0x80000000u;
} else {
_has_bits_[0] &= ~0x80000000u;
}
loss_param_ = loss_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.loss_param)
}
// optional .caffe.V0LayerParameter layer = 1;
inline bool V1LayerParameter::_internal_has_layer() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || layer_ != nullptr);
return value;
}
inline bool V1LayerParameter::has_layer() const {
return _internal_has_layer();
}
inline void V1LayerParameter::clear_layer() {
if (layer_ != nullptr) layer_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe::V0LayerParameter& V1LayerParameter::_internal_layer() const {
const ::caffe::V0LayerParameter* p = layer_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::V0LayerParameter&>(
::caffe::_V0LayerParameter_default_instance_);
}
inline const ::caffe::V0LayerParameter& V1LayerParameter::layer() const {
// @@protoc_insertion_point(field_get:caffe.V1LayerParameter.layer)
return _internal_layer();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_layer(
::caffe::V0LayerParameter* layer) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(layer_);
}
layer_ = layer;
if (layer) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V1LayerParameter.layer)
}
inline ::caffe::V0LayerParameter* V1LayerParameter::release_layer() {
_has_bits_[0] &= ~0x00000002u;
::caffe::V0LayerParameter* temp = layer_;
layer_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::V0LayerParameter* V1LayerParameter::unsafe_arena_release_layer() {
// @@protoc_insertion_point(field_release:caffe.V1LayerParameter.layer)
_has_bits_[0] &= ~0x00000002u;
::caffe::V0LayerParameter* temp = layer_;
layer_ = nullptr;
return temp;
}
inline ::caffe::V0LayerParameter* V1LayerParameter::_internal_mutable_layer() {
_has_bits_[0] |= 0x00000002u;
if (layer_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::V0LayerParameter>(GetArenaForAllocation());
layer_ = p;
}
return layer_;
}
inline ::caffe::V0LayerParameter* V1LayerParameter::mutable_layer() {
::caffe::V0LayerParameter* _msg = _internal_mutable_layer();
// @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.layer)
return _msg;
}
inline void V1LayerParameter::set_allocated_layer(::caffe::V0LayerParameter* layer) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete layer_;
}
if (layer) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::V0LayerParameter>::GetOwningArena(layer);
if (message_arena != submessage_arena) {
layer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, layer, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
layer_ = layer;
// @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.layer)
}
// -------------------------------------------------------------------
// V0LayerParameter
// optional string name = 1;
inline bool V0LayerParameter::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool V0LayerParameter::has_name() const {
return _internal_has_name();
}
inline void V0LayerParameter::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& V0LayerParameter::name() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.name)
}
inline std::string* V0LayerParameter::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.name)
return _s;
}
inline const std::string& V0LayerParameter::_internal_name() const {
return name_.Get();
}
inline void V0LayerParameter::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_name() {
// @@protoc_insertion_point(field_release:caffe.V0LayerParameter.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void V0LayerParameter::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.name)
}
// optional string type = 2;
inline bool V0LayerParameter::_internal_has_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool V0LayerParameter::has_type() const {
return _internal_has_type();
}
inline void V0LayerParameter::clear_type() {
type_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& V0LayerParameter::type() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.type)
return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_type(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.type)
}
inline std::string* V0LayerParameter::mutable_type() {
std::string* _s = _internal_mutable_type();
// @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.type)
return _s;
}
inline const std::string& V0LayerParameter::_internal_type() const {
return type_.Get();
}
inline void V0LayerParameter::_internal_set_type(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_type() {
_has_bits_[0] |= 0x00000002u;
return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_type() {
// @@protoc_insertion_point(field_release:caffe.V0LayerParameter.type)
if (!_internal_has_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void V0LayerParameter::set_allocated_type(std::string* type) {
if (type != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.type)
}
// optional uint32 num_output = 3;
inline bool V0LayerParameter::_internal_has_num_output() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool V0LayerParameter::has_num_output() const {
return _internal_has_num_output();
}
inline void V0LayerParameter::clear_num_output() {
num_output_ = 0u;
_has_bits_[0] &= ~0x00000100u;
}
inline uint32_t V0LayerParameter::_internal_num_output() const {
return num_output_;
}
inline uint32_t V0LayerParameter::num_output() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.num_output)
return _internal_num_output();
}
inline void V0LayerParameter::_internal_set_num_output(uint32_t value) {
_has_bits_[0] |= 0x00000100u;
num_output_ = value;
}
inline void V0LayerParameter::set_num_output(uint32_t value) {
_internal_set_num_output(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.num_output)
}
// optional bool biasterm = 4 [default = true];
inline bool V0LayerParameter::_internal_has_biasterm() const {
bool value = (_has_bits_[0] & 0x00800000u) != 0;
return value;
}
inline bool V0LayerParameter::has_biasterm() const {
return _internal_has_biasterm();
}
inline void V0LayerParameter::clear_biasterm() {
biasterm_ = true;
_has_bits_[0] &= ~0x00800000u;
}
inline bool V0LayerParameter::_internal_biasterm() const {
return biasterm_;
}
inline bool V0LayerParameter::biasterm() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.biasterm)
return _internal_biasterm();
}
inline void V0LayerParameter::_internal_set_biasterm(bool value) {
_has_bits_[0] |= 0x00800000u;
biasterm_ = value;
}
inline void V0LayerParameter::set_biasterm(bool value) {
_internal_set_biasterm(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.biasterm)
}
// optional .caffe.FillerParameter weight_filler = 5;
inline bool V0LayerParameter::_internal_has_weight_filler() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
PROTOBUF_ASSUME(!value || weight_filler_ != nullptr);
return value;
}
inline bool V0LayerParameter::has_weight_filler() const {
return _internal_has_weight_filler();
}
inline void V0LayerParameter::clear_weight_filler() {
if (weight_filler_ != nullptr) weight_filler_->Clear();
_has_bits_[0] &= ~0x00000020u;
}
inline const ::caffe::FillerParameter& V0LayerParameter::_internal_weight_filler() const {
const ::caffe::FillerParameter* p = weight_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& V0LayerParameter::weight_filler() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.weight_filler)
return _internal_weight_filler();
}
inline void V0LayerParameter::unsafe_arena_set_allocated_weight_filler(
::caffe::FillerParameter* weight_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(weight_filler_);
}
weight_filler_ = weight_filler;
if (weight_filler) {
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V0LayerParameter.weight_filler)
}
inline ::caffe::FillerParameter* V0LayerParameter::release_weight_filler() {
_has_bits_[0] &= ~0x00000020u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* V0LayerParameter::unsafe_arena_release_weight_filler() {
// @@protoc_insertion_point(field_release:caffe.V0LayerParameter.weight_filler)
_has_bits_[0] &= ~0x00000020u;
::caffe::FillerParameter* temp = weight_filler_;
weight_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* V0LayerParameter::_internal_mutable_weight_filler() {
_has_bits_[0] |= 0x00000020u;
if (weight_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
weight_filler_ = p;
}
return weight_filler_;
}
inline ::caffe::FillerParameter* V0LayerParameter::mutable_weight_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
// @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.weight_filler)
return _msg;
}
inline void V0LayerParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete weight_filler_;
}
if (weight_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(weight_filler);
if (message_arena != submessage_arena) {
weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, weight_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
weight_filler_ = weight_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.weight_filler)
}
// optional .caffe.FillerParameter bias_filler = 6;
inline bool V0LayerParameter::_internal_has_bias_filler() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
PROTOBUF_ASSUME(!value || bias_filler_ != nullptr);
return value;
}
inline bool V0LayerParameter::has_bias_filler() const {
return _internal_has_bias_filler();
}
inline void V0LayerParameter::clear_bias_filler() {
if (bias_filler_ != nullptr) bias_filler_->Clear();
_has_bits_[0] &= ~0x00000040u;
}
inline const ::caffe::FillerParameter& V0LayerParameter::_internal_bias_filler() const {
const ::caffe::FillerParameter* p = bias_filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& V0LayerParameter::bias_filler() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.bias_filler)
return _internal_bias_filler();
}
inline void V0LayerParameter::unsafe_arena_set_allocated_bias_filler(
::caffe::FillerParameter* bias_filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bias_filler_);
}
bias_filler_ = bias_filler;
if (bias_filler) {
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V0LayerParameter.bias_filler)
}
inline ::caffe::FillerParameter* V0LayerParameter::release_bias_filler() {
_has_bits_[0] &= ~0x00000040u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* V0LayerParameter::unsafe_arena_release_bias_filler() {
// @@protoc_insertion_point(field_release:caffe.V0LayerParameter.bias_filler)
_has_bits_[0] &= ~0x00000040u;
::caffe::FillerParameter* temp = bias_filler_;
bias_filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* V0LayerParameter::_internal_mutable_bias_filler() {
_has_bits_[0] |= 0x00000040u;
if (bias_filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
bias_filler_ = p;
}
return bias_filler_;
}
inline ::caffe::FillerParameter* V0LayerParameter::mutable_bias_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
// @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.bias_filler)
return _msg;
}
inline void V0LayerParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bias_filler_;
}
if (bias_filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(bias_filler);
if (message_arena != submessage_arena) {
bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bias_filler, submessage_arena);
}
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
bias_filler_ = bias_filler;
// @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.bias_filler)
}
// optional uint32 pad = 7 [default = 0];
inline bool V0LayerParameter::_internal_has_pad() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool V0LayerParameter::has_pad() const {
return _internal_has_pad();
}
inline void V0LayerParameter::clear_pad() {
pad_ = 0u;
_has_bits_[0] &= ~0x00000200u;
}
inline uint32_t V0LayerParameter::_internal_pad() const {
return pad_;
}
inline uint32_t V0LayerParameter::pad() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.pad)
return _internal_pad();
}
inline void V0LayerParameter::_internal_set_pad(uint32_t value) {
_has_bits_[0] |= 0x00000200u;
pad_ = value;
}
inline void V0LayerParameter::set_pad(uint32_t value) {
_internal_set_pad(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.pad)
}
// optional uint32 kernelsize = 8;
inline bool V0LayerParameter::_internal_has_kernelsize() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool V0LayerParameter::has_kernelsize() const {
return _internal_has_kernelsize();
}
inline void V0LayerParameter::clear_kernelsize() {
kernelsize_ = 0u;
_has_bits_[0] &= ~0x00000400u;
}
inline uint32_t V0LayerParameter::_internal_kernelsize() const {
return kernelsize_;
}
inline uint32_t V0LayerParameter::kernelsize() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.kernelsize)
return _internal_kernelsize();
}
inline void V0LayerParameter::_internal_set_kernelsize(uint32_t value) {
_has_bits_[0] |= 0x00000400u;
kernelsize_ = value;
}
inline void V0LayerParameter::set_kernelsize(uint32_t value) {
_internal_set_kernelsize(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.kernelsize)
}
// optional uint32 group = 9 [default = 1];
inline bool V0LayerParameter::_internal_has_group() const {
bool value = (_has_bits_[0] & 0x01000000u) != 0;
return value;
}
inline bool V0LayerParameter::has_group() const {
return _internal_has_group();
}
inline void V0LayerParameter::clear_group() {
group_ = 1u;
_has_bits_[0] &= ~0x01000000u;
}
inline uint32_t V0LayerParameter::_internal_group() const {
return group_;
}
inline uint32_t V0LayerParameter::group() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.group)
return _internal_group();
}
inline void V0LayerParameter::_internal_set_group(uint32_t value) {
_has_bits_[0] |= 0x01000000u;
group_ = value;
}
inline void V0LayerParameter::set_group(uint32_t value) {
_internal_set_group(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.group)
}
// optional uint32 stride = 10 [default = 1];
inline bool V0LayerParameter::_internal_has_stride() const {
bool value = (_has_bits_[0] & 0x02000000u) != 0;
return value;
}
inline bool V0LayerParameter::has_stride() const {
return _internal_has_stride();
}
inline void V0LayerParameter::clear_stride() {
stride_ = 1u;
_has_bits_[0] &= ~0x02000000u;
}
inline uint32_t V0LayerParameter::_internal_stride() const {
return stride_;
}
inline uint32_t V0LayerParameter::stride() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.stride)
return _internal_stride();
}
inline void V0LayerParameter::_internal_set_stride(uint32_t value) {
_has_bits_[0] |= 0x02000000u;
stride_ = value;
}
inline void V0LayerParameter::set_stride(uint32_t value) {
_internal_set_stride(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.stride)
}
// optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
inline bool V0LayerParameter::_internal_has_pool() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool V0LayerParameter::has_pool() const {
return _internal_has_pool();
}
inline void V0LayerParameter::clear_pool() {
pool_ = 0;
_has_bits_[0] &= ~0x00000800u;
}
inline ::caffe::V0LayerParameter_PoolMethod V0LayerParameter::_internal_pool() const {
return static_cast< ::caffe::V0LayerParameter_PoolMethod >(pool_);
}
inline ::caffe::V0LayerParameter_PoolMethod V0LayerParameter::pool() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.pool)
return _internal_pool();
}
inline void V0LayerParameter::_internal_set_pool(::caffe::V0LayerParameter_PoolMethod value) {
assert(::caffe::V0LayerParameter_PoolMethod_IsValid(value));
_has_bits_[0] |= 0x00000800u;
pool_ = value;
}
inline void V0LayerParameter::set_pool(::caffe::V0LayerParameter_PoolMethod value) {
_internal_set_pool(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.pool)
}
// optional float dropout_ratio = 12 [default = 0.5];
inline bool V0LayerParameter::_internal_has_dropout_ratio() const {
bool value = (_has_bits_[0] & 0x04000000u) != 0;
return value;
}
inline bool V0LayerParameter::has_dropout_ratio() const {
return _internal_has_dropout_ratio();
}
inline void V0LayerParameter::clear_dropout_ratio() {
dropout_ratio_ = 0.5f;
_has_bits_[0] &= ~0x04000000u;
}
inline float V0LayerParameter::_internal_dropout_ratio() const {
return dropout_ratio_;
}
inline float V0LayerParameter::dropout_ratio() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.dropout_ratio)
return _internal_dropout_ratio();
}
inline void V0LayerParameter::_internal_set_dropout_ratio(float value) {
_has_bits_[0] |= 0x04000000u;
dropout_ratio_ = value;
}
inline void V0LayerParameter::set_dropout_ratio(float value) {
_internal_set_dropout_ratio(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.dropout_ratio)
}
// optional uint32 local_size = 13 [default = 5];
inline bool V0LayerParameter::_internal_has_local_size() const {
bool value = (_has_bits_[0] & 0x08000000u) != 0;
return value;
}
inline bool V0LayerParameter::has_local_size() const {
return _internal_has_local_size();
}
inline void V0LayerParameter::clear_local_size() {
local_size_ = 5u;
_has_bits_[0] &= ~0x08000000u;
}
inline uint32_t V0LayerParameter::_internal_local_size() const {
return local_size_;
}
inline uint32_t V0LayerParameter::local_size() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.local_size)
return _internal_local_size();
}
inline void V0LayerParameter::_internal_set_local_size(uint32_t value) {
_has_bits_[0] |= 0x08000000u;
local_size_ = value;
}
inline void V0LayerParameter::set_local_size(uint32_t value) {
_internal_set_local_size(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.local_size)
}
// optional float alpha = 14 [default = 1];
inline bool V0LayerParameter::_internal_has_alpha() const {
bool value = (_has_bits_[0] & 0x10000000u) != 0;
return value;
}
inline bool V0LayerParameter::has_alpha() const {
return _internal_has_alpha();
}
inline void V0LayerParameter::clear_alpha() {
alpha_ = 1;
_has_bits_[0] &= ~0x10000000u;
}
inline float V0LayerParameter::_internal_alpha() const {
return alpha_;
}
inline float V0LayerParameter::alpha() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.alpha)
return _internal_alpha();
}
inline void V0LayerParameter::_internal_set_alpha(float value) {
_has_bits_[0] |= 0x10000000u;
alpha_ = value;
}
inline void V0LayerParameter::set_alpha(float value) {
_internal_set_alpha(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.alpha)
}
// optional float beta = 15 [default = 0.75];
inline bool V0LayerParameter::_internal_has_beta() const {
bool value = (_has_bits_[0] & 0x20000000u) != 0;
return value;
}
inline bool V0LayerParameter::has_beta() const {
return _internal_has_beta();
}
inline void V0LayerParameter::clear_beta() {
beta_ = 0.75f;
_has_bits_[0] &= ~0x20000000u;
}
inline float V0LayerParameter::_internal_beta() const {
return beta_;
}
inline float V0LayerParameter::beta() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.beta)
return _internal_beta();
}
inline void V0LayerParameter::_internal_set_beta(float value) {
_has_bits_[0] |= 0x20000000u;
beta_ = value;
}
inline void V0LayerParameter::set_beta(float value) {
_internal_set_beta(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.beta)
}
// optional float k = 22 [default = 1];
inline bool V0LayerParameter::_internal_has_k() const {
bool value = (_has_bits_[0] & 0x80000000u) != 0;
return value;
}
inline bool V0LayerParameter::has_k() const {
return _internal_has_k();
}
inline void V0LayerParameter::clear_k() {
k_ = 1;
_has_bits_[0] &= ~0x80000000u;
}
inline float V0LayerParameter::_internal_k() const {
return k_;
}
inline float V0LayerParameter::k() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.k)
return _internal_k();
}
inline void V0LayerParameter::_internal_set_k(float value) {
_has_bits_[0] |= 0x80000000u;
k_ = value;
}
inline void V0LayerParameter::set_k(float value) {
_internal_set_k(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.k)
}
// optional string source = 16;
inline bool V0LayerParameter::_internal_has_source() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool V0LayerParameter::has_source() const {
return _internal_has_source();
}
inline void V0LayerParameter::clear_source() {
source_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& V0LayerParameter::source() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.source)
return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_source(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.source)
}
inline std::string* V0LayerParameter::mutable_source() {
std::string* _s = _internal_mutable_source();
// @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.source)
return _s;
}
inline const std::string& V0LayerParameter::_internal_source() const {
return source_.Get();
}
inline void V0LayerParameter::_internal_set_source(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_source() {
_has_bits_[0] |= 0x00000004u;
return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_source() {
// @@protoc_insertion_point(field_release:caffe.V0LayerParameter.source)
if (!_internal_has_source()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void V0LayerParameter::set_allocated_source(std::string* source) {
if (source != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.source)
}
// optional float scale = 17 [default = 1];
inline bool V0LayerParameter::_internal_has_scale() const {
bool value = (_has_bits_[0] & 0x40000000u) != 0;
return value;
}
inline bool V0LayerParameter::has_scale() const {
return _internal_has_scale();
}
inline void V0LayerParameter::clear_scale() {
scale_ = 1;
_has_bits_[0] &= ~0x40000000u;
}
inline float V0LayerParameter::_internal_scale() const {
return scale_;
}
inline float V0LayerParameter::scale() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.scale)
return _internal_scale();
}
inline void V0LayerParameter::_internal_set_scale(float value) {
_has_bits_[0] |= 0x40000000u;
scale_ = value;
}
inline void V0LayerParameter::set_scale(float value) {
_internal_set_scale(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.scale)
}
// optional string meanfile = 18;
inline bool V0LayerParameter::_internal_has_meanfile() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool V0LayerParameter::has_meanfile() const {
return _internal_has_meanfile();
}
inline void V0LayerParameter::clear_meanfile() {
meanfile_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& V0LayerParameter::meanfile() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.meanfile)
return _internal_meanfile();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_meanfile(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000008u;
meanfile_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.meanfile)
}
inline std::string* V0LayerParameter::mutable_meanfile() {
std::string* _s = _internal_mutable_meanfile();
// @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.meanfile)
return _s;
}
inline const std::string& V0LayerParameter::_internal_meanfile() const {
return meanfile_.Get();
}
inline void V0LayerParameter::_internal_set_meanfile(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
meanfile_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_meanfile() {
_has_bits_[0] |= 0x00000008u;
return meanfile_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_meanfile() {
// @@protoc_insertion_point(field_release:caffe.V0LayerParameter.meanfile)
if (!_internal_has_meanfile()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
auto* p = meanfile_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (meanfile_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
meanfile_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void V0LayerParameter::set_allocated_meanfile(std::string* meanfile) {
if (meanfile != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
meanfile_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), meanfile,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (meanfile_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
meanfile_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.meanfile)
}
// optional uint32 batchsize = 19;
inline bool V0LayerParameter::_internal_has_batchsize() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool V0LayerParameter::has_batchsize() const {
return _internal_has_batchsize();
}
inline void V0LayerParameter::clear_batchsize() {
batchsize_ = 0u;
_has_bits_[0] &= ~0x00001000u;
}
inline uint32_t V0LayerParameter::_internal_batchsize() const {
return batchsize_;
}
inline uint32_t V0LayerParameter::batchsize() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.batchsize)
return _internal_batchsize();
}
inline void V0LayerParameter::_internal_set_batchsize(uint32_t value) {
_has_bits_[0] |= 0x00001000u;
batchsize_ = value;
}
inline void V0LayerParameter::set_batchsize(uint32_t value) {
_internal_set_batchsize(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.batchsize)
}
// optional uint32 cropsize = 20 [default = 0];
inline bool V0LayerParameter::_internal_has_cropsize() const {
bool value = (_has_bits_[0] & 0x00002000u) != 0;
return value;
}
inline bool V0LayerParameter::has_cropsize() const {
return _internal_has_cropsize();
}
inline void V0LayerParameter::clear_cropsize() {
cropsize_ = 0u;
_has_bits_[0] &= ~0x00002000u;
}
inline uint32_t V0LayerParameter::_internal_cropsize() const {
return cropsize_;
}
inline uint32_t V0LayerParameter::cropsize() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.cropsize)
return _internal_cropsize();
}
inline void V0LayerParameter::_internal_set_cropsize(uint32_t value) {
_has_bits_[0] |= 0x00002000u;
cropsize_ = value;
}
inline void V0LayerParameter::set_cropsize(uint32_t value) {
_internal_set_cropsize(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.cropsize)
}
// optional bool mirror = 21 [default = false];
inline bool V0LayerParameter::_internal_has_mirror() const {
bool value = (_has_bits_[0] & 0x00008000u) != 0;
return value;
}
inline bool V0LayerParameter::has_mirror() const {
return _internal_has_mirror();
}
inline void V0LayerParameter::clear_mirror() {
mirror_ = false;
_has_bits_[0] &= ~0x00008000u;
}
inline bool V0LayerParameter::_internal_mirror() const {
return mirror_;
}
inline bool V0LayerParameter::mirror() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.mirror)
return _internal_mirror();
}
inline void V0LayerParameter::_internal_set_mirror(bool value) {
_has_bits_[0] |= 0x00008000u;
mirror_ = value;
}
inline void V0LayerParameter::set_mirror(bool value) {
_internal_set_mirror(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.mirror)
}
// repeated .caffe.BlobProto blobs = 50;
inline int V0LayerParameter::_internal_blobs_size() const {
return blobs_.size();
}
inline int V0LayerParameter::blobs_size() const {
return _internal_blobs_size();
}
inline void V0LayerParameter::clear_blobs() {
blobs_.Clear();
}
inline ::caffe::BlobProto* V0LayerParameter::mutable_blobs(int index) {
// @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.blobs)
return blobs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >*
V0LayerParameter::mutable_blobs() {
// @@protoc_insertion_point(field_mutable_list:caffe.V0LayerParameter.blobs)
return &blobs_;
}
inline const ::caffe::BlobProto& V0LayerParameter::_internal_blobs(int index) const {
return blobs_.Get(index);
}
inline const ::caffe::BlobProto& V0LayerParameter::blobs(int index) const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.blobs)
return _internal_blobs(index);
}
inline ::caffe::BlobProto* V0LayerParameter::_internal_add_blobs() {
return blobs_.Add();
}
inline ::caffe::BlobProto* V0LayerParameter::add_blobs() {
::caffe::BlobProto* _add = _internal_add_blobs();
// @@protoc_insertion_point(field_add:caffe.V0LayerParameter.blobs)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe::BlobProto >&
V0LayerParameter::blobs() const {
// @@protoc_insertion_point(field_list:caffe.V0LayerParameter.blobs)
return blobs_;
}
// repeated float blobs_lr = 51;
inline int V0LayerParameter::_internal_blobs_lr_size() const {
return blobs_lr_.size();
}
inline int V0LayerParameter::blobs_lr_size() const {
return _internal_blobs_lr_size();
}
inline void V0LayerParameter::clear_blobs_lr() {
blobs_lr_.Clear();
}
inline float V0LayerParameter::_internal_blobs_lr(int index) const {
return blobs_lr_.Get(index);
}
inline float V0LayerParameter::blobs_lr(int index) const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.blobs_lr)
return _internal_blobs_lr(index);
}
inline void V0LayerParameter::set_blobs_lr(int index, float value) {
blobs_lr_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.blobs_lr)
}
inline void V0LayerParameter::_internal_add_blobs_lr(float value) {
blobs_lr_.Add(value);
}
inline void V0LayerParameter::add_blobs_lr(float value) {
_internal_add_blobs_lr(value);
// @@protoc_insertion_point(field_add:caffe.V0LayerParameter.blobs_lr)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V0LayerParameter::_internal_blobs_lr() const {
return blobs_lr_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V0LayerParameter::blobs_lr() const {
// @@protoc_insertion_point(field_list:caffe.V0LayerParameter.blobs_lr)
return _internal_blobs_lr();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V0LayerParameter::_internal_mutable_blobs_lr() {
return &blobs_lr_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V0LayerParameter::mutable_blobs_lr() {
// @@protoc_insertion_point(field_mutable_list:caffe.V0LayerParameter.blobs_lr)
return _internal_mutable_blobs_lr();
}
// repeated float weight_decay = 52;
inline int V0LayerParameter::_internal_weight_decay_size() const {
return weight_decay_.size();
}
inline int V0LayerParameter::weight_decay_size() const {
return _internal_weight_decay_size();
}
inline void V0LayerParameter::clear_weight_decay() {
weight_decay_.Clear();
}
inline float V0LayerParameter::_internal_weight_decay(int index) const {
return weight_decay_.Get(index);
}
inline float V0LayerParameter::weight_decay(int index) const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.weight_decay)
return _internal_weight_decay(index);
}
inline void V0LayerParameter::set_weight_decay(int index, float value) {
weight_decay_.Set(index, value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.weight_decay)
}
inline void V0LayerParameter::_internal_add_weight_decay(float value) {
weight_decay_.Add(value);
}
inline void V0LayerParameter::add_weight_decay(float value) {
_internal_add_weight_decay(value);
// @@protoc_insertion_point(field_add:caffe.V0LayerParameter.weight_decay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V0LayerParameter::_internal_weight_decay() const {
return weight_decay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V0LayerParameter::weight_decay() const {
// @@protoc_insertion_point(field_list:caffe.V0LayerParameter.weight_decay)
return _internal_weight_decay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V0LayerParameter::_internal_mutable_weight_decay() {
return &weight_decay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V0LayerParameter::mutable_weight_decay() {
// @@protoc_insertion_point(field_mutable_list:caffe.V0LayerParameter.weight_decay)
return _internal_mutable_weight_decay();
}
// optional uint32 rand_skip = 53 [default = 0];
inline bool V0LayerParameter::_internal_has_rand_skip() const {
bool value = (_has_bits_[0] & 0x00020000u) != 0;
return value;
}
inline bool V0LayerParameter::has_rand_skip() const {
return _internal_has_rand_skip();
}
inline void V0LayerParameter::clear_rand_skip() {
rand_skip_ = 0u;
_has_bits_[0] &= ~0x00020000u;
}
inline uint32_t V0LayerParameter::_internal_rand_skip() const {
return rand_skip_;
}
inline uint32_t V0LayerParameter::rand_skip() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.rand_skip)
return _internal_rand_skip();
}
inline void V0LayerParameter::_internal_set_rand_skip(uint32_t value) {
_has_bits_[0] |= 0x00020000u;
rand_skip_ = value;
}
inline void V0LayerParameter::set_rand_skip(uint32_t value) {
_internal_set_rand_skip(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.rand_skip)
}
// optional float det_fg_threshold = 54 [default = 0.5];
inline bool V0LayerParameter::_internal_has_det_fg_threshold() const {
bool value = (_has_bits_[1] & 0x00000001u) != 0;
return value;
}
inline bool V0LayerParameter::has_det_fg_threshold() const {
return _internal_has_det_fg_threshold();
}
inline void V0LayerParameter::clear_det_fg_threshold() {
det_fg_threshold_ = 0.5f;
_has_bits_[1] &= ~0x00000001u;
}
inline float V0LayerParameter::_internal_det_fg_threshold() const {
return det_fg_threshold_;
}
inline float V0LayerParameter::det_fg_threshold() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_fg_threshold)
return _internal_det_fg_threshold();
}
inline void V0LayerParameter::_internal_set_det_fg_threshold(float value) {
_has_bits_[1] |= 0x00000001u;
det_fg_threshold_ = value;
}
inline void V0LayerParameter::set_det_fg_threshold(float value) {
_internal_set_det_fg_threshold(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_fg_threshold)
}
// optional float det_bg_threshold = 55 [default = 0.5];
inline bool V0LayerParameter::_internal_has_det_bg_threshold() const {
bool value = (_has_bits_[1] & 0x00000002u) != 0;
return value;
}
inline bool V0LayerParameter::has_det_bg_threshold() const {
return _internal_has_det_bg_threshold();
}
inline void V0LayerParameter::clear_det_bg_threshold() {
det_bg_threshold_ = 0.5f;
_has_bits_[1] &= ~0x00000002u;
}
inline float V0LayerParameter::_internal_det_bg_threshold() const {
return det_bg_threshold_;
}
inline float V0LayerParameter::det_bg_threshold() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_bg_threshold)
return _internal_det_bg_threshold();
}
inline void V0LayerParameter::_internal_set_det_bg_threshold(float value) {
_has_bits_[1] |= 0x00000002u;
det_bg_threshold_ = value;
}
inline void V0LayerParameter::set_det_bg_threshold(float value) {
_internal_set_det_bg_threshold(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_bg_threshold)
}
// optional float det_fg_fraction = 56 [default = 0.25];
inline bool V0LayerParameter::_internal_has_det_fg_fraction() const {
bool value = (_has_bits_[1] & 0x00000004u) != 0;
return value;
}
inline bool V0LayerParameter::has_det_fg_fraction() const {
return _internal_has_det_fg_fraction();
}
inline void V0LayerParameter::clear_det_fg_fraction() {
det_fg_fraction_ = 0.25f;
_has_bits_[1] &= ~0x00000004u;
}
inline float V0LayerParameter::_internal_det_fg_fraction() const {
return det_fg_fraction_;
}
inline float V0LayerParameter::det_fg_fraction() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_fg_fraction)
return _internal_det_fg_fraction();
}
inline void V0LayerParameter::_internal_set_det_fg_fraction(float value) {
_has_bits_[1] |= 0x00000004u;
det_fg_fraction_ = value;
}
inline void V0LayerParameter::set_det_fg_fraction(float value) {
_internal_set_det_fg_fraction(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_fg_fraction)
}
// optional uint32 det_context_pad = 58 [default = 0];
inline bool V0LayerParameter::_internal_has_det_context_pad() const {
bool value = (_has_bits_[0] & 0x00040000u) != 0;
return value;
}
inline bool V0LayerParameter::has_det_context_pad() const {
return _internal_has_det_context_pad();
}
inline void V0LayerParameter::clear_det_context_pad() {
det_context_pad_ = 0u;
_has_bits_[0] &= ~0x00040000u;
}
inline uint32_t V0LayerParameter::_internal_det_context_pad() const {
return det_context_pad_;
}
inline uint32_t V0LayerParameter::det_context_pad() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_context_pad)
return _internal_det_context_pad();
}
inline void V0LayerParameter::_internal_set_det_context_pad(uint32_t value) {
_has_bits_[0] |= 0x00040000u;
det_context_pad_ = value;
}
inline void V0LayerParameter::set_det_context_pad(uint32_t value) {
_internal_set_det_context_pad(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_context_pad)
}
// optional string det_crop_mode = 59 [default = "warp"];
inline bool V0LayerParameter::_internal_has_det_crop_mode() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool V0LayerParameter::has_det_crop_mode() const {
return _internal_has_det_crop_mode();
}
inline void V0LayerParameter::clear_det_crop_mode() {
det_crop_mode_.ClearToDefault(::caffe::V0LayerParameter::_i_give_permission_to_break_this_code_default_det_crop_mode_, GetArenaForAllocation());
_has_bits_[0] &= ~0x00000010u;
}
inline const std::string& V0LayerParameter::det_crop_mode() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_crop_mode)
if (det_crop_mode_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_det_crop_mode_.get();
return _internal_det_crop_mode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_det_crop_mode(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000010u;
det_crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_crop_mode)
}
inline std::string* V0LayerParameter::mutable_det_crop_mode() {
std::string* _s = _internal_mutable_det_crop_mode();
// @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.det_crop_mode)
return _s;
}
inline const std::string& V0LayerParameter::_internal_det_crop_mode() const {
return det_crop_mode_.Get();
}
inline void V0LayerParameter::_internal_set_det_crop_mode(const std::string& value) {
_has_bits_[0] |= 0x00000010u;
det_crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_det_crop_mode() {
_has_bits_[0] |= 0x00000010u;
return det_crop_mode_.Mutable(::caffe::V0LayerParameter::_i_give_permission_to_break_this_code_default_det_crop_mode_, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_det_crop_mode() {
// @@protoc_insertion_point(field_release:caffe.V0LayerParameter.det_crop_mode)
if (!_internal_has_det_crop_mode()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000010u;
auto* p = det_crop_mode_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
return p;
}
inline void V0LayerParameter::set_allocated_det_crop_mode(std::string* det_crop_mode) {
if (det_crop_mode != nullptr) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
det_crop_mode_.SetAllocated(nullptr, det_crop_mode,
GetArenaForAllocation());
// @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.det_crop_mode)
}
// optional int32 new_num = 60 [default = 0];
inline bool V0LayerParameter::_internal_has_new_num() const {
bool value = (_has_bits_[0] & 0x00080000u) != 0;
return value;
}
inline bool V0LayerParameter::has_new_num() const {
return _internal_has_new_num();
}
inline void V0LayerParameter::clear_new_num() {
new_num_ = 0;
_has_bits_[0] &= ~0x00080000u;
}
inline int32_t V0LayerParameter::_internal_new_num() const {
return new_num_;
}
inline int32_t V0LayerParameter::new_num() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_num)
return _internal_new_num();
}
inline void V0LayerParameter::_internal_set_new_num(int32_t value) {
_has_bits_[0] |= 0x00080000u;
new_num_ = value;
}
inline void V0LayerParameter::set_new_num(int32_t value) {
_internal_set_new_num(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_num)
}
// optional int32 new_channels = 61 [default = 0];
inline bool V0LayerParameter::_internal_has_new_channels() const {
bool value = (_has_bits_[0] & 0x00100000u) != 0;
return value;
}
inline bool V0LayerParameter::has_new_channels() const {
return _internal_has_new_channels();
}
inline void V0LayerParameter::clear_new_channels() {
new_channels_ = 0;
_has_bits_[0] &= ~0x00100000u;
}
inline int32_t V0LayerParameter::_internal_new_channels() const {
return new_channels_;
}
inline int32_t V0LayerParameter::new_channels() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_channels)
return _internal_new_channels();
}
inline void V0LayerParameter::_internal_set_new_channels(int32_t value) {
_has_bits_[0] |= 0x00100000u;
new_channels_ = value;
}
inline void V0LayerParameter::set_new_channels(int32_t value) {
_internal_set_new_channels(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_channels)
}
// optional int32 new_height = 62 [default = 0];
inline bool V0LayerParameter::_internal_has_new_height() const {
bool value = (_has_bits_[0] & 0x00200000u) != 0;
return value;
}
inline bool V0LayerParameter::has_new_height() const {
return _internal_has_new_height();
}
inline void V0LayerParameter::clear_new_height() {
new_height_ = 0;
_has_bits_[0] &= ~0x00200000u;
}
inline int32_t V0LayerParameter::_internal_new_height() const {
return new_height_;
}
inline int32_t V0LayerParameter::new_height() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_height)
return _internal_new_height();
}
inline void V0LayerParameter::_internal_set_new_height(int32_t value) {
_has_bits_[0] |= 0x00200000u;
new_height_ = value;
}
inline void V0LayerParameter::set_new_height(int32_t value) {
_internal_set_new_height(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_height)
}
// optional int32 new_width = 63 [default = 0];
inline bool V0LayerParameter::_internal_has_new_width() const {
bool value = (_has_bits_[0] & 0x00004000u) != 0;
return value;
}
inline bool V0LayerParameter::has_new_width() const {
return _internal_has_new_width();
}
inline void V0LayerParameter::clear_new_width() {
new_width_ = 0;
_has_bits_[0] &= ~0x00004000u;
}
inline int32_t V0LayerParameter::_internal_new_width() const {
return new_width_;
}
inline int32_t V0LayerParameter::new_width() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_width)
return _internal_new_width();
}
inline void V0LayerParameter::_internal_set_new_width(int32_t value) {
_has_bits_[0] |= 0x00004000u;
new_width_ = value;
}
inline void V0LayerParameter::set_new_width(int32_t value) {
_internal_set_new_width(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_width)
}
// optional bool shuffle_images = 64 [default = false];
inline bool V0LayerParameter::_internal_has_shuffle_images() const {
bool value = (_has_bits_[0] & 0x00010000u) != 0;
return value;
}
inline bool V0LayerParameter::has_shuffle_images() const {
return _internal_has_shuffle_images();
}
inline void V0LayerParameter::clear_shuffle_images() {
shuffle_images_ = false;
_has_bits_[0] &= ~0x00010000u;
}
inline bool V0LayerParameter::_internal_shuffle_images() const {
return shuffle_images_;
}
inline bool V0LayerParameter::shuffle_images() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.shuffle_images)
return _internal_shuffle_images();
}
inline void V0LayerParameter::_internal_set_shuffle_images(bool value) {
_has_bits_[0] |= 0x00010000u;
shuffle_images_ = value;
}
inline void V0LayerParameter::set_shuffle_images(bool value) {
_internal_set_shuffle_images(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.shuffle_images)
}
// optional uint32 concat_dim = 65 [default = 1];
inline bool V0LayerParameter::_internal_has_concat_dim() const {
bool value = (_has_bits_[0] & 0x00400000u) != 0;
return value;
}
inline bool V0LayerParameter::has_concat_dim() const {
return _internal_has_concat_dim();
}
inline void V0LayerParameter::clear_concat_dim() {
concat_dim_ = 1u;
_has_bits_[0] &= ~0x00400000u;
}
inline uint32_t V0LayerParameter::_internal_concat_dim() const {
return concat_dim_;
}
inline uint32_t V0LayerParameter::concat_dim() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.concat_dim)
return _internal_concat_dim();
}
inline void V0LayerParameter::_internal_set_concat_dim(uint32_t value) {
_has_bits_[0] |= 0x00400000u;
concat_dim_ = value;
}
inline void V0LayerParameter::set_concat_dim(uint32_t value) {
_internal_set_concat_dim(value);
// @@protoc_insertion_point(field_set:caffe.V0LayerParameter.concat_dim)
}
// optional .caffe.HDF5OutputParameter hdf5_output_param = 1001;
inline bool V0LayerParameter::_internal_has_hdf5_output_param() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
PROTOBUF_ASSUME(!value || hdf5_output_param_ != nullptr);
return value;
}
inline bool V0LayerParameter::has_hdf5_output_param() const {
return _internal_has_hdf5_output_param();
}
inline void V0LayerParameter::clear_hdf5_output_param() {
if (hdf5_output_param_ != nullptr) hdf5_output_param_->Clear();
_has_bits_[0] &= ~0x00000080u;
}
inline const ::caffe::HDF5OutputParameter& V0LayerParameter::_internal_hdf5_output_param() const {
const ::caffe::HDF5OutputParameter* p = hdf5_output_param_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::HDF5OutputParameter&>(
::caffe::_HDF5OutputParameter_default_instance_);
}
inline const ::caffe::HDF5OutputParameter& V0LayerParameter::hdf5_output_param() const {
// @@protoc_insertion_point(field_get:caffe.V0LayerParameter.hdf5_output_param)
return _internal_hdf5_output_param();
}
inline void V0LayerParameter::unsafe_arena_set_allocated_hdf5_output_param(
::caffe::HDF5OutputParameter* hdf5_output_param) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hdf5_output_param_);
}
hdf5_output_param_ = hdf5_output_param;
if (hdf5_output_param) {
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.V0LayerParameter.hdf5_output_param)
}
inline ::caffe::HDF5OutputParameter* V0LayerParameter::release_hdf5_output_param() {
_has_bits_[0] &= ~0x00000080u;
::caffe::HDF5OutputParameter* temp = hdf5_output_param_;
hdf5_output_param_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::HDF5OutputParameter* V0LayerParameter::unsafe_arena_release_hdf5_output_param() {
// @@protoc_insertion_point(field_release:caffe.V0LayerParameter.hdf5_output_param)
_has_bits_[0] &= ~0x00000080u;
::caffe::HDF5OutputParameter* temp = hdf5_output_param_;
hdf5_output_param_ = nullptr;
return temp;
}
inline ::caffe::HDF5OutputParameter* V0LayerParameter::_internal_mutable_hdf5_output_param() {
_has_bits_[0] |= 0x00000080u;
if (hdf5_output_param_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::HDF5OutputParameter>(GetArenaForAllocation());
hdf5_output_param_ = p;
}
return hdf5_output_param_;
}
inline ::caffe::HDF5OutputParameter* V0LayerParameter::mutable_hdf5_output_param() {
::caffe::HDF5OutputParameter* _msg = _internal_mutable_hdf5_output_param();
// @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.hdf5_output_param)
return _msg;
}
inline void V0LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete hdf5_output_param_;
}
if (hdf5_output_param) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::HDF5OutputParameter>::GetOwningArena(hdf5_output_param);
if (message_arena != submessage_arena) {
hdf5_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, hdf5_output_param, submessage_arena);
}
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
hdf5_output_param_ = hdf5_output_param;
// @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.hdf5_output_param)
}
// -------------------------------------------------------------------
// PReLUParameter
// optional .caffe.FillerParameter filler = 1;
inline bool PReLUParameter::_internal_has_filler() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || filler_ != nullptr);
return value;
}
inline bool PReLUParameter::has_filler() const {
return _internal_has_filler();
}
inline void PReLUParameter::clear_filler() {
if (filler_ != nullptr) filler_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::caffe::FillerParameter& PReLUParameter::_internal_filler() const {
const ::caffe::FillerParameter* p = filler_;
return p != nullptr ? *p : reinterpret_cast<const ::caffe::FillerParameter&>(
::caffe::_FillerParameter_default_instance_);
}
inline const ::caffe::FillerParameter& PReLUParameter::filler() const {
// @@protoc_insertion_point(field_get:caffe.PReLUParameter.filler)
return _internal_filler();
}
inline void PReLUParameter::unsafe_arena_set_allocated_filler(
::caffe::FillerParameter* filler) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filler_);
}
filler_ = filler;
if (filler) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe.PReLUParameter.filler)
}
inline ::caffe::FillerParameter* PReLUParameter::release_filler() {
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = filler_;
filler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::caffe::FillerParameter* PReLUParameter::unsafe_arena_release_filler() {
// @@protoc_insertion_point(field_release:caffe.PReLUParameter.filler)
_has_bits_[0] &= ~0x00000001u;
::caffe::FillerParameter* temp = filler_;
filler_ = nullptr;
return temp;
}
inline ::caffe::FillerParameter* PReLUParameter::_internal_mutable_filler() {
_has_bits_[0] |= 0x00000001u;
if (filler_ == nullptr) {
auto* p = CreateMaybeMessage<::caffe::FillerParameter>(GetArenaForAllocation());
filler_ = p;
}
return filler_;
}
inline ::caffe::FillerParameter* PReLUParameter::mutable_filler() {
::caffe::FillerParameter* _msg = _internal_mutable_filler();
// @@protoc_insertion_point(field_mutable:caffe.PReLUParameter.filler)
return _msg;
}
inline void PReLUParameter::set_allocated_filler(::caffe::FillerParameter* filler) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete filler_;
}
if (filler) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::caffe::FillerParameter>::GetOwningArena(filler);
if (message_arena != submessage_arena) {
filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, filler, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
filler_ = filler;
// @@protoc_insertion_point(field_set_allocated:caffe.PReLUParameter.filler)
}
// optional bool channel_shared = 2 [default = false];
inline bool PReLUParameter::_internal_has_channel_shared() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool PReLUParameter::has_channel_shared() const {
return _internal_has_channel_shared();
}
inline void PReLUParameter::clear_channel_shared() {
channel_shared_ = false;
_has_bits_[0] &= ~0x00000002u;
}
inline bool PReLUParameter::_internal_channel_shared() const {
return channel_shared_;
}
inline bool PReLUParameter::channel_shared() const {
// @@protoc_insertion_point(field_get:caffe.PReLUParameter.channel_shared)
return _internal_channel_shared();
}
inline void PReLUParameter::_internal_set_channel_shared(bool value) {
_has_bits_[0] |= 0x00000002u;
channel_shared_ = value;
}
inline void PReLUParameter::set_channel_shared(bool value) {
_internal_set_channel_shared(value);
// @@protoc_insertion_point(field_set:caffe.PReLUParameter.channel_shared)
}
// -------------------------------------------------------------------
// ShuffleChannelParameter
// optional uint32 group = 1 [default = 1];
inline bool ShuffleChannelParameter::_internal_has_group() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ShuffleChannelParameter::has_group() const {
return _internal_has_group();
}
inline void ShuffleChannelParameter::clear_group() {
group_ = 1u;
_has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ShuffleChannelParameter::_internal_group() const {
return group_;
}
inline uint32_t ShuffleChannelParameter::group() const {
// @@protoc_insertion_point(field_get:caffe.ShuffleChannelParameter.group)
return _internal_group();
}
inline void ShuffleChannelParameter::_internal_set_group(uint32_t value) {
_has_bits_[0] |= 0x00000001u;
group_ = value;
}
inline void ShuffleChannelParameter::set_group(uint32_t value) {
_internal_set_group(value);
// @@protoc_insertion_point(field_set:caffe.ShuffleChannelParameter.group)
}
// -------------------------------------------------------------------
// UpsampleParameter
// optional float scale = 1;
inline bool UpsampleParameter::_internal_has_scale() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool UpsampleParameter::has_scale() const {
return _internal_has_scale();
}
inline void UpsampleParameter::clear_scale() {
scale_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline float UpsampleParameter::_internal_scale() const {
return scale_;
}
inline float UpsampleParameter::scale() const {
// @@protoc_insertion_point(field_get:caffe.UpsampleParameter.scale)
return _internal_scale();
}
inline void UpsampleParameter::_internal_set_scale(float value) {
_has_bits_[0] |= 0x00000001u;
scale_ = value;
}
inline void UpsampleParameter::set_scale(float value) {
_internal_set_scale(value);
// @@protoc_insertion_point(field_set:caffe.UpsampleParameter.scale)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace caffe
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::caffe::EmitConstraint_EmitType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::EmitConstraint_EmitType>() {
return ::caffe::EmitConstraint_EmitType_descriptor();
}
template <> struct is_proto_enum< ::caffe::AnnotatedDatum_AnnotationType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::AnnotatedDatum_AnnotationType>() {
return ::caffe::AnnotatedDatum_AnnotationType_descriptor();
}
template <> struct is_proto_enum< ::caffe::FillerParameter_VarianceNorm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::FillerParameter_VarianceNorm>() {
return ::caffe::FillerParameter_VarianceNorm_descriptor();
}
template <> struct is_proto_enum< ::caffe::SolverParameter_SnapshotFormat> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SolverParameter_SnapshotFormat>() {
return ::caffe::SolverParameter_SnapshotFormat_descriptor();
}
template <> struct is_proto_enum< ::caffe::SolverParameter_SolverMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SolverParameter_SolverMode>() {
return ::caffe::SolverParameter_SolverMode_descriptor();
}
template <> struct is_proto_enum< ::caffe::SolverParameter_SolverType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SolverParameter_SolverType>() {
return ::caffe::SolverParameter_SolverType_descriptor();
}
template <> struct is_proto_enum< ::caffe::ParamSpec_DimCheckMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ParamSpec_DimCheckMode>() {
return ::caffe::ParamSpec_DimCheckMode_descriptor();
}
template <> struct is_proto_enum< ::caffe::Im2seqParameter_Direction> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::Im2seqParameter_Direction>() {
return ::caffe::Im2seqParameter_Direction_descriptor();
}
template <> struct is_proto_enum< ::caffe::ResizeParameter_Resize_mode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ResizeParameter_Resize_mode>() {
return ::caffe::ResizeParameter_Resize_mode_descriptor();
}
template <> struct is_proto_enum< ::caffe::ResizeParameter_Pad_mode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ResizeParameter_Pad_mode>() {
return ::caffe::ResizeParameter_Pad_mode_descriptor();
}
template <> struct is_proto_enum< ::caffe::ResizeParameter_Interp_mode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ResizeParameter_Interp_mode>() {
return ::caffe::ResizeParameter_Interp_mode_descriptor();
}
template <> struct is_proto_enum< ::caffe::LossParameter_NormalizationMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::LossParameter_NormalizationMode>() {
return ::caffe::LossParameter_NormalizationMode_descriptor();
}
template <> struct is_proto_enum< ::caffe::ConvolutionParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ConvolutionParameter_Engine>() {
return ::caffe::ConvolutionParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::caffe::DataParameter_DB> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::DataParameter_DB>() {
return ::caffe::DataParameter_DB_descriptor();
}
template <> struct is_proto_enum< ::caffe::EltwiseParameter_EltwiseOp> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::EltwiseParameter_EltwiseOp>() {
return ::caffe::EltwiseParameter_EltwiseOp_descriptor();
}
template <> struct is_proto_enum< ::caffe::HingeLossParameter_Norm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::HingeLossParameter_Norm>() {
return ::caffe::HingeLossParameter_Norm_descriptor();
}
template <> struct is_proto_enum< ::caffe::LRNParameter_NormRegion> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::LRNParameter_NormRegion>() {
return ::caffe::LRNParameter_NormRegion_descriptor();
}
template <> struct is_proto_enum< ::caffe::LRNParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::LRNParameter_Engine>() {
return ::caffe::LRNParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::caffe::MultiBoxLossParameter_LocLossType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::MultiBoxLossParameter_LocLossType>() {
return ::caffe::MultiBoxLossParameter_LocLossType_descriptor();
}
template <> struct is_proto_enum< ::caffe::MultiBoxLossParameter_ConfLossType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::MultiBoxLossParameter_ConfLossType>() {
return ::caffe::MultiBoxLossParameter_ConfLossType_descriptor();
}
template <> struct is_proto_enum< ::caffe::MultiBoxLossParameter_MatchType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::MultiBoxLossParameter_MatchType>() {
return ::caffe::MultiBoxLossParameter_MatchType_descriptor();
}
template <> struct is_proto_enum< ::caffe::MultiBoxLossParameter_MiningType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::MultiBoxLossParameter_MiningType>() {
return ::caffe::MultiBoxLossParameter_MiningType_descriptor();
}
template <> struct is_proto_enum< ::caffe::PoolingParameter_PoolMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::PoolingParameter_PoolMethod>() {
return ::caffe::PoolingParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::caffe::PoolingParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::PoolingParameter_Engine>() {
return ::caffe::PoolingParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::caffe::PoolingParameter_RoundMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::PoolingParameter_RoundMode>() {
return ::caffe::PoolingParameter_RoundMode_descriptor();
}
template <> struct is_proto_enum< ::caffe::Pooling3DParameter_PoolMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::Pooling3DParameter_PoolMethod>() {
return ::caffe::Pooling3DParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::caffe::PriorBoxParameter_CodeType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::PriorBoxParameter_CodeType>() {
return ::caffe::PriorBoxParameter_CodeType_descriptor();
}
template <> struct is_proto_enum< ::caffe::ReductionParameter_ReductionOp> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ReductionParameter_ReductionOp>() {
return ::caffe::ReductionParameter_ReductionOp_descriptor();
}
template <> struct is_proto_enum< ::caffe::ReLUParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ReLUParameter_Engine>() {
return ::caffe::ReLUParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::caffe::SigmoidParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SigmoidParameter_Engine>() {
return ::caffe::SigmoidParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::caffe::SoftmaxParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SoftmaxParameter_Engine>() {
return ::caffe::SoftmaxParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::caffe::TanHParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::TanHParameter_Engine>() {
return ::caffe::TanHParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::caffe::SPPParameter_PoolMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SPPParameter_PoolMethod>() {
return ::caffe::SPPParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::caffe::SPPParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SPPParameter_Engine>() {
return ::caffe::SPPParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::caffe::V1LayerParameter_LayerType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::V1LayerParameter_LayerType>() {
return ::caffe::V1LayerParameter_LayerType_descriptor();
}
template <> struct is_proto_enum< ::caffe::V1LayerParameter_DimCheckMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::V1LayerParameter_DimCheckMode>() {
return ::caffe::V1LayerParameter_DimCheckMode_descriptor();
}
template <> struct is_proto_enum< ::caffe::V0LayerParameter_PoolMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::V0LayerParameter_PoolMethod>() {
return ::caffe::V0LayerParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::caffe::Phase> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::Phase>() {
return ::caffe::Phase_descriptor();
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_caffe_2eproto
Reference in New Issue View Git Blame Copy Permalink