// 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 #include #include #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 #include #include #include #include #include #include #include #include #include #include // IWYU pragma: export #include // IWYU pragma: export #include #include // @@protoc_insertion_point(includes) #include #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 inline const std::string& EmitConstraint_EmitType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& AnnotatedDatum_AnnotationType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& FillerParameter_VarianceNorm_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& SolverParameter_SnapshotFormat_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& SolverParameter_SolverMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& SolverParameter_SolverType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& ParamSpec_DimCheckMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& Im2seqParameter_Direction_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& ResizeParameter_Resize_mode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& ResizeParameter_Pad_mode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& ResizeParameter_Interp_mode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& LossParameter_NormalizationMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& ConvolutionParameter_Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& DataParameter_DB_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& EltwiseParameter_EltwiseOp_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& HingeLossParameter_Norm_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& LRNParameter_NormRegion_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& LRNParameter_Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& MultiBoxLossParameter_LocLossType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& MultiBoxLossParameter_ConfLossType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& MultiBoxLossParameter_MatchType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& MultiBoxLossParameter_MiningType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& PoolingParameter_PoolMethod_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& PoolingParameter_Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& PoolingParameter_RoundMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& Pooling3DParameter_PoolMethod_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& PriorBoxParameter_CodeType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& ReductionParameter_ReductionOp_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& ReLUParameter_Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& SigmoidParameter_Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& SoftmaxParameter_Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& TanHParameter_Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& SPPParameter_PoolMethod_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& SPPParameter_Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& V1LayerParameter_LayerType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& V1LayerParameter_DimCheckMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& V0LayerParameter_PoolMethod_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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 inline const std::string& Phase_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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_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( &_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(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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dim_; mutable std::atomic _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( &_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(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 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( &_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(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 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( &_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(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 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 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 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( &_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(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 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( &_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(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 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( &_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(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 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 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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& EmitType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& AnnotationType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 static inline const std::string& VarianceNorm_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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 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( &_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(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& input() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 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 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 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( &_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(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 static inline const std::string& SnapshotFormat_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& SolverMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& SolverType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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& test_net() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 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 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 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 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 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 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 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 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 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 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( &_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(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 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 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( &_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(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& stage() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 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 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( &_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(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& stage() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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& not_stage() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 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 stage_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( &_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(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 static inline const std::string& DimCheckMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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 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( &_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(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& bottom() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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& top() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 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 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 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 bottom_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& Direction_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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 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( &_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(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 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( &_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(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 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 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 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 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( &_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(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 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 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( &_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(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 static inline const std::string& Resize_mode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& Pad_mode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& Interp_mode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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* _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& interp_mode() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField* 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 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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& NormalizationMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& DB_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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 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 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( &_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(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 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 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( &_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(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 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( &_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(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 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 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 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 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 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 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( &_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(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 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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& EltwiseOp_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 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 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( &_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(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 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 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( &_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(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 static inline const std::string& Norm_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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 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 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 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( &_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(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 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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& NormRegion_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 static inline const std::string& LocLossType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& ConfLossType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& MatchType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& MiningType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& PoolMethod_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& RoundMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 static inline const std::string& PoolMethod_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 static inline const std::string& CodeType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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 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 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 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( &_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(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 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( &_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(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 static inline const std::string& ReductionOp_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 static inline const std::string& Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 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( &_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(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 static inline const std::string& Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 static inline const std::string& Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 static inline const std::string& Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 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( &_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(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 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( &_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(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 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 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 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 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 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( &_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(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 static inline const std::string& PoolMethod_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& Engine_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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( &_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(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 static inline const std::string& LayerType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 static inline const std::string& DimCheckMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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& bottom() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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& top() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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& param() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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* _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& blob_share_mode() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField* 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 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 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 bottom_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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 param_; ::PROTOBUF_NAMESPACE_ID::RepeatedField 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( &_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(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 static inline const std::string& PoolMethod_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::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 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 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 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 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 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 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( &_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(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 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( &_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(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 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( &_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(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 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( ::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 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(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 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(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( ::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( ::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 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(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 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(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( ::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( ::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( ::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( ::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 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(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 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(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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.NetParameter.input) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& NetParameter::input() const { // @@protoc_insertion_point(field_list:caffe.NetParameter.input) return input_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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( ::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 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(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( ::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 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(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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.SolverParameter.test_net) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& SolverParameter::test_net() const { // @@protoc_insertion_point(field_list:caffe.SolverParameter.test_net) return test_net_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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( ::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( ::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 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(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 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(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 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(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 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(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 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(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 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(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 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(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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.NetState.stage) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& NetState::stage() const { // @@protoc_insertion_point(field_list:caffe.NetState.stage) return stage_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.NetStateRule.stage) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& NetStateRule::stage() const { // @@protoc_insertion_point(field_list:caffe.NetStateRule.stage) return stage_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.NetStateRule.not_stage) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& NetStateRule::not_stage() const { // @@protoc_insertion_point(field_list:caffe.NetStateRule.not_stage) return not_stage_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* NetStateRule::mutable_not_stage() { // @@protoc_insertion_point(field_mutable_list:caffe.NetStateRule.not_stage) return ¬_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 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(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 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(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 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(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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.LayerParameter.bottom) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& LayerParameter::bottom() const { // @@protoc_insertion_point(field_list:caffe.LayerParameter.bottom) return bottom_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.LayerParameter.top) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& LayerParameter::top() const { // @@protoc_insertion_point(field_list:caffe.LayerParameter.top) return top_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 ¶m_; } 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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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 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(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 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(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 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(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 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(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 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(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( ::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( ::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( ::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( ::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( ::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& ResizeParameter::interp_mode() const { // @@protoc_insertion_point(field_list:caffe.ResizeParameter.interp_mode) return interp_mode_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* ResizeParameter::_internal_mutable_interp_mode() { return &interp_mode_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* 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( ::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 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(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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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 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(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 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(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 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(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( ::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 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(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 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(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 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(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 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(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 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(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( ::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( ::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( ::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 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(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( ::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( ::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 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(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 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(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 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(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 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(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 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(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 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(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( ::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( ::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( ::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( ::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( ::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 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(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 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(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 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(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( ::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( ::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( ::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( ::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( ::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 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(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 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(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 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(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 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(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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.bottom) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& V1LayerParameter::bottom() const { // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.bottom) return bottom_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.top) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& V1LayerParameter::top() const { // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.top) return top_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 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(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(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(value), size); // @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.param) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& V1LayerParameter::param() const { // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.param) return param_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* V1LayerParameter::mutable_param() { // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.param) return ¶m_; } // 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& V1LayerParameter::blob_share_mode() const { // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blob_share_mode) return blob_share_mode_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* V1LayerParameter::_internal_mutable_blob_share_mode() { return &blob_share_mode_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* 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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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( ::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 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(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 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(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( ::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( ::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 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(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 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(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 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(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( ::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( ::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 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_caffe_2eproto