// Generated by the protocol buffer compiler. DO NOT EDIT! // source: opencv-caffe.proto #include "opencv-caffe.pb.h" #include #include #include #include #include #include #include #include // @@protoc_insertion_point(includes) #include PROTOBUF_PRAGMA_INIT_SEG namespace opencv_caffe { constexpr BlobShape::BlobShape( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : dim_() , _dim_cached_byte_size_(0){} struct BlobShapeDefaultTypeInternal { constexpr BlobShapeDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~BlobShapeDefaultTypeInternal() {} union { BlobShape _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BlobShapeDefaultTypeInternal _BlobShape_default_instance_; constexpr BlobProto::BlobProto( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : data_() , diff_() , double_data_() , double_diff_() , raw_data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , shape_(nullptr) , num_(0) , channels_(0) , height_(0) , width_(0) , raw_data_type_(0) {} struct BlobProtoDefaultTypeInternal { constexpr BlobProtoDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~BlobProtoDefaultTypeInternal() {} union { BlobProto _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BlobProtoDefaultTypeInternal _BlobProto_default_instance_; constexpr BlobProtoVector::BlobProtoVector( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : blobs_(){} struct BlobProtoVectorDefaultTypeInternal { constexpr BlobProtoVectorDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~BlobProtoVectorDefaultTypeInternal() {} union { BlobProtoVector _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BlobProtoVectorDefaultTypeInternal _BlobProtoVector_default_instance_; constexpr PermuteParameter::PermuteParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : order_(){} struct PermuteParameterDefaultTypeInternal { constexpr PermuteParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~PermuteParameterDefaultTypeInternal() {} union { PermuteParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PermuteParameterDefaultTypeInternal _PermuteParameter_default_instance_; constexpr NormalizeBBoxParameter::NormalizeBBoxParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : scale_filler_(nullptr) , across_spatial_(true) , channel_shared_(true) , eps_(1e-10f){} struct NormalizeBBoxParameterDefaultTypeInternal { constexpr NormalizeBBoxParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NormalizeBBoxParameterDefaultTypeInternal() {} union { NormalizeBBoxParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NormalizeBBoxParameterDefaultTypeInternal _NormalizeBBoxParameter_default_instance_; constexpr PriorBoxParameter::PriorBoxParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : min_size_() , max_size_() , aspect_ratio_() , variance_() , offset_h_() , offset_w_() , width_() , height_() , img_size_(0u) , img_h_(0u) , img_w_(0u) , step_(0) , step_h_(0) , step_w_(0) , flip_(true) , clip_(true) , offset_(0.5f){} struct PriorBoxParameterDefaultTypeInternal { constexpr PriorBoxParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~PriorBoxParameterDefaultTypeInternal() {} union { PriorBoxParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PriorBoxParameterDefaultTypeInternal _PriorBoxParameter_default_instance_; constexpr DetectionOutputParameter::DetectionOutputParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : nms_param_(nullptr) , save_output_param_(nullptr) , num_classes_(0u) , background_label_id_(0) , confidence_threshold_(0) , variance_encoded_in_target_(false) , clip_(false) , keep_top_k_(-1) , code_type_(1) , share_location_(true) , normalized_bbox_(true){} struct DetectionOutputParameterDefaultTypeInternal { constexpr DetectionOutputParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~DetectionOutputParameterDefaultTypeInternal() {} union { DetectionOutputParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DetectionOutputParameterDefaultTypeInternal _DetectionOutputParameter_default_instance_; constexpr Datum::Datum( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : float_data_() , data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , channels_(0) , height_(0) , width_(0) , label_(0) , encoded_(false){} struct DatumDefaultTypeInternal { constexpr DatumDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~DatumDefaultTypeInternal() {} union { Datum _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DatumDefaultTypeInternal _Datum_default_instance_; constexpr FillerParameter::FillerParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : type_(nullptr) , value_(0) , min_(0) , mean_(0) , variance_norm_(0) , sparse_(-1) , max_(1) , std_(1){} struct FillerParameterDefaultTypeInternal { constexpr FillerParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~FillerParameterDefaultTypeInternal() {} union { FillerParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FillerParameterDefaultTypeInternal _FillerParameter_default_instance_; constexpr NetParameter::NetParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : layers_() , input_() , input_dim_() , input_shape_() , layer_() , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , state_(nullptr) , force_backward_(false) , debug_info_(false){} struct NetParameterDefaultTypeInternal { constexpr NetParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NetParameterDefaultTypeInternal() {} union { NetParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NetParameterDefaultTypeInternal _NetParameter_default_instance_; constexpr SolverParameter::SolverParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : test_net_() , test_iter_() , test_net_param_() , test_state_() , stepvalue_() , train_net_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , lr_policy_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , snapshot_prefix_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , net_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , regularization_type_(nullptr) , type_(nullptr) , train_net_param_(nullptr) , net_param_(nullptr) , train_state_(nullptr) , test_interval_(0) , base_lr_(0) , display_(0) , max_iter_(0) , gamma_(0) , power_(0) , momentum_(0) , weight_decay_(0) , stepsize_(0) , snapshot_(0) , device_id_(0) , test_compute_loss_(false) , snapshot_diff_(false) , debug_info_(false) , solver_type_(0) , momentum2_(0.999f) , random_seed_(int64_t{-1}) , solver_mode_(1) , test_initialization_(true) , snapshot_after_train_(true) , delta_(1e-08f) , average_loss_(1) , clip_gradients_(-1) , iter_size_(1) , snapshot_format_(1) , rms_decay_(0.99f){} struct SolverParameterDefaultTypeInternal { constexpr SolverParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SolverParameterDefaultTypeInternal() {} union { SolverParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SolverParameterDefaultTypeInternal _SolverParameter_default_instance_; constexpr SolverState::SolverState( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : history_() , learned_net_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , iter_(0) , current_step_(0){} struct SolverStateDefaultTypeInternal { constexpr SolverStateDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SolverStateDefaultTypeInternal() {} union { SolverState _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SolverStateDefaultTypeInternal _SolverState_default_instance_; constexpr NetState::NetState( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : stage_() , level_(0) , phase_(1) {} struct NetStateDefaultTypeInternal { constexpr NetStateDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NetStateDefaultTypeInternal() {} union { NetState _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NetStateDefaultTypeInternal _NetState_default_instance_; constexpr NetStateRule::NetStateRule( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : stage_() , not_stage_() , phase_(0) , min_level_(0) , max_level_(0){} struct NetStateRuleDefaultTypeInternal { constexpr NetStateRuleDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NetStateRuleDefaultTypeInternal() {} union { NetStateRule _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NetStateRuleDefaultTypeInternal _NetStateRule_default_instance_; constexpr ParamSpec::ParamSpec( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , share_mode_(0) , lr_mult_(1) , decay_mult_(1){} struct ParamSpecDefaultTypeInternal { constexpr ParamSpecDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ParamSpecDefaultTypeInternal() {} union { ParamSpec _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParamSpecDefaultTypeInternal _ParamSpec_default_instance_; constexpr LayerParameter::LayerParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : bottom_() , top_() , loss_weight_() , param_() , blobs_() , include_() , exclude_() , propagate_down_() , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , type_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , transform_param_(nullptr) , loss_param_(nullptr) , accuracy_param_(nullptr) , argmax_param_(nullptr) , concat_param_(nullptr) , contrastive_loss_param_(nullptr) , convolution_param_(nullptr) , data_param_(nullptr) , dropout_param_(nullptr) , dummy_data_param_(nullptr) , eltwise_param_(nullptr) , exp_param_(nullptr) , hdf5_data_param_(nullptr) , hdf5_output_param_(nullptr) , hinge_loss_param_(nullptr) , image_data_param_(nullptr) , infogain_loss_param_(nullptr) , inner_product_param_(nullptr) , lrn_param_(nullptr) , memory_data_param_(nullptr) , mvn_param_(nullptr) , pooling_param_(nullptr) , power_param_(nullptr) , relu_param_(nullptr) , sigmoid_param_(nullptr) , softmax_param_(nullptr) , slice_param_(nullptr) , tanh_param_(nullptr) , threshold_param_(nullptr) , window_data_param_(nullptr) , python_param_(nullptr) , prelu_param_(nullptr) , spp_param_(nullptr) , reshape_param_(nullptr) , log_param_(nullptr) , flatten_param_(nullptr) , reduction_param_(nullptr) , embed_param_(nullptr) , tile_param_(nullptr) , batch_norm_param_(nullptr) , elu_param_(nullptr) , bias_param_(nullptr) , scale_param_(nullptr) , input_param_(nullptr) , crop_param_(nullptr) , parameter_param_(nullptr) , recurrent_param_(nullptr) , detection_output_param_(nullptr) , permute_param_(nullptr) , norm_param_(nullptr) , prior_box_param_(nullptr) , proposal_param_(nullptr) , psroi_pooling_param_(nullptr) , roi_pooling_param_(nullptr) , phase_(0) {} struct LayerParameterDefaultTypeInternal { constexpr LayerParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~LayerParameterDefaultTypeInternal() {} union { LayerParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LayerParameterDefaultTypeInternal _LayerParameter_default_instance_; constexpr TransformationParameter::TransformationParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : mean_value_() , mean_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , crop_size_(0u) , mirror_(false) , force_color_(false) , force_gray_(false) , scale_(1){} struct TransformationParameterDefaultTypeInternal { constexpr TransformationParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~TransformationParameterDefaultTypeInternal() {} union { TransformationParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TransformationParameterDefaultTypeInternal _TransformationParameter_default_instance_; constexpr LossParameter::LossParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : ignore_label_(0) , normalize_(false) , normalization_(1) {} struct LossParameterDefaultTypeInternal { constexpr LossParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~LossParameterDefaultTypeInternal() {} union { LossParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LossParameterDefaultTypeInternal _LossParameter_default_instance_; constexpr AccuracyParameter::AccuracyParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : ignore_label_(0) , top_k_(1u) , axis_(1){} struct AccuracyParameterDefaultTypeInternal { constexpr AccuracyParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~AccuracyParameterDefaultTypeInternal() {} union { AccuracyParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AccuracyParameterDefaultTypeInternal _AccuracyParameter_default_instance_; constexpr ArgMaxParameter::ArgMaxParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : out_max_val_(false) , axis_(0) , top_k_(1u){} struct ArgMaxParameterDefaultTypeInternal { constexpr ArgMaxParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ArgMaxParameterDefaultTypeInternal() {} union { ArgMaxParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ArgMaxParameterDefaultTypeInternal _ArgMaxParameter_default_instance_; constexpr ConcatParameter::ConcatParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : concat_dim_(1u) , axis_(1){} struct ConcatParameterDefaultTypeInternal { constexpr ConcatParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ConcatParameterDefaultTypeInternal() {} union { ConcatParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConcatParameterDefaultTypeInternal _ConcatParameter_default_instance_; constexpr BatchNormParameter::BatchNormParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : use_global_stats_(false) , scale_bias_(false) , moving_average_fraction_(0.999f) , eps_(1e-05f){} struct BatchNormParameterDefaultTypeInternal { constexpr BatchNormParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~BatchNormParameterDefaultTypeInternal() {} union { BatchNormParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BatchNormParameterDefaultTypeInternal _BatchNormParameter_default_instance_; constexpr BiasParameter::BiasParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : filler_(nullptr) , axis_(1) , num_axes_(1){} struct BiasParameterDefaultTypeInternal { constexpr BiasParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~BiasParameterDefaultTypeInternal() {} union { BiasParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BiasParameterDefaultTypeInternal _BiasParameter_default_instance_; constexpr ContrastiveLossParameter::ContrastiveLossParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : legacy_version_(false) , margin_(1){} struct ContrastiveLossParameterDefaultTypeInternal { constexpr ContrastiveLossParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ContrastiveLossParameterDefaultTypeInternal() {} union { ContrastiveLossParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ContrastiveLossParameterDefaultTypeInternal _ContrastiveLossParameter_default_instance_; constexpr ConvolutionParameter::ConvolutionParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : pad_() , kernel_size_() , stride_() , dilation_() , weight_filler_(nullptr) , bias_filler_(nullptr) , num_output_(0u) , pad_h_(0u) , pad_w_(0u) , kernel_h_(0u) , kernel_w_(0u) , stride_h_(0u) , stride_w_(0u) , engine_(0) , force_nd_im2col_(false) , axis_(1) , bias_term_(true) , group_(1u){} struct ConvolutionParameterDefaultTypeInternal { constexpr ConvolutionParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ConvolutionParameterDefaultTypeInternal() {} union { ConvolutionParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConvolutionParameterDefaultTypeInternal _ConvolutionParameter_default_instance_; constexpr CropParameter::CropParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : offset_() , axis_(2){} struct CropParameterDefaultTypeInternal { constexpr CropParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~CropParameterDefaultTypeInternal() {} union { CropParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CropParameterDefaultTypeInternal _CropParameter_default_instance_; constexpr DataParameter::DataParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , mean_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , batch_size_(0u) , crop_size_(0u) , rand_skip_(0u) , mirror_(false) , force_encoded_color_(false) , backend_(0) , scale_(1) , prefetch_(4u){} struct DataParameterDefaultTypeInternal { constexpr DataParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~DataParameterDefaultTypeInternal() {} union { DataParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DataParameterDefaultTypeInternal _DataParameter_default_instance_; constexpr NonMaximumSuppressionParameter::NonMaximumSuppressionParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : top_k_(0) , nms_threshold_(0.3f) , eta_(1){} struct NonMaximumSuppressionParameterDefaultTypeInternal { constexpr NonMaximumSuppressionParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NonMaximumSuppressionParameterDefaultTypeInternal() {} union { NonMaximumSuppressionParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NonMaximumSuppressionParameterDefaultTypeInternal _NonMaximumSuppressionParameter_default_instance_; constexpr SaveOutputParameter::SaveOutputParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : output_directory_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , output_name_prefix_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , output_format_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , label_map_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , name_size_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , num_test_image_(0u){} struct SaveOutputParameterDefaultTypeInternal { constexpr SaveOutputParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SaveOutputParameterDefaultTypeInternal() {} union { SaveOutputParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SaveOutputParameterDefaultTypeInternal _SaveOutputParameter_default_instance_; constexpr DropoutParameter::DropoutParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : dropout_ratio_(0.5f) , scale_train_(true){} struct DropoutParameterDefaultTypeInternal { constexpr DropoutParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~DropoutParameterDefaultTypeInternal() {} union { DropoutParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DropoutParameterDefaultTypeInternal _DropoutParameter_default_instance_; constexpr DummyDataParameter::DummyDataParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : data_filler_() , num_() , channels_() , height_() , width_() , shape_(){} struct DummyDataParameterDefaultTypeInternal { constexpr DummyDataParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~DummyDataParameterDefaultTypeInternal() {} union { DummyDataParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DummyDataParameterDefaultTypeInternal _DummyDataParameter_default_instance_; constexpr EltwiseParameter::EltwiseParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : coeff_() , operation_(1) , stable_prod_grad_(true){} struct EltwiseParameterDefaultTypeInternal { constexpr EltwiseParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~EltwiseParameterDefaultTypeInternal() {} union { EltwiseParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT EltwiseParameterDefaultTypeInternal _EltwiseParameter_default_instance_; constexpr ELUParameter::ELUParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : alpha_(1){} struct ELUParameterDefaultTypeInternal { constexpr ELUParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ELUParameterDefaultTypeInternal() {} union { ELUParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ELUParameterDefaultTypeInternal _ELUParameter_default_instance_; constexpr EmbedParameter::EmbedParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : weight_filler_(nullptr) , bias_filler_(nullptr) , num_output_(0u) , input_dim_(0u) , bias_term_(true){} struct EmbedParameterDefaultTypeInternal { constexpr EmbedParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~EmbedParameterDefaultTypeInternal() {} union { EmbedParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT EmbedParameterDefaultTypeInternal _EmbedParameter_default_instance_; constexpr ExpParameter::ExpParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : shift_(0) , base_(-1) , scale_(1){} struct ExpParameterDefaultTypeInternal { constexpr ExpParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ExpParameterDefaultTypeInternal() {} union { ExpParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExpParameterDefaultTypeInternal _ExpParameter_default_instance_; constexpr FlattenParameter::FlattenParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : axis_(1) , end_axis_(-1){} struct FlattenParameterDefaultTypeInternal { constexpr FlattenParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~FlattenParameterDefaultTypeInternal() {} union { FlattenParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FlattenParameterDefaultTypeInternal _FlattenParameter_default_instance_; constexpr HDF5DataParameter::HDF5DataParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , batch_size_(0u) , shuffle_(false){} struct HDF5DataParameterDefaultTypeInternal { constexpr HDF5DataParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~HDF5DataParameterDefaultTypeInternal() {} union { HDF5DataParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT HDF5DataParameterDefaultTypeInternal _HDF5DataParameter_default_instance_; constexpr HDF5OutputParameter::HDF5OutputParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : file_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct HDF5OutputParameterDefaultTypeInternal { constexpr HDF5OutputParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~HDF5OutputParameterDefaultTypeInternal() {} union { HDF5OutputParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT HDF5OutputParameterDefaultTypeInternal _HDF5OutputParameter_default_instance_; constexpr HingeLossParameter::HingeLossParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : norm_(1) {} struct HingeLossParameterDefaultTypeInternal { constexpr HingeLossParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~HingeLossParameterDefaultTypeInternal() {} union { HingeLossParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT HingeLossParameterDefaultTypeInternal _HingeLossParameter_default_instance_; constexpr ImageDataParameter::ImageDataParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , mean_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , root_folder_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , crop_size_(0u) , rand_skip_(0u) , shuffle_(false) , mirror_(false) , new_height_(0u) , new_width_(0u) , is_color_(true) , scale_(1) , batch_size_(1u){} struct ImageDataParameterDefaultTypeInternal { constexpr ImageDataParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ImageDataParameterDefaultTypeInternal() {} union { ImageDataParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ImageDataParameterDefaultTypeInternal _ImageDataParameter_default_instance_; constexpr InfogainLossParameter::InfogainLossParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct InfogainLossParameterDefaultTypeInternal { constexpr InfogainLossParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~InfogainLossParameterDefaultTypeInternal() {} union { InfogainLossParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InfogainLossParameterDefaultTypeInternal _InfogainLossParameter_default_instance_; constexpr InnerProductParameter::InnerProductParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : weight_filler_(nullptr) , bias_filler_(nullptr) , num_output_(0u) , transpose_(false) , bias_term_(true) , axis_(1){} struct InnerProductParameterDefaultTypeInternal { constexpr InnerProductParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~InnerProductParameterDefaultTypeInternal() {} union { InnerProductParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InnerProductParameterDefaultTypeInternal _InnerProductParameter_default_instance_; constexpr InputParameter::InputParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : shape_(){} struct InputParameterDefaultTypeInternal { constexpr InputParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~InputParameterDefaultTypeInternal() {} union { InputParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InputParameterDefaultTypeInternal _InputParameter_default_instance_; constexpr LogParameter::LogParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : shift_(0) , base_(-1) , scale_(1){} struct LogParameterDefaultTypeInternal { constexpr LogParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~LogParameterDefaultTypeInternal() {} union { LogParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LogParameterDefaultTypeInternal _LogParameter_default_instance_; constexpr LRNParameter::LRNParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : norm_region_(0) , engine_(0) , local_size_(5u) , alpha_(1) , beta_(0.75f) , k_(1){} struct LRNParameterDefaultTypeInternal { constexpr LRNParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~LRNParameterDefaultTypeInternal() {} union { LRNParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LRNParameterDefaultTypeInternal _LRNParameter_default_instance_; constexpr MemoryDataParameter::MemoryDataParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : batch_size_(0u) , channels_(0u) , height_(0u) , width_(0u){} struct MemoryDataParameterDefaultTypeInternal { constexpr MemoryDataParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~MemoryDataParameterDefaultTypeInternal() {} union { MemoryDataParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MemoryDataParameterDefaultTypeInternal _MemoryDataParameter_default_instance_; constexpr MVNParameter::MVNParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : across_channels_(false) , normalize_variance_(true) , eps_(1e-09f){} struct MVNParameterDefaultTypeInternal { constexpr MVNParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~MVNParameterDefaultTypeInternal() {} union { MVNParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MVNParameterDefaultTypeInternal _MVNParameter_default_instance_; constexpr ParameterParameter::ParameterParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : shape_(nullptr){} struct ParameterParameterDefaultTypeInternal { constexpr ParameterParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ParameterParameterDefaultTypeInternal() {} union { ParameterParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterParameterDefaultTypeInternal _ParameterParameter_default_instance_; constexpr PoolingParameter::PoolingParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : pool_(0) , kernel_size_(0u) , pad_(0u) , kernel_h_(0u) , kernel_w_(0u) , stride_h_(0u) , stride_w_(0u) , pad_h_(0u) , pad_w_(0u) , engine_(0) , global_pooling_(false) , stride_(1u) , ceil_mode_(true){} struct PoolingParameterDefaultTypeInternal { constexpr PoolingParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~PoolingParameterDefaultTypeInternal() {} union { PoolingParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PoolingParameterDefaultTypeInternal _PoolingParameter_default_instance_; constexpr PowerParameter::PowerParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : shift_(0) , power_(1) , scale_(1){} struct PowerParameterDefaultTypeInternal { constexpr PowerParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~PowerParameterDefaultTypeInternal() {} union { PowerParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PowerParameterDefaultTypeInternal _PowerParameter_default_instance_; constexpr PythonParameter::PythonParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : module_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , layer_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , param_str_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , share_in_parallel_(false){} struct PythonParameterDefaultTypeInternal { constexpr PythonParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~PythonParameterDefaultTypeInternal() {} union { PythonParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PythonParameterDefaultTypeInternal _PythonParameter_default_instance_; constexpr RecurrentParameter::RecurrentParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : weight_filler_(nullptr) , bias_filler_(nullptr) , num_output_(0u) , debug_info_(false) , expose_hidden_(false){} struct RecurrentParameterDefaultTypeInternal { constexpr RecurrentParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~RecurrentParameterDefaultTypeInternal() {} union { RecurrentParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecurrentParameterDefaultTypeInternal _RecurrentParameter_default_instance_; constexpr ReductionParameter::ReductionParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : axis_(0) , operation_(1) , coeff_(1){} struct ReductionParameterDefaultTypeInternal { constexpr ReductionParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ReductionParameterDefaultTypeInternal() {} union { ReductionParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReductionParameterDefaultTypeInternal _ReductionParameter_default_instance_; constexpr ReLUParameter::ReLUParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : negative_slope_(0) , engine_(0) {} struct ReLUParameterDefaultTypeInternal { constexpr ReLUParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ReLUParameterDefaultTypeInternal() {} union { ReLUParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReLUParameterDefaultTypeInternal _ReLUParameter_default_instance_; constexpr ReshapeParameter::ReshapeParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : shape_(nullptr) , axis_(0) , num_axes_(-1){} struct ReshapeParameterDefaultTypeInternal { constexpr ReshapeParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ReshapeParameterDefaultTypeInternal() {} union { ReshapeParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReshapeParameterDefaultTypeInternal _ReshapeParameter_default_instance_; constexpr ScaleParameter::ScaleParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : filler_(nullptr) , bias_filler_(nullptr) , bias_term_(false) , axis_(1) , num_axes_(1){} struct ScaleParameterDefaultTypeInternal { constexpr ScaleParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ScaleParameterDefaultTypeInternal() {} union { ScaleParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ScaleParameterDefaultTypeInternal _ScaleParameter_default_instance_; constexpr SigmoidParameter::SigmoidParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : engine_(0) {} struct SigmoidParameterDefaultTypeInternal { constexpr SigmoidParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SigmoidParameterDefaultTypeInternal() {} union { SigmoidParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SigmoidParameterDefaultTypeInternal _SigmoidParameter_default_instance_; constexpr SliceParameter::SliceParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : slice_point_() , slice_dim_(1u) , axis_(1){} struct SliceParameterDefaultTypeInternal { constexpr SliceParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SliceParameterDefaultTypeInternal() {} union { SliceParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SliceParameterDefaultTypeInternal _SliceParameter_default_instance_; constexpr SoftmaxParameter::SoftmaxParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : engine_(0) , axis_(1){} struct SoftmaxParameterDefaultTypeInternal { constexpr SoftmaxParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SoftmaxParameterDefaultTypeInternal() {} union { SoftmaxParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SoftmaxParameterDefaultTypeInternal _SoftmaxParameter_default_instance_; constexpr TanHParameter::TanHParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : engine_(0) {} struct TanHParameterDefaultTypeInternal { constexpr TanHParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~TanHParameterDefaultTypeInternal() {} union { TanHParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TanHParameterDefaultTypeInternal _TanHParameter_default_instance_; constexpr TileParameter::TileParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : tiles_(0) , axis_(1){} struct TileParameterDefaultTypeInternal { constexpr TileParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~TileParameterDefaultTypeInternal() {} union { TileParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TileParameterDefaultTypeInternal _TileParameter_default_instance_; constexpr ThresholdParameter::ThresholdParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : threshold_(0){} struct ThresholdParameterDefaultTypeInternal { constexpr ThresholdParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ThresholdParameterDefaultTypeInternal() {} union { ThresholdParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ThresholdParameterDefaultTypeInternal _ThresholdParameter_default_instance_; constexpr WindowDataParameter::WindowDataParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , mean_file_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , crop_mode_(nullptr) , root_folder_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , batch_size_(0u) , crop_size_(0u) , mirror_(false) , cache_images_(false) , context_pad_(0u) , scale_(1) , fg_threshold_(0.5f) , bg_threshold_(0.5f) , fg_fraction_(0.25f){} struct WindowDataParameterDefaultTypeInternal { constexpr WindowDataParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~WindowDataParameterDefaultTypeInternal() {} union { WindowDataParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WindowDataParameterDefaultTypeInternal _WindowDataParameter_default_instance_; constexpr SPPParameter::SPPParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : pyramid_height_(0u) , pool_(0) , engine_(0) {} struct SPPParameterDefaultTypeInternal { constexpr SPPParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SPPParameterDefaultTypeInternal() {} union { SPPParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SPPParameterDefaultTypeInternal _SPPParameter_default_instance_; constexpr V1LayerParameter::V1LayerParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : bottom_() , top_() , blobs_() , blobs_lr_() , weight_decay_() , include_() , exclude_() , loss_weight_() , param_() , blob_share_mode_() , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , layer_(nullptr) , concat_param_(nullptr) , convolution_param_(nullptr) , data_param_(nullptr) , dropout_param_(nullptr) , hdf5_data_param_(nullptr) , hdf5_output_param_(nullptr) , image_data_param_(nullptr) , infogain_loss_param_(nullptr) , inner_product_param_(nullptr) , lrn_param_(nullptr) , pooling_param_(nullptr) , window_data_param_(nullptr) , power_param_(nullptr) , memory_data_param_(nullptr) , argmax_param_(nullptr) , eltwise_param_(nullptr) , threshold_param_(nullptr) , dummy_data_param_(nullptr) , accuracy_param_(nullptr) , hinge_loss_param_(nullptr) , relu_param_(nullptr) , slice_param_(nullptr) , mvn_param_(nullptr) , transform_param_(nullptr) , tanh_param_(nullptr) , sigmoid_param_(nullptr) , softmax_param_(nullptr) , contrastive_loss_param_(nullptr) , exp_param_(nullptr) , loss_param_(nullptr) , type_(0) {} struct V1LayerParameterDefaultTypeInternal { constexpr V1LayerParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~V1LayerParameterDefaultTypeInternal() {} union { V1LayerParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT V1LayerParameterDefaultTypeInternal _V1LayerParameter_default_instance_; constexpr V0LayerParameter::V0LayerParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : blobs_() , blobs_lr_() , weight_decay_() , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , type_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , source_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , meanfile_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , det_crop_mode_(nullptr) , weight_filler_(nullptr) , bias_filler_(nullptr) , hdf5_output_param_(nullptr) , num_output_(0u) , pad_(0u) , kernelsize_(0u) , pool_(0) , batchsize_(0u) , cropsize_(0u) , new_width_(0) , mirror_(false) , shuffle_images_(false) , rand_skip_(0u) , det_context_pad_(0u) , new_num_(0) , new_channels_(0) , new_height_(0) , concat_dim_(1u) , biasterm_(true) , group_(1u) , stride_(1u) , dropout_ratio_(0.5f) , local_size_(5u) , alpha_(1) , beta_(0.75f) , scale_(1) , k_(1) , det_fg_threshold_(0.5f) , det_bg_threshold_(0.5f) , det_fg_fraction_(0.25f){} struct V0LayerParameterDefaultTypeInternal { constexpr V0LayerParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~V0LayerParameterDefaultTypeInternal() {} union { V0LayerParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT V0LayerParameterDefaultTypeInternal _V0LayerParameter_default_instance_; constexpr PReLUParameter::PReLUParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : filler_(nullptr) , channel_shared_(false){} struct PReLUParameterDefaultTypeInternal { constexpr PReLUParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~PReLUParameterDefaultTypeInternal() {} union { PReLUParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PReLUParameterDefaultTypeInternal _PReLUParameter_default_instance_; constexpr NormalizedBBox::NormalizedBBox( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : xmin_(0) , ymin_(0) , xmax_(0) , ymax_(0) , label_(0) , difficult_(false) , score_(0) , size_(0){} struct NormalizedBBoxDefaultTypeInternal { constexpr NormalizedBBoxDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NormalizedBBoxDefaultTypeInternal() {} union { NormalizedBBox _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NormalizedBBoxDefaultTypeInternal _NormalizedBBox_default_instance_; constexpr ROIPoolingParameter::ROIPoolingParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : pooled_h_(0u) , pooled_w_(0u) , spatial_scale_(1){} struct ROIPoolingParameterDefaultTypeInternal { constexpr ROIPoolingParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ROIPoolingParameterDefaultTypeInternal() {} union { ROIPoolingParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ROIPoolingParameterDefaultTypeInternal _ROIPoolingParameter_default_instance_; constexpr ProposalParameter::ProposalParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : ratio_() , scale_() , feat_stride_(16u) , base_size_(16u) , min_size_(16u) , pre_nms_topn_(6000u) , post_nms_topn_(300u) , nms_thresh_(0.7f){} struct ProposalParameterDefaultTypeInternal { constexpr ProposalParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ProposalParameterDefaultTypeInternal() {} union { ProposalParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ProposalParameterDefaultTypeInternal _ProposalParameter_default_instance_; constexpr PSROIPoolingParameter::PSROIPoolingParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : spatial_scale_(0) , output_dim_(0) , group_size_(0){} struct PSROIPoolingParameterDefaultTypeInternal { constexpr PSROIPoolingParameterDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~PSROIPoolingParameterDefaultTypeInternal() {} union { PSROIPoolingParameter _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PSROIPoolingParameterDefaultTypeInternal _PSROIPoolingParameter_default_instance_; } // namespace opencv_caffe static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_opencv_2dcaffe_2eproto[71]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_opencv_2dcaffe_2eproto[27]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_opencv_2dcaffe_2eproto = nullptr; const uint32_t TableStruct_opencv_2dcaffe_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobShape, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobShape, dim_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, shape_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, data_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, diff_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, double_data_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, double_diff_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, raw_data_type_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, raw_data_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, num_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, channels_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, height_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProto, width_), 1, ~0u, ~0u, ~0u, ~0u, 6, 0, 2, 3, 4, 5, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProtoVector, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::BlobProtoVector, blobs_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::PermuteParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::PermuteParameter, order_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, across_spatial_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, scale_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, channel_shared_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, eps_), 1, 0, 2, 3, PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, min_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, max_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, aspect_ratio_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, flip_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, clip_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, variance_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, img_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, img_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, img_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, step_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, step_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, step_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, offset_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, offset_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, offset_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, width_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, height_), ~0u, ~0u, ~0u, 6, 7, ~0u, 0, 1, 2, 3, 4, 5, 8, ~0u, ~0u, ~0u, ~0u, PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, num_classes_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, share_location_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, background_label_id_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, nms_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, save_output_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, code_type_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, variance_encoded_in_target_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, keep_top_k_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, confidence_threshold_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, normalized_bbox_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, clip_), 2, 9, 3, 0, 1, 8, 5, 7, 4, 10, 6, PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, channels_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, height_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, width_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, data_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, label_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, float_data_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::Datum, encoded_), 1, 2, 3, 0, 4, ~0u, 5, PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, type_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, value_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, min_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, max_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, mean_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, std_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, sparse_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FillerParameter, variance_norm_), 0, 1, 2, 6, 3, 7, 5, 4, PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, name_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, input_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, input_shape_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, input_dim_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, force_backward_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, state_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, debug_info_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, layer_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetParameter, layers_), 0, ~0u, ~0u, ~0u, 2, 1, 3, ~0u, ~0u, PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, net_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, net_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, train_net_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_net_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, train_net_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_net_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, train_state_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_state_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_iter_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_interval_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_compute_loss_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_initialization_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, base_lr_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, display_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, average_loss_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, max_iter_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, iter_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, lr_policy_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, gamma_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, power_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, momentum_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, weight_decay_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, regularization_type_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, stepsize_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, stepvalue_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, clip_gradients_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_prefix_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_diff_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_format_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, solver_mode_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, device_id_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, random_seed_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, type_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, delta_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, momentum2_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, rms_decay_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, debug_info_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_after_train_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverParameter, solver_type_), 3, 7, 0, ~0u, 6, ~0u, 8, ~0u, ~0u, 9, 20, 27, 10, 11, 30, 12, 32, 1, 13, 14, 15, 16, 4, 17, ~0u, 31, 18, 2, 21, 33, 26, 19, 25, 5, 29, 24, 34, 22, 28, 23, PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, iter_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, learned_net_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, history_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SolverState, current_step_), 1, 0, ~0u, 2, PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, phase_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, level_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetState, stage_), 1, 0, ~0u, PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, phase_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, min_level_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, max_level_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, stage_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NetStateRule, not_stage_), 0, 1, 2, ~0u, ~0u, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, name_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, share_mode_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, lr_mult_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParamSpec, decay_mult_), 0, 1, 2, 3, PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, name_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, type_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, bottom_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, top_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, phase_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, loss_weight_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, blobs_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, propagate_down_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, include_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, exclude_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, transform_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, loss_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, accuracy_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, argmax_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, batch_norm_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, bias_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, concat_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, contrastive_loss_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, convolution_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, crop_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, detection_output_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, dropout_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, dummy_data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, eltwise_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, elu_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, embed_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, exp_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, flatten_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, hdf5_data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, hdf5_output_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, hinge_loss_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, image_data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, infogain_loss_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, inner_product_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, input_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, log_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, lrn_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, memory_data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, mvn_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, norm_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, permute_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, parameter_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, pooling_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, power_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, prelu_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, prior_box_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, proposal_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, psroi_pooling_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, python_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, recurrent_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, reduction_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, relu_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, reshape_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, roi_pooling_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, scale_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, sigmoid_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, softmax_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, spp_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, slice_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, tanh_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, threshold_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, tile_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LayerParameter, window_data_param_), 0, 1, ~0u, ~0u, 56, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, 2, 3, 4, 5, 41, 43, 6, 7, 8, 46, 9, 49, 10, 11, 12, 42, 39, 13, 37, 14, 15, 16, 17, 18, 19, 45, 36, 20, 21, 22, 51, 50, 47, 23, 24, 33, 52, 53, 54, 32, 48, 38, 25, 35, 55, 44, 26, 27, 34, 28, 29, 30, 40, 31, PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, mirror_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, crop_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, mean_file_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, mean_value_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, force_color_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TransformationParameter, force_gray_), 5, 2, 1, 0, ~0u, 3, 4, PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, ignore_label_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, normalization_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LossParameter, normalize_), 0, 2, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, top_k_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, ignore_label_), 1, 2, 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, out_max_val_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, top_k_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, axis_), 0, 2, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConcatParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConcatParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConcatParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConcatParameter, concat_dim_), 1, 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, use_global_stats_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, moving_average_fraction_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, eps_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, scale_bias_), 0, 2, 3, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, num_axes_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::BiasParameter, filler_), 1, 2, 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, margin_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, legacy_version_), 1, 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, num_output_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, bias_term_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, pad_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, kernel_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, stride_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, dilation_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, pad_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, pad_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, kernel_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, kernel_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, stride_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, stride_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, group_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, weight_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, bias_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, engine_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, force_nd_im2col_), 2, 12, ~0u, ~0u, ~0u, ~0u, 3, 4, 5, 6, 7, 8, 13, 0, 1, 9, 11, 10, PROTOBUF_FIELD_OFFSET(::opencv_caffe::CropParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::CropParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::CropParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::CropParameter, offset_), 0, ~0u, PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, source_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, batch_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, rand_skip_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, backend_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, mean_file_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, crop_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, mirror_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, force_encoded_color_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DataParameter, prefetch_), 0, 2, 4, 7, 8, 1, 3, 5, 6, 9, PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, nms_threshold_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, top_k_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, eta_), 1, 0, 2, PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, output_directory_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, output_name_prefix_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, output_format_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, label_map_file_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, name_size_file_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, num_test_image_), 0, 1, 2, 3, 4, 5, PROTOBUF_FIELD_OFFSET(::opencv_caffe::DropoutParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DropoutParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::DropoutParameter, dropout_ratio_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DropoutParameter, scale_train_), 0, 1, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, data_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, shape_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, num_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, channels_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, height_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, width_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, operation_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, coeff_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, stable_prod_grad_), 0, ~0u, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ELUParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ELUParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ELUParameter, alpha_), 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, num_output_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, input_dim_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, bias_term_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, weight_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::EmbedParameter, bias_filler_), 2, 3, 4, 0, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, base_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ExpParameter, shift_), 1, 2, 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::FlattenParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FlattenParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::FlattenParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::FlattenParameter, end_axis_), 0, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, source_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, batch_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, shuffle_), 0, 1, 2, PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5OutputParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5OutputParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::HDF5OutputParameter, file_name_), 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::HingeLossParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::HingeLossParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::HingeLossParameter, norm_), 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, source_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, batch_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, rand_skip_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, shuffle_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, new_height_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, new_width_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, is_color_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, mean_file_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, crop_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, mirror_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, root_folder_), 0, 11, 4, 5, 7, 8, 9, 10, 1, 3, 6, 2, PROTOBUF_FIELD_OFFSET(::opencv_caffe::InfogainLossParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::InfogainLossParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::InfogainLossParameter, source_), 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, num_output_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, bias_term_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, weight_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, bias_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, transpose_), 2, 4, 0, 1, 5, 3, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::InputParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::InputParameter, shape_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, base_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LogParameter, shift_), 1, 2, 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, local_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, alpha_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, beta_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, norm_region_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, k_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::LRNParameter, engine_), 2, 3, 4, 0, 5, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, batch_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, channels_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, height_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, width_), 0, 1, 2, 3, PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, normalize_variance_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, across_channels_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::MVNParameter, eps_), 1, 0, 2, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParameterParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParameterParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ParameterParameter, shape_), 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pool_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pad_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pad_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pad_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, kernel_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, kernel_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, kernel_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, stride_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, stride_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, stride_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, engine_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, global_pooling_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PoolingParameter, ceil_mode_), 0, 2, 7, 8, 1, 3, 4, 11, 5, 6, 9, 10, 12, PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, power_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PowerParameter, shift_), 1, 2, 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, module_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, layer_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, param_str_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PythonParameter, share_in_parallel_), 0, 1, 2, 3, PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, num_output_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, weight_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, bias_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, debug_info_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, expose_hidden_), 2, 0, 1, 3, 4, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, operation_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReductionParameter, coeff_), 1, 0, 2, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReLUParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReLUParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReLUParameter, negative_slope_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReLUParameter, engine_), 0, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, shape_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, num_axes_), 0, 1, 2, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, num_axes_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, bias_term_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ScaleParameter, bias_filler_), 3, 4, 0, 2, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::SigmoidParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SigmoidParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::SigmoidParameter, engine_), 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, slice_point_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SliceParameter, slice_dim_), 1, ~0u, 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, engine_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, axis_), 0, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::TanHParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TanHParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::TanHParameter, engine_), 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::TileParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TileParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::TileParameter, axis_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::TileParameter, tiles_), 1, 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ThresholdParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ThresholdParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ThresholdParameter, threshold_), 0, PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, source_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, mean_file_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, batch_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, crop_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, mirror_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, fg_threshold_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, bg_threshold_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, fg_fraction_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, context_pad_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, crop_mode_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, cache_images_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, root_folder_), 0, 9, 1, 4, 5, 6, 10, 11, 12, 8, 2, 7, 3, PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, pyramid_height_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, pool_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::SPPParameter, engine_), 0, 1, 2, PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, bottom_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, top_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, name_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, include_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, exclude_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, type_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, blobs_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, blob_share_mode_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, blobs_lr_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, weight_decay_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, loss_weight_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, accuracy_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, argmax_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, concat_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, contrastive_loss_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, convolution_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, dropout_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, dummy_data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, eltwise_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, exp_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, hdf5_data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, hdf5_output_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, hinge_loss_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, image_data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, infogain_loss_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, inner_product_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, lrn_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, memory_data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, mvn_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, pooling_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, power_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, relu_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, sigmoid_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, softmax_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, slice_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, tanh_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, threshold_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, window_data_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, transform_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, loss_param_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, layer_), ~0u, ~0u, 0, ~0u, ~0u, 32, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, 20, 16, 2, 29, 3, 4, 5, 19, 17, 30, 6, 7, 21, 8, 9, 10, 11, 15, 24, 12, 14, 22, 27, 28, 23, 26, 18, 13, 25, 31, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, name_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, type_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, num_output_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, biasterm_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, weight_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, bias_filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, pad_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, kernelsize_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, group_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, stride_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, pool_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, dropout_ratio_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, local_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, alpha_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, beta_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, k_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, source_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, meanfile_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, batchsize_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, cropsize_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, mirror_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, blobs_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, blobs_lr_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, weight_decay_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, rand_skip_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_fg_threshold_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_bg_threshold_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_fg_fraction_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_context_pad_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_crop_mode_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_num_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_channels_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_height_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_width_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, shuffle_images_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, concat_dim_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, hdf5_output_param_), 0, 1, 8, 23, 5, 6, 9, 10, 24, 25, 11, 26, 27, 28, 29, 31, 2, 30, 3, 12, 13, 15, ~0u, ~0u, ~0u, 17, 32, 33, 34, 18, 4, 19, 20, 21, 14, 16, 22, 7, PROTOBUF_FIELD_OFFSET(::opencv_caffe::PReLUParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PReLUParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::PReLUParameter, filler_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PReLUParameter, channel_shared_), 0, 1, PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, xmin_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, ymin_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, xmax_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, ymax_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, label_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, difficult_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, score_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, size_), 0, 1, 2, 3, 4, 5, 6, 7, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, pooled_h_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, pooled_w_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, spatial_scale_), 0, 1, 2, PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, feat_stride_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, base_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, min_size_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, ratio_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, pre_nms_topn_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, post_nms_topn_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::ProposalParameter, nms_thresh_), 0, 1, 2, ~0u, ~0u, 3, 4, 5, PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, _has_bits_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, spatial_scale_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, output_dim_), PROTOBUF_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, group_size_), 0, 1, 2, }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, -1, sizeof(::opencv_caffe::BlobShape)}, { 7, 24, -1, sizeof(::opencv_caffe::BlobProto)}, { 35, -1, -1, sizeof(::opencv_caffe::BlobProtoVector)}, { 42, -1, -1, sizeof(::opencv_caffe::PermuteParameter)}, { 49, 59, -1, sizeof(::opencv_caffe::NormalizeBBoxParameter)}, { 63, 86, -1, sizeof(::opencv_caffe::PriorBoxParameter)}, { 103, 120, -1, sizeof(::opencv_caffe::DetectionOutputParameter)}, { 131, 144, -1, sizeof(::opencv_caffe::Datum)}, { 151, 165, -1, sizeof(::opencv_caffe::FillerParameter)}, { 173, 188, -1, sizeof(::opencv_caffe::NetParameter)}, { 197, 243, -1, sizeof(::opencv_caffe::SolverParameter)}, { 283, 293, -1, sizeof(::opencv_caffe::SolverState)}, { 297, 306, -1, sizeof(::opencv_caffe::NetState)}, { 309, 320, -1, sizeof(::opencv_caffe::NetStateRule)}, { 325, 335, -1, sizeof(::opencv_caffe::ParamSpec)}, { 339, 410, -1, sizeof(::opencv_caffe::LayerParameter)}, { 475, 488, -1, sizeof(::opencv_caffe::TransformationParameter)}, { 495, 504, -1, sizeof(::opencv_caffe::LossParameter)}, { 507, 516, -1, sizeof(::opencv_caffe::AccuracyParameter)}, { 519, 528, -1, sizeof(::opencv_caffe::ArgMaxParameter)}, { 531, 539, -1, sizeof(::opencv_caffe::ConcatParameter)}, { 541, 551, -1, sizeof(::opencv_caffe::BatchNormParameter)}, { 555, 564, -1, sizeof(::opencv_caffe::BiasParameter)}, { 567, 575, -1, sizeof(::opencv_caffe::ContrastiveLossParameter)}, { 577, 601, -1, sizeof(::opencv_caffe::ConvolutionParameter)}, { 619, 627, -1, sizeof(::opencv_caffe::CropParameter)}, { 629, 645, -1, sizeof(::opencv_caffe::DataParameter)}, { 655, 664, -1, sizeof(::opencv_caffe::NonMaximumSuppressionParameter)}, { 667, 679, -1, sizeof(::opencv_caffe::SaveOutputParameter)}, { 685, 693, -1, sizeof(::opencv_caffe::DropoutParameter)}, { 695, -1, -1, sizeof(::opencv_caffe::DummyDataParameter)}, { 707, 716, -1, sizeof(::opencv_caffe::EltwiseParameter)}, { 719, 726, -1, sizeof(::opencv_caffe::ELUParameter)}, { 727, 738, -1, sizeof(::opencv_caffe::EmbedParameter)}, { 743, 752, -1, sizeof(::opencv_caffe::ExpParameter)}, { 755, 763, -1, sizeof(::opencv_caffe::FlattenParameter)}, { 765, 774, -1, sizeof(::opencv_caffe::HDF5DataParameter)}, { 777, 784, -1, sizeof(::opencv_caffe::HDF5OutputParameter)}, { 785, 792, -1, sizeof(::opencv_caffe::HingeLossParameter)}, { 793, 811, -1, sizeof(::opencv_caffe::ImageDataParameter)}, { 823, 830, -1, sizeof(::opencv_caffe::InfogainLossParameter)}, { 831, 843, -1, sizeof(::opencv_caffe::InnerProductParameter)}, { 849, -1, -1, sizeof(::opencv_caffe::InputParameter)}, { 856, 865, -1, sizeof(::opencv_caffe::LogParameter)}, { 868, 880, -1, sizeof(::opencv_caffe::LRNParameter)}, { 886, 896, -1, sizeof(::opencv_caffe::MemoryDataParameter)}, { 900, 909, -1, sizeof(::opencv_caffe::MVNParameter)}, { 912, 919, -1, sizeof(::opencv_caffe::ParameterParameter)}, { 920, 939, -1, sizeof(::opencv_caffe::PoolingParameter)}, { 952, 961, -1, sizeof(::opencv_caffe::PowerParameter)}, { 964, 974, -1, sizeof(::opencv_caffe::PythonParameter)}, { 978, 989, -1, sizeof(::opencv_caffe::RecurrentParameter)}, { 994, 1003, -1, sizeof(::opencv_caffe::ReductionParameter)}, { 1006, 1014, -1, sizeof(::opencv_caffe::ReLUParameter)}, { 1016, 1025, -1, sizeof(::opencv_caffe::ReshapeParameter)}, { 1028, 1039, -1, sizeof(::opencv_caffe::ScaleParameter)}, { 1044, 1051, -1, sizeof(::opencv_caffe::SigmoidParameter)}, { 1052, 1061, -1, sizeof(::opencv_caffe::SliceParameter)}, { 1064, 1072, -1, sizeof(::opencv_caffe::SoftmaxParameter)}, { 1074, 1081, -1, sizeof(::opencv_caffe::TanHParameter)}, { 1082, 1090, -1, sizeof(::opencv_caffe::TileParameter)}, { 1092, 1099, -1, sizeof(::opencv_caffe::ThresholdParameter)}, { 1100, 1119, -1, sizeof(::opencv_caffe::WindowDataParameter)}, { 1132, 1141, -1, sizeof(::opencv_caffe::SPPParameter)}, { 1144, 1193, -1, sizeof(::opencv_caffe::V1LayerParameter)}, { 1236, 1280, -1, sizeof(::opencv_caffe::V0LayerParameter)}, { 1318, 1326, -1, sizeof(::opencv_caffe::PReLUParameter)}, { 1328, 1342, -1, sizeof(::opencv_caffe::NormalizedBBox)}, { 1350, 1359, -1, sizeof(::opencv_caffe::ROIPoolingParameter)}, { 1362, 1376, -1, sizeof(::opencv_caffe::ProposalParameter)}, { 1384, 1393, -1, sizeof(::opencv_caffe::PSROIPoolingParameter)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { reinterpret_cast(&::opencv_caffe::_BlobShape_default_instance_), reinterpret_cast(&::opencv_caffe::_BlobProto_default_instance_), reinterpret_cast(&::opencv_caffe::_BlobProtoVector_default_instance_), reinterpret_cast(&::opencv_caffe::_PermuteParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_NormalizeBBoxParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_PriorBoxParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_DetectionOutputParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_Datum_default_instance_), reinterpret_cast(&::opencv_caffe::_FillerParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_NetParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_SolverParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_SolverState_default_instance_), reinterpret_cast(&::opencv_caffe::_NetState_default_instance_), reinterpret_cast(&::opencv_caffe::_NetStateRule_default_instance_), reinterpret_cast(&::opencv_caffe::_ParamSpec_default_instance_), reinterpret_cast(&::opencv_caffe::_LayerParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_TransformationParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_LossParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_AccuracyParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ArgMaxParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ConcatParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_BatchNormParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_BiasParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ContrastiveLossParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ConvolutionParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_CropParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_DataParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_NonMaximumSuppressionParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_SaveOutputParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_DropoutParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_DummyDataParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_EltwiseParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ELUParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_EmbedParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ExpParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_FlattenParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_HDF5DataParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_HDF5OutputParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_HingeLossParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ImageDataParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_InfogainLossParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_InnerProductParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_InputParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_LogParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_LRNParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_MemoryDataParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_MVNParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ParameterParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_PoolingParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_PowerParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_PythonParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_RecurrentParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ReductionParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ReLUParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ReshapeParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ScaleParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_SigmoidParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_SliceParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_SoftmaxParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_TanHParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_TileParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ThresholdParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_WindowDataParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_SPPParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_V1LayerParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_V0LayerParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_PReLUParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_NormalizedBBox_default_instance_), reinterpret_cast(&::opencv_caffe::_ROIPoolingParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_ProposalParameter_default_instance_), reinterpret_cast(&::opencv_caffe::_PSROIPoolingParameter_default_instance_), }; const char descriptor_table_protodef_opencv_2dcaffe_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\022opencv-caffe.proto\022\014opencv_caffe\"\034\n\tBl" "obShape\022\017\n\003dim\030\001 \003(\003B\002\020\001\"\224\002\n\tBlobProto\022&" "\n\005shape\030\007 \001(\0132\027.opencv_caffe.BlobShape\022\020" "\n\004data\030\005 \003(\002B\002\020\001\022\020\n\004diff\030\006 \003(\002B\002\020\001\022\027\n\013do" "uble_data\030\010 \003(\001B\002\020\001\022\027\n\013double_diff\030\t \003(\001" "B\002\020\001\022)\n\rraw_data_type\030\n \001(\0162\022.opencv_caf" "fe.Type\022\024\n\010raw_data\030\014 \001(\014B\002\020\000\022\016\n\003num\030\001 \001" "(\005:\0010\022\023\n\010channels\030\002 \001(\005:\0010\022\021\n\006height\030\003 \001" "(\005:\0010\022\020\n\005width\030\004 \001(\005:\0010\"9\n\017BlobProtoVect" "or\022&\n\005blobs\030\001 \003(\0132\027.opencv_caffe.BlobPro" "to\"!\n\020PermuteParameter\022\r\n\005order\030\001 \003(\r\"\235\001" "\n\026NormalizeBBoxParameter\022\034\n\016across_spati" "al\030\001 \001(\010:\004true\0223\n\014scale_filler\030\002 \001(\0132\035.o" "pencv_caffe.FillerParameter\022\034\n\016channel_s" "hared\030\003 \001(\010:\004true\022\022\n\003eps\030\004 \001(\002:\0051e-10\"\346\002" "\n\021PriorBoxParameter\022\020\n\010min_size\030\001 \003(\002\022\020\n" "\010max_size\030\002 \003(\002\022\024\n\014aspect_ratio\030\003 \003(\002\022\022\n" "\004flip\030\004 \001(\010:\004true\022\022\n\004clip\030\005 \001(\010:\004true\022\020\n" "\010variance\030\006 \003(\002\022\020\n\010img_size\030\007 \001(\r\022\r\n\005img" "_h\030\010 \001(\r\022\r\n\005img_w\030\t \001(\r\022\014\n\004step\030\n \001(\002\022\016\n" "\006step_h\030\013 \001(\002\022\016\n\006step_w\030\014 \001(\002\022\023\n\006offset\030" "\r \001(\002:\0030.5\022\020\n\010offset_h\030\016 \003(\002\022\020\n\010offset_w" "\030\017 \003(\002\022\r\n\005width\030\020 \003(\002\022\016\n\006height\030\021 \003(\002\"\'\n" "\010CodeType\022\n\n\006CORNER\020\001\022\017\n\013CENTER_SIZE\020\002\"\307" "\003\n\030DetectionOutputParameter\022\023\n\013num_class" "es\030\001 \001(\r\022\034\n\016share_location\030\002 \001(\010:\004true\022\036" "\n\023background_label_id\030\003 \001(\005:\0010\022\?\n\tnms_pa" "ram\030\004 \001(\0132,.opencv_caffe.NonMaximumSuppr" "essionParameter\022<\n\021save_output_param\030\005 \001" "(\0132!.opencv_caffe.SaveOutputParameter\022C\n" "\tcode_type\030\006 \001(\0162(.opencv_caffe.PriorBox" "Parameter.CodeType:\006CORNER\022)\n\032variance_e" "ncoded_in_target\030\010 \001(\010:\005false\022\026\n\nkeep_to" "p_k\030\007 \001(\005:\002-1\022\034\n\024confidence_threshold\030\t " "\001(\002\022\035\n\017normalized_bbox\030\n \001(\010:\004true\022\024\n\004cl" "ip\030\350\007 \001(\010:\005false\"\201\001\n\005Datum\022\020\n\010channels\030\001" " \001(\005\022\016\n\006height\030\002 \001(\005\022\r\n\005width\030\003 \001(\005\022\014\n\004d" "ata\030\004 \001(\014\022\r\n\005label\030\005 \001(\005\022\022\n\nfloat_data\030\006" " \003(\002\022\026\n\007encoded\030\007 \001(\010:\005false\"\221\002\n\017FillerP" "arameter\022\026\n\004type\030\001 \001(\t:\010constant\022\020\n\005valu" "e\030\002 \001(\002:\0010\022\016\n\003min\030\003 \001(\002:\0010\022\016\n\003max\030\004 \001(\002:" "\0011\022\017\n\004mean\030\005 \001(\002:\0010\022\016\n\003std\030\006 \001(\002:\0011\022\022\n\006s" "parse\030\007 \001(\005:\002-1\022I\n\rvariance_norm\030\010 \001(\0162*" ".opencv_caffe.FillerParameter.VarianceNo" "rm:\006FAN_IN\"4\n\014VarianceNorm\022\n\n\006FAN_IN\020\000\022\013" "\n\007FAN_OUT\020\001\022\013\n\007AVERAGE\020\002\"\252\002\n\014NetParamete" "r\022\014\n\004name\030\001 \001(\t\022\r\n\005input\030\003 \003(\t\022,\n\013input_" "shape\030\010 \003(\0132\027.opencv_caffe.BlobShape\022\021\n\t" "input_dim\030\004 \003(\005\022\035\n\016force_backward\030\005 \001(\010:" "\005false\022%\n\005state\030\006 \001(\0132\026.opencv_caffe.Net" "State\022\031\n\ndebug_info\030\007 \001(\010:\005false\022+\n\005laye" "r\030d \003(\0132\034.opencv_caffe.LayerParameter\022.\n" "\006layers\030\002 \003(\0132\036.opencv_caffe.V1LayerPara" "meter\"\332\n\n\017SolverParameter\022\013\n\003net\030\030 \001(\t\022-" "\n\tnet_param\030\031 \001(\0132\032.opencv_caffe.NetPara" "meter\022\021\n\ttrain_net\030\001 \001(\t\022\020\n\010test_net\030\002 \003" "(\t\0223\n\017train_net_param\030\025 \001(\0132\032.opencv_caf" "fe.NetParameter\0222\n\016test_net_param\030\026 \003(\0132" "\032.opencv_caffe.NetParameter\022+\n\013train_sta" "te\030\032 \001(\0132\026.opencv_caffe.NetState\022*\n\ntest" "_state\030\033 \003(\0132\026.opencv_caffe.NetState\022\021\n\t" "test_iter\030\003 \003(\005\022\030\n\rtest_interval\030\004 \001(\005:\001" "0\022 \n\021test_compute_loss\030\023 \001(\010:\005false\022!\n\023t" "est_initialization\030 \001(\010:\004true\022\017\n\007base_l" "r\030\005 \001(\002\022\017\n\007display\030\006 \001(\005\022\027\n\014average_loss" "\030! \001(\005:\0011\022\020\n\010max_iter\030\007 \001(\005\022\024\n\titer_size" "\030$ \001(\005:\0011\022\021\n\tlr_policy\030\010 \001(\t\022\r\n\005gamma\030\t " "\001(\002\022\r\n\005power\030\n \001(\002\022\020\n\010momentum\030\013 \001(\002\022\024\n\014" "weight_decay\030\014 \001(\002\022\037\n\023regularization_typ" "e\030\035 \001(\t:\002L2\022\020\n\010stepsize\030\r \001(\005\022\021\n\tstepval" "ue\030\" \003(\005\022\032\n\016clip_gradients\030# \001(\002:\002-1\022\023\n\010" "snapshot\030\016 \001(\005:\0010\022\027\n\017snapshot_prefix\030\017 \001" "(\t\022\034\n\rsnapshot_diff\030\020 \001(\010:\005false\022R\n\017snap" "shot_format\030% \001(\0162,.opencv_caffe.SolverP" "arameter.SnapshotFormat:\013BINARYPROTO\022B\n\013" "solver_mode\030\021 \001(\0162(.opencv_caffe.SolverP" "arameter.SolverMode:\003GPU\022\024\n\tdevice_id\030\022 " "\001(\005:\0010\022\027\n\013random_seed\030\024 \001(\003:\002-1\022\021\n\004type\030" "( \001(\t:\003SGD\022\024\n\005delta\030\037 \001(\002:\0051e-08\022\030\n\tmome" "ntum2\030\' \001(\002:\0050.999\022\027\n\trms_decay\030& \001(\002:\0040" ".99\022\031\n\ndebug_info\030\027 \001(\010:\005false\022\"\n\024snapsh" "ot_after_train\030\034 \001(\010:\004true\022B\n\013solver_typ" "e\030\036 \001(\0162(.opencv_caffe.SolverParameter.S" "olverType:\003SGD\"+\n\016SnapshotFormat\022\010\n\004HDF5" "\020\000\022\017\n\013BINARYPROTO\020\001\"\036\n\nSolverMode\022\007\n\003CPU" "\020\000\022\007\n\003GPU\020\001\"U\n\nSolverType\022\007\n\003SGD\020\000\022\014\n\010NE" "STEROV\020\001\022\013\n\007ADAGRAD\020\002\022\013\n\007RMSPROP\020\003\022\014\n\010AD" "ADELTA\020\004\022\010\n\004ADAM\020\005\"s\n\013SolverState\022\014\n\004ite" "r\030\001 \001(\005\022\023\n\013learned_net\030\002 \001(\t\022(\n\007history\030" "\003 \003(\0132\027.opencv_caffe.BlobProto\022\027\n\014curren" "t_step\030\004 \001(\005:\0010\"U\n\010NetState\022(\n\005phase\030\001 \001" "(\0162\023.opencv_caffe.Phase:\004TEST\022\020\n\005level\030\002" " \001(\005:\0010\022\r\n\005stage\030\003 \003(\t\"z\n\014NetStateRule\022\"" "\n\005phase\030\001 \001(\0162\023.opencv_caffe.Phase\022\021\n\tmi" "n_level\030\002 \001(\005\022\021\n\tmax_level\030\003 \001(\005\022\r\n\005stag" "e\030\004 \003(\t\022\021\n\tnot_stage\030\005 \003(\t\"\252\001\n\tParamSpec" "\022\014\n\004name\030\001 \001(\t\0228\n\nshare_mode\030\002 \001(\0162$.ope" "ncv_caffe.ParamSpec.DimCheckMode\022\022\n\007lr_m" "ult\030\003 \001(\002:\0011\022\025\n\ndecay_mult\030\004 \001(\002:\0011\"*\n\014D" "imCheckMode\022\n\n\006STRICT\020\000\022\016\n\nPERMISSIVE\020\001\"" "\243\032\n\016LayerParameter\022\014\n\004name\030\001 \001(\t\022\014\n\004type" "\030\002 \001(\t\022\016\n\006bottom\030\003 \003(\t\022\013\n\003top\030\004 \003(\t\022\"\n\005p" "hase\030\n \001(\0162\023.opencv_caffe.Phase\022\023\n\013loss_" "weight\030\005 \003(\002\022&\n\005param\030\006 \003(\0132\027.opencv_caf" "fe.ParamSpec\022&\n\005blobs\030\007 \003(\0132\027.opencv_caf" "fe.BlobProto\022\026\n\016propagate_down\030\013 \003(\010\022+\n\007" "include\030\010 \003(\0132\032.opencv_caffe.NetStateRul" "e\022+\n\007exclude\030\t \003(\0132\032.opencv_caffe.NetSta" "teRule\022>\n\017transform_param\030d \001(\0132%.opencv" "_caffe.TransformationParameter\022/\n\nloss_p" "aram\030e \001(\0132\033.opencv_caffe.LossParameter\022" "7\n\016accuracy_param\030f \001(\0132\037.opencv_caffe.A" "ccuracyParameter\0223\n\014argmax_param\030g \001(\0132\035" ".opencv_caffe.ArgMaxParameter\022;\n\020batch_n" "orm_param\030\213\001 \001(\0132 .opencv_caffe.BatchNor" "mParameter\0220\n\nbias_param\030\215\001 \001(\0132\033.opencv" "_caffe.BiasParameter\0223\n\014concat_param\030h \001" "(\0132\035.opencv_caffe.ConcatParameter\022F\n\026con" "trastive_loss_param\030i \001(\0132&.opencv_caffe" ".ContrastiveLossParameter\022=\n\021convolution" "_param\030j \001(\0132\".opencv_caffe.ConvolutionP" "arameter\0220\n\ncrop_param\030\220\001 \001(\0132\033.opencv_c" "affe.CropParameter\022/\n\ndata_param\030k \001(\0132\033" ".opencv_caffe.DataParameter\022G\n\026detection" "_output_param\030\223\001 \001(\0132&.opencv_caffe.Dete" "ctionOutputParameter\0225\n\rdropout_param\030l " "\001(\0132\036.opencv_caffe.DropoutParameter\022:\n\020d" "ummy_data_param\030m \001(\0132 .opencv_caffe.Dum" "myDataParameter\0225\n\reltwise_param\030n \001(\0132\036" ".opencv_caffe.EltwiseParameter\022.\n\telu_pa" "ram\030\214\001 \001(\0132\032.opencv_caffe.ELUParameter\0222" "\n\013embed_param\030\211\001 \001(\0132\034.opencv_caffe.Embe" "dParameter\022-\n\texp_param\030o \001(\0132\032.opencv_c" "affe.ExpParameter\0226\n\rflatten_param\030\207\001 \001(" "\0132\036.opencv_caffe.FlattenParameter\0228\n\017hdf" "5_data_param\030p \001(\0132\037.opencv_caffe.HDF5Da" "taParameter\022<\n\021hdf5_output_param\030q \001(\0132!" ".opencv_caffe.HDF5OutputParameter\022:\n\020hin" "ge_loss_param\030r \001(\0132 .opencv_caffe.Hinge" "LossParameter\022:\n\020image_data_param\030s \001(\0132" " .opencv_caffe.ImageDataParameter\022@\n\023inf" "ogain_loss_param\030t \001(\0132#.opencv_caffe.In" "fogainLossParameter\022@\n\023inner_product_par" "am\030u \001(\0132#.opencv_caffe.InnerProductPara" "meter\0222\n\013input_param\030\217\001 \001(\0132\034.opencv_caf" "fe.InputParameter\022.\n\tlog_param\030\206\001 \001(\0132\032." "opencv_caffe.LogParameter\022-\n\tlrn_param\030v" " \001(\0132\032.opencv_caffe.LRNParameter\022<\n\021memo" "ry_data_param\030w \001(\0132!.opencv_caffe.Memor" "yDataParameter\022-\n\tmvn_param\030x \001(\0132\032.open" "cv_caffe.MVNParameter\0229\n\nnorm_param\030\225\001 \001" "(\0132$.opencv_caffe.NormalizeBBoxParameter" "\0226\n\rpermute_param\030\224\001 \001(\0132\036.opencv_caffe." "PermuteParameter\022:\n\017parameter_param\030\221\001 \001" "(\0132 .opencv_caffe.ParameterParameter\0225\n\r" "pooling_param\030y \001(\0132\036.opencv_caffe.Pooli" "ngParameter\0221\n\013power_param\030z \001(\0132\034.openc" "v_caffe.PowerParameter\0222\n\013prelu_param\030\203\001" " \001(\0132\034.opencv_caffe.PReLUParameter\0229\n\017pr" "ior_box_param\030\226\001 \001(\0132\037.opencv_caffe.Prio" "rBoxParameter\0228\n\016proposal_param\030\311\001 \001(\0132\037" ".opencv_caffe.ProposalParameter\022A\n\023psroi" "_pooling_param\030\222N \001(\0132#.opencv_caffe.PSR" "OIPoolingParameter\0224\n\014python_param\030\202\001 \001(" "\0132\035.opencv_caffe.PythonParameter\022:\n\017recu" "rrent_param\030\222\001 \001(\0132 .opencv_caffe.Recurr" "entParameter\022:\n\017reduction_param\030\210\001 \001(\0132 " ".opencv_caffe.ReductionParameter\022/\n\nrelu" "_param\030{ \001(\0132\033.opencv_caffe.ReLUParamete" "r\0226\n\rreshape_param\030\205\001 \001(\0132\036.opencv_caffe" ".ReshapeParameter\022\?\n\021roi_pooling_param\030\327" "\307\370\003 \001(\0132!.opencv_caffe.ROIPoolingParamet" "er\0222\n\013scale_param\030\216\001 \001(\0132\034.opencv_caffe." "ScaleParameter\0225\n\rsigmoid_param\030| \001(\0132\036." "opencv_caffe.SigmoidParameter\0225\n\rsoftmax" "_param\030} \001(\0132\036.opencv_caffe.SoftmaxParam" "eter\022.\n\tspp_param\030\204\001 \001(\0132\032.opencv_caffe." "SPPParameter\0221\n\013slice_param\030~ \001(\0132\034.open" "cv_caffe.SliceParameter\022/\n\ntanh_param\030\177 " "\001(\0132\033.opencv_caffe.TanHParameter\022:\n\017thre" "shold_param\030\200\001 \001(\0132 .opencv_caffe.Thresh" "oldParameter\0220\n\ntile_param\030\212\001 \001(\0132\033.open" "cv_caffe.TileParameter\022=\n\021window_data_pa" "ram\030\201\001 \001(\0132!.opencv_caffe.WindowDataPara" "meter\"\266\001\n\027TransformationParameter\022\020\n\005sca" "le\030\001 \001(\002:\0011\022\025\n\006mirror\030\002 \001(\010:\005false\022\024\n\tcr" "op_size\030\003 \001(\r:\0010\022\021\n\tmean_file\030\004 \001(\t\022\022\n\nm" "ean_value\030\005 \003(\002\022\032\n\013force_color\030\006 \001(\010:\005fa" "lse\022\031\n\nforce_gray\030\007 \001(\010:\005false\"\311\001\n\rLossP" "arameter\022\024\n\014ignore_label\030\001 \001(\005\022K\n\rnormal" "ization\030\003 \001(\0162-.opencv_caffe.LossParamet" "er.NormalizationMode:\005VALID\022\021\n\tnormalize" "\030\002 \001(\010\"B\n\021NormalizationMode\022\010\n\004FULL\020\000\022\t\n" "\005VALID\020\001\022\016\n\nBATCH_SIZE\020\002\022\010\n\004NONE\020\003\"L\n\021Ac" "curacyParameter\022\020\n\005top_k\030\001 \001(\r:\0011\022\017\n\004axi" "s\030\002 \001(\005:\0011\022\024\n\014ignore_label\030\003 \001(\005\"M\n\017ArgM" "axParameter\022\032\n\013out_max_val\030\001 \001(\010:\005false\022" "\020\n\005top_k\030\002 \001(\r:\0011\022\014\n\004axis\030\003 \001(\005\"9\n\017Conca" "tParameter\022\017\n\004axis\030\002 \001(\005:\0011\022\025\n\nconcat_di" "m\030\001 \001(\r:\0011\"\205\001\n\022BatchNormParameter\022\030\n\020use" "_global_stats\030\001 \001(\010\022&\n\027moving_average_fr" "action\030\002 \001(\002:\0050.999\022\022\n\003eps\030\003 \001(\002:\0051e-05\022" "\031\n\nscale_bias\030\007 \001(\010:\005false\"d\n\rBiasParame" "ter\022\017\n\004axis\030\001 \001(\005:\0011\022\023\n\010num_axes\030\002 \001(\005:\001" "1\022-\n\006filler\030\003 \001(\0132\035.opencv_caffe.FillerP" "arameter\"L\n\030ContrastiveLossParameter\022\021\n\006" "margin\030\001 \001(\002:\0011\022\035\n\016legacy_version\030\002 \001(\010:" "\005false\"\221\004\n\024ConvolutionParameter\022\022\n\nnum_o" "utput\030\001 \001(\r\022\027\n\tbias_term\030\002 \001(\010:\004true\022\013\n\003" "pad\030\003 \003(\r\022\023\n\013kernel_size\030\004 \003(\r\022\016\n\006stride" "\030\006 \003(\r\022\020\n\010dilation\030\022 \003(\r\022\020\n\005pad_h\030\t \001(\r:" "\0010\022\020\n\005pad_w\030\n \001(\r:\0010\022\020\n\010kernel_h\030\013 \001(\r\022\020" "\n\010kernel_w\030\014 \001(\r\022\020\n\010stride_h\030\r \001(\r\022\020\n\010st" "ride_w\030\016 \001(\r\022\020\n\005group\030\005 \001(\r:\0011\0224\n\rweight" "_filler\030\007 \001(\0132\035.opencv_caffe.FillerParam" "eter\0222\n\013bias_filler\030\010 \001(\0132\035.opencv_caffe" ".FillerParameter\022B\n\006engine\030\017 \001(\0162).openc" "v_caffe.ConvolutionParameter.Engine:\007DEF" "AULT\022\017\n\004axis\030\020 \001(\005:\0011\022\036\n\017force_nd_im2col" "\030\021 \001(\010:\005false\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005" "CAFFE\020\001\022\t\n\005CUDNN\020\002\"0\n\rCropParameter\022\017\n\004a" "xis\030\001 \001(\005:\0012\022\016\n\006offset\030\002 \003(\r\"\253\002\n\rDataPar" "ameter\022\016\n\006source\030\001 \001(\t\022\022\n\nbatch_size\030\004 \001" "(\r\022\024\n\trand_skip\030\007 \001(\r:\0010\0228\n\007backend\030\010 \001(" "\0162\036.opencv_caffe.DataParameter.DB:\007LEVEL" "DB\022\020\n\005scale\030\002 \001(\002:\0011\022\021\n\tmean_file\030\003 \001(\t\022" "\024\n\tcrop_size\030\005 \001(\r:\0010\022\025\n\006mirror\030\006 \001(\010:\005f" "alse\022\"\n\023force_encoded_color\030\t \001(\010:\005false" "\022\023\n\010prefetch\030\n \001(\r:\0014\"\033\n\002DB\022\013\n\007LEVELDB\020\000" "\022\010\n\004LMDB\020\001\"[\n\036NonMaximumSuppressionParam" "eter\022\032\n\rnms_threshold\030\001 \001(\002:\0030.3\022\r\n\005top_" "k\030\002 \001(\005\022\016\n\003eta\030\003 \001(\002:\0011\"\252\001\n\023SaveOutputPa" "rameter\022\030\n\020output_directory\030\001 \001(\t\022\032\n\022out" "put_name_prefix\030\002 \001(\t\022\025\n\routput_format\030\003" " \001(\t\022\026\n\016label_map_file\030\004 \001(\t\022\026\n\016name_siz" "e_file\030\005 \001(\t\022\026\n\016num_test_image\030\006 \001(\r\"I\n\020" "DropoutParameter\022\032\n\rdropout_ratio\030\001 \001(\002:" "\0030.5\022\031\n\013scale_train\030\002 \001(\010:\004true\"\256\001\n\022Dumm" "yDataParameter\0222\n\013data_filler\030\001 \003(\0132\035.op" "encv_caffe.FillerParameter\022&\n\005shape\030\006 \003(" "\0132\027.opencv_caffe.BlobShape\022\013\n\003num\030\002 \003(\r\022" "\020\n\010channels\030\003 \003(\r\022\016\n\006height\030\004 \003(\r\022\r\n\005wid" "th\030\005 \003(\r\"\254\001\n\020EltwiseParameter\022@\n\toperati" "on\030\001 \001(\0162(.opencv_caffe.EltwiseParameter" ".EltwiseOp:\003SUM\022\r\n\005coeff\030\002 \003(\002\022\036\n\020stable" "_prod_grad\030\003 \001(\010:\004true\"\'\n\tEltwiseOp\022\010\n\004P" "ROD\020\000\022\007\n\003SUM\020\001\022\007\n\003MAX\020\002\" \n\014ELUParameter\022" "\020\n\005alpha\030\001 \001(\002:\0011\"\272\001\n\016EmbedParameter\022\022\n\n" "num_output\030\001 \001(\r\022\021\n\tinput_dim\030\002 \001(\r\022\027\n\tb" "ias_term\030\003 \001(\010:\004true\0224\n\rweight_filler\030\004 " "\001(\0132\035.opencv_caffe.FillerParameter\0222\n\013bi" "as_filler\030\005 \001(\0132\035.opencv_caffe.FillerPar" "ameter\"D\n\014ExpParameter\022\020\n\004base\030\001 \001(\002:\002-1" "\022\020\n\005scale\030\002 \001(\002:\0011\022\020\n\005shift\030\003 \001(\002:\0010\"9\n\020" "FlattenParameter\022\017\n\004axis\030\001 \001(\005:\0011\022\024\n\010end" "_axis\030\002 \001(\005:\002-1\"O\n\021HDF5DataParameter\022\016\n\006" "source\030\001 \001(\t\022\022\n\nbatch_size\030\002 \001(\r\022\026\n\007shuf" "fle\030\003 \001(\010:\005false\"(\n\023HDF5OutputParameter\022" "\021\n\tfile_name\030\001 \001(\t\"e\n\022HingeLossParameter" "\0227\n\004norm\030\001 \001(\0162%.opencv_caffe.HingeLossP" "arameter.Norm:\002L1\"\026\n\004Norm\022\006\n\002L1\020\001\022\006\n\002L2\020" "\002\"\227\002\n\022ImageDataParameter\022\016\n\006source\030\001 \001(\t" "\022\025\n\nbatch_size\030\004 \001(\r:\0011\022\024\n\trand_skip\030\007 \001" "(\r:\0010\022\026\n\007shuffle\030\010 \001(\010:\005false\022\025\n\nnew_hei" "ght\030\t \001(\r:\0010\022\024\n\tnew_width\030\n \001(\r:\0010\022\026\n\010is" "_color\030\013 \001(\010:\004true\022\020\n\005scale\030\002 \001(\002:\0011\022\021\n\t" "mean_file\030\003 \001(\t\022\024\n\tcrop_size\030\005 \001(\r:\0010\022\025\n" "\006mirror\030\006 \001(\010:\005false\022\025\n\013root_folder\030\014 \001(" "\t:\000\"\'\n\025InfogainLossParameter\022\016\n\006source\030\001" " \001(\t\"\331\001\n\025InnerProductParameter\022\022\n\nnum_ou" "tput\030\001 \001(\r\022\027\n\tbias_term\030\002 \001(\010:\004true\0224\n\rw" "eight_filler\030\003 \001(\0132\035.opencv_caffe.Filler" "Parameter\0222\n\013bias_filler\030\004 \001(\0132\035.opencv_" "caffe.FillerParameter\022\017\n\004axis\030\005 \001(\005:\0011\022\030" "\n\ttranspose\030\006 \001(\010:\005false\"8\n\016InputParamet" "er\022&\n\005shape\030\001 \003(\0132\027.opencv_caffe.BlobSha" "pe\"D\n\014LogParameter\022\020\n\004base\030\001 \001(\002:\002-1\022\020\n\005" "scale\030\002 \001(\002:\0011\022\020\n\005shift\030\003 \001(\002:\0010\"\306\002\n\014LRN" "Parameter\022\025\n\nlocal_size\030\001 \001(\r:\0015\022\020\n\005alph" "a\030\002 \001(\002:\0011\022\022\n\004beta\030\003 \001(\002:\0040.75\022K\n\013norm_r" "egion\030\004 \001(\0162%.opencv_caffe.LRNParameter." "NormRegion:\017ACROSS_CHANNELS\022\014\n\001k\030\005 \001(\002:\001" "1\022:\n\006engine\030\006 \001(\0162!.opencv_caffe.LRNPara" "meter.Engine:\007DEFAULT\"5\n\nNormRegion\022\023\n\017A" "CROSS_CHANNELS\020\000\022\022\n\016WITHIN_CHANNEL\020\001\"+\n\006" "Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020" "\002\"Z\n\023MemoryDataParameter\022\022\n\nbatch_size\030\001" " \001(\r\022\020\n\010channels\030\002 \001(\r\022\016\n\006height\030\003 \001(\r\022\r" "\n\005width\030\004 \001(\r\"d\n\014MVNParameter\022 \n\022normali" "ze_variance\030\001 \001(\010:\004true\022\036\n\017across_channe" "ls\030\002 \001(\010:\005false\022\022\n\003eps\030\003 \001(\002:\0051e-09\"<\n\022P" "arameterParameter\022&\n\005shape\030\001 \001(\0132\027.openc" "v_caffe.BlobShape\"\311\003\n\020PoolingParameter\022<" "\n\004pool\030\001 \001(\0162).opencv_caffe.PoolingParam" "eter.PoolMethod:\003MAX\022\016\n\003pad\030\004 \001(\r:\0010\022\020\n\005" "pad_h\030\t \001(\r:\0010\022\020\n\005pad_w\030\n \001(\r:\0010\022\023\n\013kern" "el_size\030\002 \001(\r\022\020\n\010kernel_h\030\005 \001(\r\022\020\n\010kerne" "l_w\030\006 \001(\r\022\021\n\006stride\030\003 \001(\r:\0011\022\020\n\010stride_h" "\030\007 \001(\r\022\020\n\010stride_w\030\010 \001(\r\022>\n\006engine\030\013 \001(\016" "2%.opencv_caffe.PoolingParameter.Engine:" "\007DEFAULT\022\035\n\016global_pooling\030\014 \001(\010:\005false\022" "\027\n\tceil_mode\030\r \001(\010:\004true\".\n\nPoolMethod\022\007" "\n\003MAX\020\000\022\007\n\003AVE\020\001\022\016\n\nSTOCHASTIC\020\002\"+\n\006Engi" "ne\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"F\n" "\016PowerParameter\022\020\n\005power\030\001 \001(\002:\0011\022\020\n\005sca" "le\030\002 \001(\002:\0011\022\020\n\005shift\030\003 \001(\002:\0010\"g\n\017PythonP" "arameter\022\016\n\006module\030\001 \001(\t\022\r\n\005layer\030\002 \001(\t\022" "\023\n\tparam_str\030\003 \001(\t:\000\022 \n\021share_in_paralle" "l\030\004 \001(\010:\005false\"\316\001\n\022RecurrentParameter\022\025\n" "\nnum_output\030\001 \001(\r:\0010\0224\n\rweight_filler\030\002 " "\001(\0132\035.opencv_caffe.FillerParameter\0222\n\013bi" "as_filler\030\003 \001(\0132\035.opencv_caffe.FillerPar" "ameter\022\031\n\ndebug_info\030\004 \001(\010:\005false\022\034\n\rexp" "ose_hidden\030\005 \001(\010:\005false\"\264\001\n\022ReductionPar" "ameter\022D\n\toperation\030\001 \001(\0162,.opencv_caffe" ".ReductionParameter.ReductionOp:\003SUM\022\017\n\004" "axis\030\002 \001(\005:\0010\022\020\n\005coeff\030\003 \001(\002:\0011\"5\n\013Reduc" "tionOp\022\007\n\003SUM\020\001\022\010\n\004ASUM\020\002\022\t\n\005SUMSQ\020\003\022\010\n\004" "MEAN\020\004\"\224\001\n\rReLUParameter\022\031\n\016negative_slo" "pe\030\001 \001(\002:\0010\022;\n\006engine\030\002 \001(\0162\".opencv_caf" "fe.ReLUParameter.Engine:\007DEFAULT\"+\n\006Engi" "ne\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"a\n" "\020ReshapeParameter\022&\n\005shape\030\001 \001(\0132\027.openc" "v_caffe.BlobShape\022\017\n\004axis\030\002 \001(\005:\0010\022\024\n\010nu" "m_axes\030\003 \001(\005:\002-1\"\263\001\n\016ScaleParameter\022\017\n\004a" "xis\030\001 \001(\005:\0011\022\023\n\010num_axes\030\002 \001(\005:\0011\022-\n\006fil" "ler\030\003 \001(\0132\035.opencv_caffe.FillerParameter" "\022\030\n\tbias_term\030\004 \001(\010:\005false\0222\n\013bias_fille" "r\030\005 \001(\0132\035.opencv_caffe.FillerParameter\"\177" "\n\020SigmoidParameter\022>\n\006engine\030\001 \001(\0162%.ope" "ncv_caffe.SigmoidParameter.Engine:\007DEFAU" "LT\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005" "CUDNN\020\002\"L\n\016SliceParameter\022\017\n\004axis\030\003 \001(\005:" "\0011\022\023\n\013slice_point\030\002 \003(\r\022\024\n\tslice_dim\030\001 \001" "(\r:\0011\"\220\001\n\020SoftmaxParameter\022>\n\006engine\030\001 \001" "(\0162%.opencv_caffe.SoftmaxParameter.Engin" "e:\007DEFAULT\022\017\n\004axis\030\002 \001(\005:\0011\"+\n\006Engine\022\013\n" "\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"y\n\rTanH" "Parameter\022;\n\006engine\030\001 \001(\0162\".opencv_caffe" ".TanHParameter.Engine:\007DEFAULT\"+\n\006Engine" "\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"/\n\rT" "ileParameter\022\017\n\004axis\030\001 \001(\005:\0011\022\r\n\005tiles\030\002" " \001(\005\"*\n\022ThresholdParameter\022\024\n\tthreshold\030" "\001 \001(\002:\0010\"\301\002\n\023WindowDataParameter\022\016\n\006sour" "ce\030\001 \001(\t\022\020\n\005scale\030\002 \001(\002:\0011\022\021\n\tmean_file\030" "\003 \001(\t\022\022\n\nbatch_size\030\004 \001(\r\022\024\n\tcrop_size\030\005" " \001(\r:\0010\022\025\n\006mirror\030\006 \001(\010:\005false\022\031\n\014fg_thr" "eshold\030\007 \001(\002:\0030.5\022\031\n\014bg_threshold\030\010 \001(\002:" "\0030.5\022\031\n\013fg_fraction\030\t \001(\002:\0040.25\022\026\n\013conte" "xt_pad\030\n \001(\r:\0010\022\027\n\tcrop_mode\030\013 \001(\t:\004warp" "\022\033\n\014cache_images\030\014 \001(\010:\005false\022\025\n\013root_fo" "lder\030\r \001(\t:\000\"\371\001\n\014SPPParameter\022\026\n\016pyramid" "_height\030\001 \001(\r\0228\n\004pool\030\002 \001(\0162%.opencv_caf" "fe.SPPParameter.PoolMethod:\003MAX\022:\n\006engin" "e\030\006 \001(\0162!.opencv_caffe.SPPParameter.Engi" "ne:\007DEFAULT\".\n\nPoolMethod\022\007\n\003MAX\020\000\022\007\n\003AV" "E\020\001\022\016\n\nSTOCHASTIC\020\002\"+\n\006Engine\022\013\n\007DEFAULT" "\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"\334\025\n\020V1LayerPara" "meter\022\016\n\006bottom\030\002 \003(\t\022\013\n\003top\030\003 \003(\t\022\014\n\004na" "me\030\004 \001(\t\022+\n\007include\030 \003(\0132\032.opencv_caffe" ".NetStateRule\022+\n\007exclude\030! \003(\0132\032.opencv_" "caffe.NetStateRule\0226\n\004type\030\005 \001(\0162(.openc" "v_caffe.V1LayerParameter.LayerType\022&\n\005bl" "obs\030\006 \003(\0132\027.opencv_caffe.BlobProto\022\016\n\005pa" "ram\030\351\007 \003(\t\022E\n\017blob_share_mode\030\352\007 \003(\0162+.o" "pencv_caffe.V1LayerParameter.DimCheckMod" "e\022\020\n\010blobs_lr\030\007 \003(\002\022\024\n\014weight_decay\030\010 \003(" "\002\022\023\n\013loss_weight\030# \003(\002\0227\n\016accuracy_param" "\030\033 \001(\0132\037.opencv_caffe.AccuracyParameter\022" "3\n\014argmax_param\030\027 \001(\0132\035.opencv_caffe.Arg" "MaxParameter\0223\n\014concat_param\030\t \001(\0132\035.ope" "ncv_caffe.ConcatParameter\022F\n\026contrastive" "_loss_param\030( \001(\0132&.opencv_caffe.Contras" "tiveLossParameter\022=\n\021convolution_param\030\n" " \001(\0132\".opencv_caffe.ConvolutionParameter" "\022/\n\ndata_param\030\013 \001(\0132\033.opencv_caffe.Data" "Parameter\0225\n\rdropout_param\030\014 \001(\0132\036.openc" "v_caffe.DropoutParameter\022:\n\020dummy_data_p" "aram\030\032 \001(\0132 .opencv_caffe.DummyDataParam" "eter\0225\n\reltwise_param\030\030 \001(\0132\036.opencv_caf" "fe.EltwiseParameter\022-\n\texp_param\030) \001(\0132\032" ".opencv_caffe.ExpParameter\0228\n\017hdf5_data_" "param\030\r \001(\0132\037.opencv_caffe.HDF5DataParam" "eter\022<\n\021hdf5_output_param\030\016 \001(\0132!.opencv" "_caffe.HDF5OutputParameter\022:\n\020hinge_loss" "_param\030\035 \001(\0132 .opencv_caffe.HingeLossPar" "ameter\022:\n\020image_data_param\030\017 \001(\0132 .openc" "v_caffe.ImageDataParameter\022@\n\023infogain_l" "oss_param\030\020 \001(\0132#.opencv_caffe.InfogainL" "ossParameter\022@\n\023inner_product_param\030\021 \001(" "\0132#.opencv_caffe.InnerProductParameter\022-" "\n\tlrn_param\030\022 \001(\0132\032.opencv_caffe.LRNPara" "meter\022<\n\021memory_data_param\030\026 \001(\0132!.openc" "v_caffe.MemoryDataParameter\022-\n\tmvn_param" "\030\" \001(\0132\032.opencv_caffe.MVNParameter\0225\n\rpo" "oling_param\030\023 \001(\0132\036.opencv_caffe.Pooling" "Parameter\0221\n\013power_param\030\025 \001(\0132\034.opencv_" "caffe.PowerParameter\022/\n\nrelu_param\030\036 \001(\013" "2\033.opencv_caffe.ReLUParameter\0225\n\rsigmoid" "_param\030& \001(\0132\036.opencv_caffe.SigmoidParam" "eter\0225\n\rsoftmax_param\030\' \001(\0132\036.opencv_caf" "fe.SoftmaxParameter\0221\n\013slice_param\030\037 \001(\013" "2\034.opencv_caffe.SliceParameter\022/\n\ntanh_p" "aram\030% \001(\0132\033.opencv_caffe.TanHParameter\022" "9\n\017threshold_param\030\031 \001(\0132 .opencv_caffe." "ThresholdParameter\022<\n\021window_data_param\030" "\024 \001(\0132!.opencv_caffe.WindowDataParameter" "\022>\n\017transform_param\030$ \001(\0132%.opencv_caffe" ".TransformationParameter\022/\n\nloss_param\030*" " \001(\0132\033.opencv_caffe.LossParameter\022-\n\005lay" "er\030\001 \001(\0132\036.opencv_caffe.V0LayerParameter" "\"\330\004\n\tLayerType\022\010\n\004NONE\020\000\022\n\n\006ABSVAL\020#\022\014\n\010" "ACCURACY\020\001\022\n\n\006ARGMAX\020\036\022\010\n\004BNLL\020\002\022\n\n\006CONC" "AT\020\003\022\024\n\020CONTRASTIVE_LOSS\020%\022\017\n\013CONVOLUTIO" "N\020\004\022\010\n\004DATA\020\005\022\021\n\rDECONVOLUTION\020\'\022\013\n\007DROP" "OUT\020\006\022\016\n\nDUMMY_DATA\020 \022\022\n\016EUCLIDEAN_LOSS\020" "\007\022\013\n\007ELTWISE\020\031\022\007\n\003EXP\020&\022\013\n\007FLATTEN\020\010\022\r\n\t" "HDF5_DATA\020\t\022\017\n\013HDF5_OUTPUT\020\n\022\016\n\nHINGE_LO" "SS\020\034\022\n\n\006IM2COL\020\013\022\016\n\nIMAGE_DATA\020\014\022\021\n\rINFO" "GAIN_LOSS\020\r\022\021\n\rINNER_PRODUCT\020\016\022\007\n\003LRN\020\017\022" "\017\n\013MEMORY_DATA\020\035\022\035\n\031MULTINOMIAL_LOGISTIC" "_LOSS\020\020\022\007\n\003MVN\020\"\022\013\n\007POOLING\020\021\022\t\n\005POWER\020\032" "\022\010\n\004RELU\020\022\022\013\n\007SIGMOID\020\023\022\036\n\032SIGMOID_CROSS" "_ENTROPY_LOSS\020\033\022\013\n\007SILENCE\020$\022\013\n\007SOFTMAX\020" "\024\022\020\n\014SOFTMAX_LOSS\020\025\022\t\n\005SPLIT\020\026\022\t\n\005SLICE\020" "!\022\010\n\004TANH\020\027\022\017\n\013WINDOW_DATA\020\030\022\r\n\tTHRESHOL" "D\020\037\"*\n\014DimCheckMode\022\n\n\006STRICT\020\000\022\016\n\nPERMI" "SSIVE\020\001\"\240\010\n\020V0LayerParameter\022\014\n\004name\030\001 \001" "(\t\022\014\n\004type\030\002 \001(\t\022\022\n\nnum_output\030\003 \001(\r\022\026\n\010" "biasterm\030\004 \001(\010:\004true\0224\n\rweight_filler\030\005 " "\001(\0132\035.opencv_caffe.FillerParameter\0222\n\013bi" "as_filler\030\006 \001(\0132\035.opencv_caffe.FillerPar" "ameter\022\016\n\003pad\030\007 \001(\r:\0010\022\022\n\nkernelsize\030\010 \001" "(\r\022\020\n\005group\030\t \001(\r:\0011\022\021\n\006stride\030\n \001(\r:\0011\022" "<\n\004pool\030\013 \001(\0162).opencv_caffe.V0LayerPara" "meter.PoolMethod:\003MAX\022\032\n\rdropout_ratio\030\014" " \001(\002:\0030.5\022\025\n\nlocal_size\030\r \001(\r:\0015\022\020\n\005alph" "a\030\016 \001(\002:\0011\022\022\n\004beta\030\017 \001(\002:\0040.75\022\014\n\001k\030\026 \001(" "\002:\0011\022\016\n\006source\030\020 \001(\t\022\020\n\005scale\030\021 \001(\002:\0011\022\020" "\n\010meanfile\030\022 \001(\t\022\021\n\tbatchsize\030\023 \001(\r\022\023\n\010c" "ropsize\030\024 \001(\r:\0010\022\025\n\006mirror\030\025 \001(\010:\005false\022" "&\n\005blobs\0302 \003(\0132\027.opencv_caffe.BlobProto\022" "\020\n\010blobs_lr\0303 \003(\002\022\024\n\014weight_decay\0304 \003(\002\022" "\024\n\trand_skip\0305 \001(\r:\0010\022\035\n\020det_fg_threshol" "d\0306 \001(\002:\0030.5\022\035\n\020det_bg_threshold\0307 \001(\002:\003" "0.5\022\035\n\017det_fg_fraction\0308 \001(\002:\0040.25\022\032\n\017de" "t_context_pad\030: \001(\r:\0010\022\033\n\rdet_crop_mode\030" "; \001(\t:\004warp\022\022\n\007new_num\030< \001(\005:\0010\022\027\n\014new_c" "hannels\030= \001(\005:\0010\022\025\n\nnew_height\030> \001(\005:\0010\022" "\024\n\tnew_width\030\? \001(\005:\0010\022\035\n\016shuffle_images\030" "@ \001(\010:\005false\022\025\n\nconcat_dim\030A \001(\r:\0011\022=\n\021h" "df5_output_param\030\351\007 \001(\0132!.opencv_caffe.H" "DF5OutputParameter\".\n\nPoolMethod\022\007\n\003MAX\020" "\000\022\007\n\003AVE\020\001\022\016\n\nSTOCHASTIC\020\002\"^\n\016PReLUParam" "eter\022-\n\006filler\030\001 \001(\0132\035.opencv_caffe.Fill" "erParameter\022\035\n\016channel_shared\030\002 \001(\010:\005fal" "se\"\207\001\n\016NormalizedBBox\022\014\n\004xmin\030\001 \001(\002\022\014\n\004y" "min\030\002 \001(\002\022\014\n\004xmax\030\003 \001(\002\022\014\n\004ymax\030\004 \001(\002\022\r\n" "\005label\030\005 \001(\005\022\021\n\tdifficult\030\006 \001(\010\022\r\n\005score" "\030\007 \001(\002\022\014\n\004size\030\010 \001(\002\"Y\n\023ROIPoolingParame" "ter\022\023\n\010pooled_h\030\001 \001(\r:\0010\022\023\n\010pooled_w\030\002 \001" "(\r:\0010\022\030\n\rspatial_scale\030\003 \001(\002:\0011\"\310\001\n\021Prop" "osalParameter\022\027\n\013feat_stride\030\001 \001(\r:\00216\022\025" "\n\tbase_size\030\002 \001(\r:\00216\022\024\n\010min_size\030\003 \001(\r:" "\00216\022\r\n\005ratio\030\004 \003(\002\022\r\n\005scale\030\005 \003(\002\022\032\n\014pre" "_nms_topn\030\006 \001(\r:\0046000\022\032\n\rpost_nms_topn\030\007" " \001(\r:\003300\022\027\n\nnms_thresh\030\010 \001(\002:\0030.7\"V\n\025PS" "ROIPoolingParameter\022\025\n\rspatial_scale\030\001 \002" "(\002\022\022\n\noutput_dim\030\002 \002(\005\022\022\n\ngroup_size\030\003 \002" "(\005*=\n\004Type\022\n\n\006DOUBLE\020\000\022\t\n\005FLOAT\020\001\022\013\n\007FLO" "AT16\020\002\022\007\n\003INT\020\003\022\010\n\004UINT\020\004*\034\n\005Phase\022\t\n\005TR" "AIN\020\000\022\010\n\004TEST\020\001" ; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_opencv_2dcaffe_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_opencv_2dcaffe_2eproto = { false, false, 18855, descriptor_table_protodef_opencv_2dcaffe_2eproto, "opencv-caffe.proto", &descriptor_table_opencv_2dcaffe_2eproto_once, nullptr, 0, 71, schemas, file_default_instances, TableStruct_opencv_2dcaffe_2eproto::offsets, file_level_metadata_opencv_2dcaffe_2eproto, file_level_enum_descriptors_opencv_2dcaffe_2eproto, file_level_service_descriptors_opencv_2dcaffe_2eproto, }; PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_opencv_2dcaffe_2eproto_getter() { return &descriptor_table_opencv_2dcaffe_2eproto; } // Force running AddDescriptors() at dynamic initialization time. PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_opencv_2dcaffe_2eproto(&descriptor_table_opencv_2dcaffe_2eproto); namespace opencv_caffe { const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PriorBoxParameter_CodeType_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[0]; } bool PriorBoxParameter_CodeType_IsValid(int value) { switch (value) { case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr PriorBoxParameter_CodeType PriorBoxParameter::CORNER; constexpr PriorBoxParameter_CodeType PriorBoxParameter::CENTER_SIZE; constexpr PriorBoxParameter_CodeType PriorBoxParameter::CodeType_MIN; constexpr PriorBoxParameter_CodeType PriorBoxParameter::CodeType_MAX; constexpr int PriorBoxParameter::CodeType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FillerParameter_VarianceNorm_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[1]; } bool FillerParameter_VarianceNorm_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr FillerParameter_VarianceNorm FillerParameter::FAN_IN; constexpr FillerParameter_VarianceNorm FillerParameter::FAN_OUT; constexpr FillerParameter_VarianceNorm FillerParameter::AVERAGE; constexpr FillerParameter_VarianceNorm FillerParameter::VarianceNorm_MIN; constexpr FillerParameter_VarianceNorm FillerParameter::VarianceNorm_MAX; constexpr int FillerParameter::VarianceNorm_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[2]; } bool SolverParameter_SnapshotFormat_IsValid(int value) { switch (value) { case 0: case 1: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr SolverParameter_SnapshotFormat SolverParameter::HDF5; constexpr SolverParameter_SnapshotFormat SolverParameter::BINARYPROTO; constexpr SolverParameter_SnapshotFormat SolverParameter::SnapshotFormat_MIN; constexpr SolverParameter_SnapshotFormat SolverParameter::SnapshotFormat_MAX; constexpr int SolverParameter::SnapshotFormat_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverMode_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[3]; } bool SolverParameter_SolverMode_IsValid(int value) { switch (value) { case 0: case 1: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr SolverParameter_SolverMode SolverParameter::CPU; constexpr SolverParameter_SolverMode SolverParameter::GPU; constexpr SolverParameter_SolverMode SolverParameter::SolverMode_MIN; constexpr SolverParameter_SolverMode SolverParameter::SolverMode_MAX; constexpr int SolverParameter::SolverMode_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverType_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[4]; } bool SolverParameter_SolverType_IsValid(int value) { switch (value) { case 0: case 1: case 2: case 3: case 4: case 5: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr SolverParameter_SolverType SolverParameter::SGD; constexpr SolverParameter_SolverType SolverParameter::NESTEROV; constexpr SolverParameter_SolverType SolverParameter::ADAGRAD; constexpr SolverParameter_SolverType SolverParameter::RMSPROP; constexpr SolverParameter_SolverType SolverParameter::ADADELTA; constexpr SolverParameter_SolverType SolverParameter::ADAM; constexpr SolverParameter_SolverType SolverParameter::SolverType_MIN; constexpr SolverParameter_SolverType SolverParameter::SolverType_MAX; constexpr int SolverParameter::SolverType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ParamSpec_DimCheckMode_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[5]; } bool ParamSpec_DimCheckMode_IsValid(int value) { switch (value) { case 0: case 1: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr ParamSpec_DimCheckMode ParamSpec::STRICT; constexpr ParamSpec_DimCheckMode ParamSpec::PERMISSIVE; constexpr ParamSpec_DimCheckMode ParamSpec::DimCheckMode_MIN; constexpr ParamSpec_DimCheckMode ParamSpec::DimCheckMode_MAX; constexpr int ParamSpec::DimCheckMode_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LossParameter_NormalizationMode_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[6]; } bool LossParameter_NormalizationMode_IsValid(int value) { switch (value) { case 0: case 1: case 2: case 3: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr LossParameter_NormalizationMode LossParameter::FULL; constexpr LossParameter_NormalizationMode LossParameter::VALID; constexpr LossParameter_NormalizationMode LossParameter::BATCH_SIZE; constexpr LossParameter_NormalizationMode LossParameter::NONE; constexpr LossParameter_NormalizationMode LossParameter::NormalizationMode_MIN; constexpr LossParameter_NormalizationMode LossParameter::NormalizationMode_MAX; constexpr int LossParameter::NormalizationMode_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConvolutionParameter_Engine_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[7]; } bool ConvolutionParameter_Engine_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr ConvolutionParameter_Engine ConvolutionParameter::DEFAULT; constexpr ConvolutionParameter_Engine ConvolutionParameter::CAFFE; constexpr ConvolutionParameter_Engine ConvolutionParameter::CUDNN; constexpr ConvolutionParameter_Engine ConvolutionParameter::Engine_MIN; constexpr ConvolutionParameter_Engine ConvolutionParameter::Engine_MAX; constexpr int ConvolutionParameter::Engine_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataParameter_DB_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[8]; } bool DataParameter_DB_IsValid(int value) { switch (value) { case 0: case 1: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr DataParameter_DB DataParameter::LEVELDB; constexpr DataParameter_DB DataParameter::LMDB; constexpr DataParameter_DB DataParameter::DB_MIN; constexpr DataParameter_DB DataParameter::DB_MAX; constexpr int DataParameter::DB_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[9]; } bool EltwiseParameter_EltwiseOp_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr EltwiseParameter_EltwiseOp EltwiseParameter::PROD; constexpr EltwiseParameter_EltwiseOp EltwiseParameter::SUM; constexpr EltwiseParameter_EltwiseOp EltwiseParameter::MAX; constexpr EltwiseParameter_EltwiseOp EltwiseParameter::EltwiseOp_MIN; constexpr EltwiseParameter_EltwiseOp EltwiseParameter::EltwiseOp_MAX; constexpr int EltwiseParameter::EltwiseOp_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HingeLossParameter_Norm_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[10]; } bool HingeLossParameter_Norm_IsValid(int value) { switch (value) { case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr HingeLossParameter_Norm HingeLossParameter::L1; constexpr HingeLossParameter_Norm HingeLossParameter::L2; constexpr HingeLossParameter_Norm HingeLossParameter::Norm_MIN; constexpr HingeLossParameter_Norm HingeLossParameter::Norm_MAX; constexpr int HingeLossParameter::Norm_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_NormRegion_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[11]; } bool LRNParameter_NormRegion_IsValid(int value) { switch (value) { case 0: case 1: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr LRNParameter_NormRegion LRNParameter::ACROSS_CHANNELS; constexpr LRNParameter_NormRegion LRNParameter::WITHIN_CHANNEL; constexpr LRNParameter_NormRegion LRNParameter::NormRegion_MIN; constexpr LRNParameter_NormRegion LRNParameter::NormRegion_MAX; constexpr int LRNParameter::NormRegion_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_Engine_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[12]; } bool LRNParameter_Engine_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr LRNParameter_Engine LRNParameter::DEFAULT; constexpr LRNParameter_Engine LRNParameter::CAFFE; constexpr LRNParameter_Engine LRNParameter::CUDNN; constexpr LRNParameter_Engine LRNParameter::Engine_MIN; constexpr LRNParameter_Engine LRNParameter::Engine_MAX; constexpr int LRNParameter::Engine_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_PoolMethod_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[13]; } bool PoolingParameter_PoolMethod_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr PoolingParameter_PoolMethod PoolingParameter::MAX; constexpr PoolingParameter_PoolMethod PoolingParameter::AVE; constexpr PoolingParameter_PoolMethod PoolingParameter::STOCHASTIC; constexpr PoolingParameter_PoolMethod PoolingParameter::PoolMethod_MIN; constexpr PoolingParameter_PoolMethod PoolingParameter::PoolMethod_MAX; constexpr int PoolingParameter::PoolMethod_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_Engine_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[14]; } bool PoolingParameter_Engine_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr PoolingParameter_Engine PoolingParameter::DEFAULT; constexpr PoolingParameter_Engine PoolingParameter::CAFFE; constexpr PoolingParameter_Engine PoolingParameter::CUDNN; constexpr PoolingParameter_Engine PoolingParameter::Engine_MIN; constexpr PoolingParameter_Engine PoolingParameter::Engine_MAX; constexpr int PoolingParameter::Engine_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReductionParameter_ReductionOp_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[15]; } bool ReductionParameter_ReductionOp_IsValid(int value) { switch (value) { case 1: case 2: case 3: case 4: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr ReductionParameter_ReductionOp ReductionParameter::SUM; constexpr ReductionParameter_ReductionOp ReductionParameter::ASUM; constexpr ReductionParameter_ReductionOp ReductionParameter::SUMSQ; constexpr ReductionParameter_ReductionOp ReductionParameter::MEAN; constexpr ReductionParameter_ReductionOp ReductionParameter::ReductionOp_MIN; constexpr ReductionParameter_ReductionOp ReductionParameter::ReductionOp_MAX; constexpr int ReductionParameter::ReductionOp_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReLUParameter_Engine_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[16]; } bool ReLUParameter_Engine_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr ReLUParameter_Engine ReLUParameter::DEFAULT; constexpr ReLUParameter_Engine ReLUParameter::CAFFE; constexpr ReLUParameter_Engine ReLUParameter::CUDNN; constexpr ReLUParameter_Engine ReLUParameter::Engine_MIN; constexpr ReLUParameter_Engine ReLUParameter::Engine_MAX; constexpr int ReLUParameter::Engine_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SigmoidParameter_Engine_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[17]; } bool SigmoidParameter_Engine_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr SigmoidParameter_Engine SigmoidParameter::DEFAULT; constexpr SigmoidParameter_Engine SigmoidParameter::CAFFE; constexpr SigmoidParameter_Engine SigmoidParameter::CUDNN; constexpr SigmoidParameter_Engine SigmoidParameter::Engine_MIN; constexpr SigmoidParameter_Engine SigmoidParameter::Engine_MAX; constexpr int SigmoidParameter::Engine_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SoftmaxParameter_Engine_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[18]; } bool SoftmaxParameter_Engine_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr SoftmaxParameter_Engine SoftmaxParameter::DEFAULT; constexpr SoftmaxParameter_Engine SoftmaxParameter::CAFFE; constexpr SoftmaxParameter_Engine SoftmaxParameter::CUDNN; constexpr SoftmaxParameter_Engine SoftmaxParameter::Engine_MIN; constexpr SoftmaxParameter_Engine SoftmaxParameter::Engine_MAX; constexpr int SoftmaxParameter::Engine_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TanHParameter_Engine_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[19]; } bool TanHParameter_Engine_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr TanHParameter_Engine TanHParameter::DEFAULT; constexpr TanHParameter_Engine TanHParameter::CAFFE; constexpr TanHParameter_Engine TanHParameter::CUDNN; constexpr TanHParameter_Engine TanHParameter::Engine_MIN; constexpr TanHParameter_Engine TanHParameter::Engine_MAX; constexpr int TanHParameter::Engine_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_PoolMethod_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[20]; } bool SPPParameter_PoolMethod_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr SPPParameter_PoolMethod SPPParameter::MAX; constexpr SPPParameter_PoolMethod SPPParameter::AVE; constexpr SPPParameter_PoolMethod SPPParameter::STOCHASTIC; constexpr SPPParameter_PoolMethod SPPParameter::PoolMethod_MIN; constexpr SPPParameter_PoolMethod SPPParameter::PoolMethod_MAX; constexpr int SPPParameter::PoolMethod_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_Engine_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[21]; } bool SPPParameter_Engine_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr SPPParameter_Engine SPPParameter::DEFAULT; constexpr SPPParameter_Engine SPPParameter::CAFFE; constexpr SPPParameter_Engine SPPParameter::CUDNN; constexpr SPPParameter_Engine SPPParameter::Engine_MIN; constexpr SPPParameter_Engine SPPParameter::Engine_MAX; constexpr int SPPParameter::Engine_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_LayerType_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[22]; } bool V1LayerParameter_LayerType_IsValid(int value) { switch (value) { case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25: case 26: case 27: case 28: case 29: case 30: case 31: case 32: case 33: case 34: case 35: case 36: case 37: case 38: case 39: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr V1LayerParameter_LayerType V1LayerParameter::NONE; constexpr V1LayerParameter_LayerType V1LayerParameter::ABSVAL; constexpr V1LayerParameter_LayerType V1LayerParameter::ACCURACY; constexpr V1LayerParameter_LayerType V1LayerParameter::ARGMAX; constexpr V1LayerParameter_LayerType V1LayerParameter::BNLL; constexpr V1LayerParameter_LayerType V1LayerParameter::CONCAT; constexpr V1LayerParameter_LayerType V1LayerParameter::CONTRASTIVE_LOSS; constexpr V1LayerParameter_LayerType V1LayerParameter::CONVOLUTION; constexpr V1LayerParameter_LayerType V1LayerParameter::DATA; constexpr V1LayerParameter_LayerType V1LayerParameter::DECONVOLUTION; constexpr V1LayerParameter_LayerType V1LayerParameter::DROPOUT; constexpr V1LayerParameter_LayerType V1LayerParameter::DUMMY_DATA; constexpr V1LayerParameter_LayerType V1LayerParameter::EUCLIDEAN_LOSS; constexpr V1LayerParameter_LayerType V1LayerParameter::ELTWISE; constexpr V1LayerParameter_LayerType V1LayerParameter::EXP; constexpr V1LayerParameter_LayerType V1LayerParameter::FLATTEN; constexpr V1LayerParameter_LayerType V1LayerParameter::HDF5_DATA; constexpr V1LayerParameter_LayerType V1LayerParameter::HDF5_OUTPUT; constexpr V1LayerParameter_LayerType V1LayerParameter::HINGE_LOSS; constexpr V1LayerParameter_LayerType V1LayerParameter::IM2COL; constexpr V1LayerParameter_LayerType V1LayerParameter::IMAGE_DATA; constexpr V1LayerParameter_LayerType V1LayerParameter::INFOGAIN_LOSS; constexpr V1LayerParameter_LayerType V1LayerParameter::INNER_PRODUCT; constexpr V1LayerParameter_LayerType V1LayerParameter::LRN; constexpr V1LayerParameter_LayerType V1LayerParameter::MEMORY_DATA; constexpr V1LayerParameter_LayerType V1LayerParameter::MULTINOMIAL_LOGISTIC_LOSS; constexpr V1LayerParameter_LayerType V1LayerParameter::MVN; constexpr V1LayerParameter_LayerType V1LayerParameter::POOLING; constexpr V1LayerParameter_LayerType V1LayerParameter::POWER; constexpr V1LayerParameter_LayerType V1LayerParameter::RELU; constexpr V1LayerParameter_LayerType V1LayerParameter::SIGMOID; constexpr V1LayerParameter_LayerType V1LayerParameter::SIGMOID_CROSS_ENTROPY_LOSS; constexpr V1LayerParameter_LayerType V1LayerParameter::SILENCE; constexpr V1LayerParameter_LayerType V1LayerParameter::SOFTMAX; constexpr V1LayerParameter_LayerType V1LayerParameter::SOFTMAX_LOSS; constexpr V1LayerParameter_LayerType V1LayerParameter::SPLIT; constexpr V1LayerParameter_LayerType V1LayerParameter::SLICE; constexpr V1LayerParameter_LayerType V1LayerParameter::TANH; constexpr V1LayerParameter_LayerType V1LayerParameter::WINDOW_DATA; constexpr V1LayerParameter_LayerType V1LayerParameter::THRESHOLD; constexpr V1LayerParameter_LayerType V1LayerParameter::LayerType_MIN; constexpr V1LayerParameter_LayerType V1LayerParameter::LayerType_MAX; constexpr int V1LayerParameter::LayerType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[23]; } bool V1LayerParameter_DimCheckMode_IsValid(int value) { switch (value) { case 0: case 1: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr V1LayerParameter_DimCheckMode V1LayerParameter::STRICT; constexpr V1LayerParameter_DimCheckMode V1LayerParameter::PERMISSIVE; constexpr V1LayerParameter_DimCheckMode V1LayerParameter::DimCheckMode_MIN; constexpr V1LayerParameter_DimCheckMode V1LayerParameter::DimCheckMode_MAX; constexpr int V1LayerParameter::DimCheckMode_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[24]; } bool V0LayerParameter_PoolMethod_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr V0LayerParameter_PoolMethod V0LayerParameter::MAX; constexpr V0LayerParameter_PoolMethod V0LayerParameter::AVE; constexpr V0LayerParameter_PoolMethod V0LayerParameter::STOCHASTIC; constexpr V0LayerParameter_PoolMethod V0LayerParameter::PoolMethod_MIN; constexpr V0LayerParameter_PoolMethod V0LayerParameter::PoolMethod_MAX; constexpr int V0LayerParameter::PoolMethod_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[25]; } bool Type_IsValid(int value) { switch (value) { case 0: case 1: case 2: case 3: case 4: return true; default: return false; } } const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Phase_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_opencv_2dcaffe_2eproto); return file_level_enum_descriptors_opencv_2dcaffe_2eproto[26]; } bool Phase_IsValid(int value) { switch (value) { case 0: case 1: return true; default: return false; } } // =================================================================== class BlobShape::_Internal { public: }; BlobShape::BlobShape(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), dim_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.BlobShape) } BlobShape::BlobShape(const BlobShape& from) : ::PROTOBUF_NAMESPACE_ID::Message(), dim_(from.dim_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:opencv_caffe.BlobShape) } inline void BlobShape::SharedCtor() { } BlobShape::~BlobShape() { // @@protoc_insertion_point(destructor:opencv_caffe.BlobShape) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void BlobShape::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void BlobShape::ArenaDtor(void* object) { BlobShape* _this = reinterpret_cast< BlobShape* >(object); (void)_this; } void BlobShape::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void BlobShape::SetCachedSize(int size) const { _cached_size_.Set(size); } void BlobShape::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.BlobShape) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; dim_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* BlobShape::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated int64 dim = 1 [packed = true]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_dim(), ptr, ctx); CHK_(ptr); } else if (static_cast(tag) == 8) { _internal_add_dim(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* BlobShape::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BlobShape) uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated int64 dim = 1 [packed = true]; { int byte_size = _dim_cached_byte_size_.load(std::memory_order_relaxed); if (byte_size > 0) { target = stream->WriteInt64Packed( 1, _internal_dim(), byte_size, target); } } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BlobShape) return target; } size_t BlobShape::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BlobShape) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated int64 dim = 1 [packed = true]; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: Int64Size(this->dim_); if (data_size > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( static_cast(data_size)); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); _dim_cached_byte_size_.store(cached_size, std::memory_order_relaxed); total_size += data_size; } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BlobShape::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, BlobShape::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BlobShape::GetClassData() const { return &_class_data_; } void BlobShape::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void BlobShape::MergeFrom(const BlobShape& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BlobShape) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; dim_.MergeFrom(from.dim_); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void BlobShape::CopyFrom(const BlobShape& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BlobShape) if (&from == this) return; Clear(); MergeFrom(from); } bool BlobShape::IsInitialized() const { return true; } void BlobShape::InternalSwap(BlobShape* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); dim_.InternalSwap(&other->dim_); } ::PROTOBUF_NAMESPACE_ID::Metadata BlobShape::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[0]); } // =================================================================== class BlobProto::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static const ::opencv_caffe::BlobShape& shape(const BlobProto* msg); static void set_has_shape(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_raw_data_type(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_raw_data(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_num(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_channels(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_height(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_width(HasBits* has_bits) { (*has_bits)[0] |= 32u; } }; const ::opencv_caffe::BlobShape& BlobProto::_Internal::shape(const BlobProto* msg) { return *msg->shape_; } BlobProto::BlobProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), data_(arena), diff_(arena), double_data_(arena), double_diff_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.BlobProto) } BlobProto::BlobProto(const BlobProto& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), data_(from.data_), diff_(from.diff_), double_data_(from.double_data_), double_diff_(from.double_diff_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_raw_data()) { raw_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_raw_data(), GetArenaForAllocation()); } if (from._internal_has_shape()) { shape_ = new ::opencv_caffe::BlobShape(*from.shape_); } else { shape_ = nullptr; } ::memcpy(&num_, &from.num_, static_cast(reinterpret_cast(&raw_data_type_) - reinterpret_cast(&num_)) + sizeof(raw_data_type_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.BlobProto) } inline void BlobProto::SharedCtor() { raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&shape_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&raw_data_type_) - reinterpret_cast(&shape_)) + sizeof(raw_data_type_)); } BlobProto::~BlobProto() { // @@protoc_insertion_point(destructor:opencv_caffe.BlobProto) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void BlobProto::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); raw_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete shape_; } void BlobProto::ArenaDtor(void* object) { BlobProto* _this = reinterpret_cast< BlobProto* >(object); (void)_this; } void BlobProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void BlobProto::SetCachedSize(int size) const { _cached_size_.Set(size); } void BlobProto::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.BlobProto) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; data_.Clear(); diff_.Clear(); double_data_.Clear(); double_diff_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { raw_data_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(shape_ != nullptr); shape_->Clear(); } } if (cached_has_bits & 0x0000007cu) { ::memset(&num_, 0, static_cast( reinterpret_cast(&raw_data_type_) - reinterpret_cast(&num_)) + sizeof(raw_data_type_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* BlobProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional int32 num = 1 [default = 0]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_num(&has_bits); num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 channels = 2 [default = 0]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_channels(&has_bits); channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 height = 3 [default = 0]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_height(&has_bits); height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 width = 4 [default = 0]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_width(&has_bits); width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated float data = 5 [packed = true]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_data(), ptr, ctx); CHK_(ptr); } else if (static_cast(tag) == 45) { _internal_add_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); } else goto handle_unusual; continue; // repeated float diff = 6 [packed = true]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_diff(), ptr, ctx); CHK_(ptr); } else if (static_cast(tag) == 53) { _internal_add_diff(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); } else goto handle_unusual; continue; // optional .opencv_caffe.BlobShape shape = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated double double_data = 8 [packed = true]; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_double_data(), ptr, ctx); CHK_(ptr); } else if (static_cast(tag) == 65) { _internal_add_double_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(double); } else goto handle_unusual; continue; // repeated double double_diff = 9 [packed = true]; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_double_diff(), ptr, ctx); CHK_(ptr); } else if (static_cast(tag) == 73) { _internal_add_double_diff(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(double); } else goto handle_unusual; continue; // optional .opencv_caffe.Type raw_data_type = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::Type_IsValid(val))) { _internal_set_raw_data_type(static_cast<::opencv_caffe::Type>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional bytes raw_data = 12 [packed = false]; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { auto str = _internal_mutable_raw_data(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* BlobProto::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BlobProto) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional int32 num = 1 [default = 0]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_num(), target); } // optional int32 channels = 2 [default = 0]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_channels(), target); } // optional int32 height = 3 [default = 0]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_height(), target); } // optional int32 width = 4 [default = 0]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_width(), target); } // repeated float data = 5 [packed = true]; if (this->_internal_data_size() > 0) { target = stream->WriteFixedPacked(5, _internal_data(), target); } // repeated float diff = 6 [packed = true]; if (this->_internal_diff_size() > 0) { target = stream->WriteFixedPacked(6, _internal_diff(), target); } // optional .opencv_caffe.BlobShape shape = 7; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 7, _Internal::shape(this), target, stream); } // repeated double double_data = 8 [packed = true]; if (this->_internal_double_data_size() > 0) { target = stream->WriteFixedPacked(8, _internal_double_data(), target); } // repeated double double_diff = 9 [packed = true]; if (this->_internal_double_diff_size() > 0) { target = stream->WriteFixedPacked(9, _internal_double_diff(), target); } // optional .opencv_caffe.Type raw_data_type = 10; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 10, this->_internal_raw_data_type(), target); } // optional bytes raw_data = 12 [packed = false]; if (cached_has_bits & 0x00000001u) { target = stream->WriteBytesMaybeAliased( 12, this->_internal_raw_data(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BlobProto) return target; } size_t BlobProto::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BlobProto) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated float data = 5 [packed = true]; { unsigned int count = static_cast(this->_internal_data_size()); size_t data_size = 4UL * count; if (data_size > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( static_cast(data_size)); } total_size += data_size; } // repeated float diff = 6 [packed = true]; { unsigned int count = static_cast(this->_internal_diff_size()); size_t data_size = 4UL * count; if (data_size > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( static_cast(data_size)); } total_size += data_size; } // repeated double double_data = 8 [packed = true]; { unsigned int count = static_cast(this->_internal_double_data_size()); size_t data_size = 8UL * count; if (data_size > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( static_cast(data_size)); } total_size += data_size; } // repeated double double_diff = 9 [packed = true]; { unsigned int count = static_cast(this->_internal_double_diff_size()); size_t data_size = 8UL * count; if (data_size > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( static_cast(data_size)); } total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000007fu) { // optional bytes raw_data = 12 [packed = false]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_raw_data()); } // optional .opencv_caffe.BlobShape shape = 7; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *shape_); } // optional int32 num = 1 [default = 0]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num()); } // optional int32 channels = 2 [default = 0]; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_channels()); } // optional int32 height = 3 [default = 0]; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_height()); } // optional int32 width = 4 [default = 0]; if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_width()); } // optional .opencv_caffe.Type raw_data_type = 10; if (cached_has_bits & 0x00000040u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_raw_data_type()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BlobProto::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, BlobProto::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BlobProto::GetClassData() const { return &_class_data_; } void BlobProto::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void BlobProto::MergeFrom(const BlobProto& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BlobProto) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; data_.MergeFrom(from.data_); diff_.MergeFrom(from.diff_); double_data_.MergeFrom(from.double_data_); double_diff_.MergeFrom(from.double_diff_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000007fu) { if (cached_has_bits & 0x00000001u) { _internal_set_raw_data(from._internal_raw_data()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_shape()->::opencv_caffe::BlobShape::MergeFrom(from._internal_shape()); } if (cached_has_bits & 0x00000004u) { num_ = from.num_; } if (cached_has_bits & 0x00000008u) { channels_ = from.channels_; } if (cached_has_bits & 0x00000010u) { height_ = from.height_; } if (cached_has_bits & 0x00000020u) { width_ = from.width_; } if (cached_has_bits & 0x00000040u) { raw_data_type_ = from.raw_data_type_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void BlobProto::CopyFrom(const BlobProto& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BlobProto) if (&from == this) return; Clear(); MergeFrom(from); } bool BlobProto::IsInitialized() const { return true; } void BlobProto::InternalSwap(BlobProto* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); data_.InternalSwap(&other->data_); diff_.InternalSwap(&other->diff_); double_data_.InternalSwap(&other->double_data_); double_diff_.InternalSwap(&other->double_diff_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &raw_data_, lhs_arena, &other->raw_data_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(BlobProto, raw_data_type_) + sizeof(BlobProto::raw_data_type_) - PROTOBUF_FIELD_OFFSET(BlobProto, shape_)>( reinterpret_cast(&shape_), reinterpret_cast(&other->shape_)); } ::PROTOBUF_NAMESPACE_ID::Metadata BlobProto::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[1]); } // =================================================================== class BlobProtoVector::_Internal { public: }; BlobProtoVector::BlobProtoVector(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), blobs_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.BlobProtoVector) } BlobProtoVector::BlobProtoVector(const BlobProtoVector& from) : ::PROTOBUF_NAMESPACE_ID::Message(), blobs_(from.blobs_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:opencv_caffe.BlobProtoVector) } inline void BlobProtoVector::SharedCtor() { } BlobProtoVector::~BlobProtoVector() { // @@protoc_insertion_point(destructor:opencv_caffe.BlobProtoVector) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void BlobProtoVector::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void BlobProtoVector::ArenaDtor(void* object) { BlobProtoVector* _this = reinterpret_cast< BlobProtoVector* >(object); (void)_this; } void BlobProtoVector::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void BlobProtoVector::SetCachedSize(int size) const { _cached_size_.Set(size); } void BlobProtoVector::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.BlobProtoVector) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; blobs_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* BlobProtoVector::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .opencv_caffe.BlobProto blobs = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_blobs(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* BlobProtoVector::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BlobProtoVector) uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .opencv_caffe.BlobProto blobs = 1; for (unsigned int i = 0, n = static_cast(this->_internal_blobs_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(1, this->_internal_blobs(i), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BlobProtoVector) return target; } size_t BlobProtoVector::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BlobProtoVector) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated .opencv_caffe.BlobProto blobs = 1; total_size += 1UL * this->_internal_blobs_size(); for (const auto& msg : this->blobs_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BlobProtoVector::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, BlobProtoVector::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BlobProtoVector::GetClassData() const { return &_class_data_; } void BlobProtoVector::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void BlobProtoVector::MergeFrom(const BlobProtoVector& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BlobProtoVector) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; blobs_.MergeFrom(from.blobs_); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void BlobProtoVector::CopyFrom(const BlobProtoVector& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BlobProtoVector) if (&from == this) return; Clear(); MergeFrom(from); } bool BlobProtoVector::IsInitialized() const { return true; } void BlobProtoVector::InternalSwap(BlobProtoVector* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); blobs_.InternalSwap(&other->blobs_); } ::PROTOBUF_NAMESPACE_ID::Metadata BlobProtoVector::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[2]); } // =================================================================== class PermuteParameter::_Internal { public: }; PermuteParameter::PermuteParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), order_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.PermuteParameter) } PermuteParameter::PermuteParameter(const PermuteParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), order_(from.order_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:opencv_caffe.PermuteParameter) } inline void PermuteParameter::SharedCtor() { } PermuteParameter::~PermuteParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.PermuteParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void PermuteParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void PermuteParameter::ArenaDtor(void* object) { PermuteParameter* _this = reinterpret_cast< PermuteParameter* >(object); (void)_this; } void PermuteParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void PermuteParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void PermuteParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.PermuteParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; order_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* PermuteParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated uint32 order = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { ptr -= 1; do { ptr += 1; _internal_add_order(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr)); } else if (static_cast(tag) == 10) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_order(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* PermuteParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PermuteParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated uint32 order = 1; for (int i = 0, n = this->_internal_order_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_order(i), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PermuteParameter) return target; } size_t PermuteParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PermuteParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated uint32 order = 1; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->order_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_order_size()); total_size += data_size; } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PermuteParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, PermuteParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PermuteParameter::GetClassData() const { return &_class_data_; } void PermuteParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void PermuteParameter::MergeFrom(const PermuteParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PermuteParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; order_.MergeFrom(from.order_); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void PermuteParameter::CopyFrom(const PermuteParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PermuteParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool PermuteParameter::IsInitialized() const { return true; } void PermuteParameter::InternalSwap(PermuteParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); order_.InternalSwap(&other->order_); } ::PROTOBUF_NAMESPACE_ID::Metadata PermuteParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[3]); } // =================================================================== class NormalizeBBoxParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_across_spatial(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static const ::opencv_caffe::FillerParameter& scale_filler(const NormalizeBBoxParameter* msg); static void set_has_scale_filler(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_channel_shared(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_eps(HasBits* has_bits) { (*has_bits)[0] |= 8u; } }; const ::opencv_caffe::FillerParameter& NormalizeBBoxParameter::_Internal::scale_filler(const NormalizeBBoxParameter* msg) { return *msg->scale_filler_; } NormalizeBBoxParameter::NormalizeBBoxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.NormalizeBBoxParameter) } NormalizeBBoxParameter::NormalizeBBoxParameter(const NormalizeBBoxParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_scale_filler()) { scale_filler_ = new ::opencv_caffe::FillerParameter(*from.scale_filler_); } else { scale_filler_ = nullptr; } ::memcpy(&across_spatial_, &from.across_spatial_, static_cast(reinterpret_cast(&eps_) - reinterpret_cast(&across_spatial_)) + sizeof(eps_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.NormalizeBBoxParameter) } inline void NormalizeBBoxParameter::SharedCtor() { scale_filler_ = nullptr; across_spatial_ = true; channel_shared_ = true; eps_ = 1e-10f; } NormalizeBBoxParameter::~NormalizeBBoxParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.NormalizeBBoxParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void NormalizeBBoxParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete scale_filler_; } void NormalizeBBoxParameter::ArenaDtor(void* object) { NormalizeBBoxParameter* _this = reinterpret_cast< NormalizeBBoxParameter* >(object); (void)_this; } void NormalizeBBoxParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NormalizeBBoxParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void NormalizeBBoxParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.NormalizeBBoxParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(scale_filler_ != nullptr); scale_filler_->Clear(); } across_spatial_ = true; channel_shared_ = true; eps_ = 1e-10f; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NormalizeBBoxParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional bool across_spatial = 1 [default = true]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_across_spatial(&has_bits); across_spatial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter scale_filler = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_scale_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool channel_shared = 3 [default = true]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_channel_shared(&has_bits); channel_shared_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float eps = 4 [default = 1e-10]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { _Internal::set_has_eps(&has_bits); eps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* NormalizeBBoxParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NormalizeBBoxParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional bool across_spatial = 1 [default = true]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_across_spatial(), target); } // optional .opencv_caffe.FillerParameter scale_filler = 2; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 2, _Internal::scale_filler(this), target, stream); } // optional bool channel_shared = 3 [default = true]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_channel_shared(), target); } // optional float eps = 4 [default = 1e-10]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_eps(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NormalizeBBoxParameter) return target; } size_t NormalizeBBoxParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NormalizeBBoxParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000fu) { // optional .opencv_caffe.FillerParameter scale_filler = 2; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *scale_filler_); } // optional bool across_spatial = 1 [default = true]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 1; } // optional bool channel_shared = 3 [default = true]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 1; } // optional float eps = 4 [default = 1e-10]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NormalizeBBoxParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, NormalizeBBoxParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NormalizeBBoxParameter::GetClassData() const { return &_class_data_; } void NormalizeBBoxParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void NormalizeBBoxParameter::MergeFrom(const NormalizeBBoxParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NormalizeBBoxParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_scale_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_scale_filler()); } if (cached_has_bits & 0x00000002u) { across_spatial_ = from.across_spatial_; } if (cached_has_bits & 0x00000004u) { channel_shared_ = from.channel_shared_; } if (cached_has_bits & 0x00000008u) { eps_ = from.eps_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void NormalizeBBoxParameter::CopyFrom(const NormalizeBBoxParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NormalizeBBoxParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool NormalizeBBoxParameter::IsInitialized() const { return true; } void NormalizeBBoxParameter::InternalSwap(NormalizeBBoxParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(scale_filler_, other->scale_filler_); swap(across_spatial_, other->across_spatial_); swap(channel_shared_, other->channel_shared_); swap(eps_, other->eps_); } ::PROTOBUF_NAMESPACE_ID::Metadata NormalizeBBoxParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[4]); } // =================================================================== class PriorBoxParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_flip(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_clip(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static void set_has_img_size(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_img_h(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_img_w(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_step(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_step_h(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_step_w(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_offset(HasBits* has_bits) { (*has_bits)[0] |= 256u; } }; PriorBoxParameter::PriorBoxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), min_size_(arena), max_size_(arena), aspect_ratio_(arena), variance_(arena), offset_h_(arena), offset_w_(arena), width_(arena), height_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.PriorBoxParameter) } PriorBoxParameter::PriorBoxParameter(const PriorBoxParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), min_size_(from.min_size_), max_size_(from.max_size_), aspect_ratio_(from.aspect_ratio_), variance_(from.variance_), offset_h_(from.offset_h_), offset_w_(from.offset_w_), width_(from.width_), height_(from.height_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&img_size_, &from.img_size_, static_cast(reinterpret_cast(&offset_) - reinterpret_cast(&img_size_)) + sizeof(offset_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.PriorBoxParameter) } inline void PriorBoxParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&img_size_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&step_w_) - reinterpret_cast(&img_size_)) + sizeof(step_w_)); flip_ = true; clip_ = true; offset_ = 0.5f; } PriorBoxParameter::~PriorBoxParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.PriorBoxParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void PriorBoxParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void PriorBoxParameter::ArenaDtor(void* object) { PriorBoxParameter* _this = reinterpret_cast< PriorBoxParameter* >(object); (void)_this; } void PriorBoxParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void PriorBoxParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void PriorBoxParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.PriorBoxParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; min_size_.Clear(); max_size_.Clear(); aspect_ratio_.Clear(); variance_.Clear(); offset_h_.Clear(); offset_w_.Clear(); width_.Clear(); height_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { ::memset(&img_size_, 0, static_cast( reinterpret_cast(&step_w_) - reinterpret_cast(&img_size_)) + sizeof(step_w_)); flip_ = true; clip_ = true; } offset_ = 0.5f; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* PriorBoxParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated float min_size = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { ptr -= 1; do { ptr += 1; _internal_add_min_size(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<13>(ptr)); } else if (static_cast(tag) == 10) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_min_size(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated float max_size = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { ptr -= 1; do { ptr += 1; _internal_add_max_size(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<21>(ptr)); } else if (static_cast(tag) == 18) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_max_size(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated float aspect_ratio = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { ptr -= 1; do { ptr += 1; _internal_add_aspect_ratio(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<29>(ptr)); } else if (static_cast(tag) == 26) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_aspect_ratio(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional bool flip = 4 [default = true]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_flip(&has_bits); flip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool clip = 5 [default = true]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_clip(&has_bits); clip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated float variance = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { ptr -= 1; do { ptr += 1; _internal_add_variance(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<53>(ptr)); } else if (static_cast(tag) == 50) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_variance(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 img_size = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_img_size(&has_bits); img_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 img_h = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { _Internal::set_has_img_h(&has_bits); img_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 img_w = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { _Internal::set_has_img_w(&has_bits); img_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float step = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 85)) { _Internal::set_has_step(&has_bits); step_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float step_h = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 93)) { _Internal::set_has_step_h(&has_bits); step_h_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float step_w = 12; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 101)) { _Internal::set_has_step_w(&has_bits); step_w_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float offset = 13 [default = 0.5]; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 109)) { _Internal::set_has_offset(&has_bits); offset_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // repeated float offset_h = 14; case 14: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 117)) { ptr -= 1; do { ptr += 1; _internal_add_offset_h(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<117>(ptr)); } else if (static_cast(tag) == 114) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_offset_h(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated float offset_w = 15; case 15: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 125)) { ptr -= 1; do { ptr += 1; _internal_add_offset_w(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<125>(ptr)); } else if (static_cast(tag) == 122) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_offset_w(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated float width = 16; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 133)) { ptr -= 2; do { ptr += 2; _internal_add_width(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<133>(ptr)); } else if (static_cast(tag) == 130) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_width(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated float height = 17; case 17: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 141)) { ptr -= 2; do { ptr += 2; _internal_add_height(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<141>(ptr)); } else if (static_cast(tag) == 138) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_height(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* PriorBoxParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PriorBoxParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated float min_size = 1; for (int i = 0, n = this->_internal_min_size_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_min_size(i), target); } // repeated float max_size = 2; for (int i = 0, n = this->_internal_max_size_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_max_size(i), target); } // repeated float aspect_ratio = 3; for (int i = 0, n = this->_internal_aspect_ratio_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_aspect_ratio(i), target); } cached_has_bits = _has_bits_[0]; // optional bool flip = 4 [default = true]; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_flip(), target); } // optional bool clip = 5 [default = true]; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_clip(), target); } // repeated float variance = 6; for (int i = 0, n = this->_internal_variance_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_variance(i), target); } // optional uint32 img_size = 7; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_img_size(), target); } // optional uint32 img_h = 8; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_img_h(), target); } // optional uint32 img_w = 9; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_img_w(), target); } // optional float step = 10; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_step(), target); } // optional float step_h = 11; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(11, this->_internal_step_h(), target); } // optional float step_w = 12; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(12, this->_internal_step_w(), target); } // optional float offset = 13 [default = 0.5]; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(13, this->_internal_offset(), target); } // repeated float offset_h = 14; for (int i = 0, n = this->_internal_offset_h_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(14, this->_internal_offset_h(i), target); } // repeated float offset_w = 15; for (int i = 0, n = this->_internal_offset_w_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(15, this->_internal_offset_w(i), target); } // repeated float width = 16; for (int i = 0, n = this->_internal_width_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(16, this->_internal_width(i), target); } // repeated float height = 17; for (int i = 0, n = this->_internal_height_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(17, this->_internal_height(i), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PriorBoxParameter) return target; } size_t PriorBoxParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PriorBoxParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated float min_size = 1; { unsigned int count = static_cast(this->_internal_min_size_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_min_size_size()); total_size += data_size; } // repeated float max_size = 2; { unsigned int count = static_cast(this->_internal_max_size_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_max_size_size()); total_size += data_size; } // repeated float aspect_ratio = 3; { unsigned int count = static_cast(this->_internal_aspect_ratio_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_aspect_ratio_size()); total_size += data_size; } // repeated float variance = 6; { unsigned int count = static_cast(this->_internal_variance_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_variance_size()); total_size += data_size; } // repeated float offset_h = 14; { unsigned int count = static_cast(this->_internal_offset_h_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_offset_h_size()); total_size += data_size; } // repeated float offset_w = 15; { unsigned int count = static_cast(this->_internal_offset_w_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_offset_w_size()); total_size += data_size; } // repeated float width = 16; { unsigned int count = static_cast(this->_internal_width_size()); size_t data_size = 4UL * count; total_size += 2 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_width_size()); total_size += data_size; } // repeated float height = 17; { unsigned int count = static_cast(this->_internal_height_size()); size_t data_size = 4UL * count; total_size += 2 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_height_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional uint32 img_size = 7; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_img_size()); } // optional uint32 img_h = 8; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_img_h()); } // optional uint32 img_w = 9; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_img_w()); } // optional float step = 10; if (cached_has_bits & 0x00000008u) { total_size += 1 + 4; } // optional float step_h = 11; if (cached_has_bits & 0x00000010u) { total_size += 1 + 4; } // optional float step_w = 12; if (cached_has_bits & 0x00000020u) { total_size += 1 + 4; } // optional bool flip = 4 [default = true]; if (cached_has_bits & 0x00000040u) { total_size += 1 + 1; } // optional bool clip = 5 [default = true]; if (cached_has_bits & 0x00000080u) { total_size += 1 + 1; } } // optional float offset = 13 [default = 0.5]; if (cached_has_bits & 0x00000100u) { total_size += 1 + 4; } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PriorBoxParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, PriorBoxParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PriorBoxParameter::GetClassData() const { return &_class_data_; } void PriorBoxParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void PriorBoxParameter::MergeFrom(const PriorBoxParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PriorBoxParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; min_size_.MergeFrom(from.min_size_); max_size_.MergeFrom(from.max_size_); aspect_ratio_.MergeFrom(from.aspect_ratio_); variance_.MergeFrom(from.variance_); offset_h_.MergeFrom(from.offset_h_); offset_w_.MergeFrom(from.offset_w_); width_.MergeFrom(from.width_); height_.MergeFrom(from.height_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { img_size_ = from.img_size_; } if (cached_has_bits & 0x00000002u) { img_h_ = from.img_h_; } if (cached_has_bits & 0x00000004u) { img_w_ = from.img_w_; } if (cached_has_bits & 0x00000008u) { step_ = from.step_; } if (cached_has_bits & 0x00000010u) { step_h_ = from.step_h_; } if (cached_has_bits & 0x00000020u) { step_w_ = from.step_w_; } if (cached_has_bits & 0x00000040u) { flip_ = from.flip_; } if (cached_has_bits & 0x00000080u) { clip_ = from.clip_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0x00000100u) { _internal_set_offset(from._internal_offset()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void PriorBoxParameter::CopyFrom(const PriorBoxParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PriorBoxParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool PriorBoxParameter::IsInitialized() const { return true; } void PriorBoxParameter::InternalSwap(PriorBoxParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); min_size_.InternalSwap(&other->min_size_); max_size_.InternalSwap(&other->max_size_); aspect_ratio_.InternalSwap(&other->aspect_ratio_); variance_.InternalSwap(&other->variance_); offset_h_.InternalSwap(&other->offset_h_); offset_w_.InternalSwap(&other->offset_w_); width_.InternalSwap(&other->width_); height_.InternalSwap(&other->height_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(PriorBoxParameter, step_w_) + sizeof(PriorBoxParameter::step_w_) - PROTOBUF_FIELD_OFFSET(PriorBoxParameter, img_size_)>( reinterpret_cast(&img_size_), reinterpret_cast(&other->img_size_)); swap(flip_, other->flip_); swap(clip_, other->clip_); swap(offset_, other->offset_); } ::PROTOBUF_NAMESPACE_ID::Metadata PriorBoxParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[5]); } // =================================================================== class DetectionOutputParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_num_classes(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_share_location(HasBits* has_bits) { (*has_bits)[0] |= 512u; } static void set_has_background_label_id(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static const ::opencv_caffe::NonMaximumSuppressionParameter& nms_param(const DetectionOutputParameter* msg); static void set_has_nms_param(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static const ::opencv_caffe::SaveOutputParameter& save_output_param(const DetectionOutputParameter* msg); static void set_has_save_output_param(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_code_type(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static void set_has_variance_encoded_in_target(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_keep_top_k(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static void set_has_confidence_threshold(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_normalized_bbox(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } static void set_has_clip(HasBits* has_bits) { (*has_bits)[0] |= 64u; } }; const ::opencv_caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::_Internal::nms_param(const DetectionOutputParameter* msg) { return *msg->nms_param_; } const ::opencv_caffe::SaveOutputParameter& DetectionOutputParameter::_Internal::save_output_param(const DetectionOutputParameter* msg) { return *msg->save_output_param_; } DetectionOutputParameter::DetectionOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.DetectionOutputParameter) } DetectionOutputParameter::DetectionOutputParameter(const DetectionOutputParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_nms_param()) { nms_param_ = new ::opencv_caffe::NonMaximumSuppressionParameter(*from.nms_param_); } else { nms_param_ = nullptr; } if (from._internal_has_save_output_param()) { save_output_param_ = new ::opencv_caffe::SaveOutputParameter(*from.save_output_param_); } else { save_output_param_ = nullptr; } ::memcpy(&num_classes_, &from.num_classes_, static_cast(reinterpret_cast(&normalized_bbox_) - reinterpret_cast(&num_classes_)) + sizeof(normalized_bbox_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.DetectionOutputParameter) } inline void DetectionOutputParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&nms_param_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&clip_) - reinterpret_cast(&nms_param_)) + sizeof(clip_)); keep_top_k_ = -1; code_type_ = 1; share_location_ = true; normalized_bbox_ = true; } DetectionOutputParameter::~DetectionOutputParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.DetectionOutputParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void DetectionOutputParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete nms_param_; if (this != internal_default_instance()) delete save_output_param_; } void DetectionOutputParameter::ArenaDtor(void* object) { DetectionOutputParameter* _this = reinterpret_cast< DetectionOutputParameter* >(object); (void)_this; } void DetectionOutputParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void DetectionOutputParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void DetectionOutputParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.DetectionOutputParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(nms_param_ != nullptr); nms_param_->Clear(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(save_output_param_ != nullptr); save_output_param_->Clear(); } } if (cached_has_bits & 0x000000fcu) { ::memset(&num_classes_, 0, static_cast( reinterpret_cast(&clip_) - reinterpret_cast(&num_classes_)) + sizeof(clip_)); keep_top_k_ = -1; } if (cached_has_bits & 0x00000700u) { code_type_ = 1; share_location_ = true; normalized_bbox_ = true; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* DetectionOutputParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 num_classes = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_num_classes(&has_bits); num_classes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool share_location = 2 [default = true]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_share_location(&has_bits); share_location_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 background_label_id = 3 [default = 0]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_background_label_id(&has_bits); background_label_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_nms_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SaveOutputParameter save_output_param = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_save_output_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::PriorBoxParameter_CodeType_IsValid(val))) { _internal_set_code_type(static_cast<::opencv_caffe::PriorBoxParameter_CodeType>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional int32 keep_top_k = 7 [default = -1]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_keep_top_k(&has_bits); keep_top_k_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool variance_encoded_in_target = 8 [default = false]; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { _Internal::set_has_variance_encoded_in_target(&has_bits); variance_encoded_in_target_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float confidence_threshold = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 77)) { _Internal::set_has_confidence_threshold(&has_bits); confidence_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional bool normalized_bbox = 10 [default = true]; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { _Internal::set_has_normalized_bbox(&has_bits); normalized_bbox_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool clip = 1000 [default = false]; case 1000: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { _Internal::set_has_clip(&has_bits); clip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* DetectionOutputParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DetectionOutputParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 num_classes = 1; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_classes(), target); } // optional bool share_location = 2 [default = true]; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_share_location(), target); } // optional int32 background_label_id = 3 [default = 0]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_background_label_id(), target); } // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 4, _Internal::nms_param(this), target, stream); } // optional .opencv_caffe.SaveOutputParameter save_output_param = 5; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 5, _Internal::save_output_param(this), target, stream); } // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 6, this->_internal_code_type(), target); } // optional int32 keep_top_k = 7 [default = -1]; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_keep_top_k(), target); } // optional bool variance_encoded_in_target = 8 [default = false]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_variance_encoded_in_target(), target); } // optional float confidence_threshold = 9; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_confidence_threshold(), target); } // optional bool normalized_bbox = 10 [default = true]; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(10, this->_internal_normalized_bbox(), target); } // optional bool clip = 1000 [default = false]; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1000, this->_internal_clip(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DetectionOutputParameter) return target; } size_t DetectionOutputParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DetectionOutputParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *nms_param_); } // optional .opencv_caffe.SaveOutputParameter save_output_param = 5; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *save_output_param_); } // optional uint32 num_classes = 1; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_classes()); } // optional int32 background_label_id = 3 [default = 0]; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_background_label_id()); } // optional float confidence_threshold = 9; if (cached_has_bits & 0x00000010u) { total_size += 1 + 4; } // optional bool variance_encoded_in_target = 8 [default = false]; if (cached_has_bits & 0x00000020u) { total_size += 1 + 1; } // optional bool clip = 1000 [default = false]; if (cached_has_bits & 0x00000040u) { total_size += 2 + 1; } // optional int32 keep_top_k = 7 [default = -1]; if (cached_has_bits & 0x00000080u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_keep_top_k()); } } if (cached_has_bits & 0x00000700u) { // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; if (cached_has_bits & 0x00000100u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_code_type()); } // optional bool share_location = 2 [default = true]; if (cached_has_bits & 0x00000200u) { total_size += 1 + 1; } // optional bool normalized_bbox = 10 [default = true]; if (cached_has_bits & 0x00000400u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DetectionOutputParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, DetectionOutputParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DetectionOutputParameter::GetClassData() const { return &_class_data_; } void DetectionOutputParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void DetectionOutputParameter::MergeFrom(const DetectionOutputParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DetectionOutputParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_nms_param()->::opencv_caffe::NonMaximumSuppressionParameter::MergeFrom(from._internal_nms_param()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_save_output_param()->::opencv_caffe::SaveOutputParameter::MergeFrom(from._internal_save_output_param()); } if (cached_has_bits & 0x00000004u) { num_classes_ = from.num_classes_; } if (cached_has_bits & 0x00000008u) { background_label_id_ = from.background_label_id_; } if (cached_has_bits & 0x00000010u) { confidence_threshold_ = from.confidence_threshold_; } if (cached_has_bits & 0x00000020u) { variance_encoded_in_target_ = from.variance_encoded_in_target_; } if (cached_has_bits & 0x00000040u) { clip_ = from.clip_; } if (cached_has_bits & 0x00000080u) { keep_top_k_ = from.keep_top_k_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0x00000700u) { if (cached_has_bits & 0x00000100u) { code_type_ = from.code_type_; } if (cached_has_bits & 0x00000200u) { share_location_ = from.share_location_; } if (cached_has_bits & 0x00000400u) { normalized_bbox_ = from.normalized_bbox_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DetectionOutputParameter::CopyFrom(const DetectionOutputParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DetectionOutputParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool DetectionOutputParameter::IsInitialized() const { return true; } void DetectionOutputParameter::InternalSwap(DetectionOutputParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DetectionOutputParameter, clip_) + sizeof(DetectionOutputParameter::clip_) - PROTOBUF_FIELD_OFFSET(DetectionOutputParameter, nms_param_)>( reinterpret_cast(&nms_param_), reinterpret_cast(&other->nms_param_)); swap(keep_top_k_, other->keep_top_k_); swap(code_type_, other->code_type_); swap(share_location_, other->share_location_); swap(normalized_bbox_, other->normalized_bbox_); } ::PROTOBUF_NAMESPACE_ID::Metadata DetectionOutputParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[6]); } // =================================================================== class Datum::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_channels(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_height(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_width(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_data(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_label(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_encoded(HasBits* has_bits) { (*has_bits)[0] |= 32u; } }; Datum::Datum(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), float_data_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.Datum) } Datum::Datum(const Datum& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), float_data_(from.float_data_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_data()) { data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), GetArenaForAllocation()); } ::memcpy(&channels_, &from.channels_, static_cast(reinterpret_cast(&encoded_) - reinterpret_cast(&channels_)) + sizeof(encoded_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.Datum) } inline void Datum::SharedCtor() { data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&channels_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&encoded_) - reinterpret_cast(&channels_)) + sizeof(encoded_)); } Datum::~Datum() { // @@protoc_insertion_point(destructor:opencv_caffe.Datum) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void Datum::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void Datum::ArenaDtor(void* object) { Datum* _this = reinterpret_cast< Datum* >(object); (void)_this; } void Datum::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void Datum::SetCachedSize(int size) const { _cached_size_.Set(size); } void Datum::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.Datum) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; float_data_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { data_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x0000003eu) { ::memset(&channels_, 0, static_cast( reinterpret_cast(&encoded_) - reinterpret_cast(&channels_)) + sizeof(encoded_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* Datum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional int32 channels = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_channels(&has_bits); channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 height = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_height(&has_bits); height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 width = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_width(&has_bits); width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bytes data = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { auto str = _internal_mutable_data(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 label = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_label(&has_bits); label_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated float float_data = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { ptr -= 1; do { ptr += 1; _internal_add_float_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<53>(ptr)); } else if (static_cast(tag) == 50) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_float_data(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional bool encoded = 7 [default = false]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_encoded(&has_bits); encoded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* Datum::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.Datum) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional int32 channels = 1; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_channels(), target); } // optional int32 height = 2; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_height(), target); } // optional int32 width = 3; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_width(), target); } // optional bytes data = 4; if (cached_has_bits & 0x00000001u) { target = stream->WriteBytesMaybeAliased( 4, this->_internal_data(), target); } // optional int32 label = 5; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_label(), target); } // repeated float float_data = 6; for (int i = 0, n = this->_internal_float_data_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_float_data(i), target); } // optional bool encoded = 7 [default = false]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_encoded(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.Datum) return target; } size_t Datum::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.Datum) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated float float_data = 6; { unsigned int count = static_cast(this->_internal_float_data_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_float_data_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000003fu) { // optional bytes data = 4; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_data()); } // optional int32 channels = 1; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_channels()); } // optional int32 height = 2; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_height()); } // optional int32 width = 3; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_width()); } // optional int32 label = 5; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_label()); } // optional bool encoded = 7 [default = false]; if (cached_has_bits & 0x00000020u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Datum::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, Datum::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Datum::GetClassData() const { return &_class_data_; } void Datum::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void Datum::MergeFrom(const Datum& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.Datum) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; float_data_.MergeFrom(from.float_data_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { _internal_set_data(from._internal_data()); } if (cached_has_bits & 0x00000002u) { channels_ = from.channels_; } if (cached_has_bits & 0x00000004u) { height_ = from.height_; } if (cached_has_bits & 0x00000008u) { width_ = from.width_; } if (cached_has_bits & 0x00000010u) { label_ = from.label_; } if (cached_has_bits & 0x00000020u) { encoded_ = from.encoded_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Datum::CopyFrom(const Datum& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.Datum) if (&from == this) return; Clear(); MergeFrom(from); } bool Datum::IsInitialized() const { return true; } void Datum::InternalSwap(Datum* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); float_data_.InternalSwap(&other->float_data_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &data_, lhs_arena, &other->data_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Datum, encoded_) + sizeof(Datum::encoded_) - PROTOBUF_FIELD_OFFSET(Datum, channels_)>( reinterpret_cast(&channels_), reinterpret_cast(&other->channels_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Datum::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[7]); } // =================================================================== class FillerParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_type(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_value(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_min(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_max(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_mean(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_std(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static void set_has_sparse(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_variance_norm(HasBits* has_bits) { (*has_bits)[0] |= 16u; } }; const ::PROTOBUF_NAMESPACE_ID::internal::LazyString FillerParameter::_i_give_permission_to_break_this_code_default_type_{{{"constant", 8}}, {nullptr}}; FillerParameter::FillerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.FillerParameter) } FillerParameter::FillerParameter(const FillerParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); type_.UnsafeSetDefault(nullptr); if (from._internal_has_type()) { type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_type(), GetArenaForAllocation()); } ::memcpy(&value_, &from.value_, static_cast(reinterpret_cast(&std_) - reinterpret_cast(&value_)) + sizeof(std_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.FillerParameter) } inline void FillerParameter::SharedCtor() { type_.UnsafeSetDefault(nullptr); ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&value_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&variance_norm_) - reinterpret_cast(&value_)) + sizeof(variance_norm_)); sparse_ = -1; max_ = 1; std_ = 1; } FillerParameter::~FillerParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.FillerParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void FillerParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); type_.DestroyNoArena(nullptr); } void FillerParameter::ArenaDtor(void* object) { FillerParameter* _this = reinterpret_cast< FillerParameter* >(object); (void)_this; } void FillerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void FillerParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void FillerParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.FillerParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { type_.ClearToDefault(::opencv_caffe::FillerParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation()); } if (cached_has_bits & 0x000000feu) { ::memset(&value_, 0, static_cast( reinterpret_cast(&variance_norm_) - reinterpret_cast(&value_)) + sizeof(variance_norm_)); sparse_ = -1; max_ = 1; std_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* FillerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string type = 1 [default = "constant"]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_type(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.FillerParameter.type"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional float value = 2 [default = 0]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_value(&has_bits); value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float min = 3 [default = 0]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_min(&has_bits); min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float max = 4 [default = 1]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { _Internal::set_has_max(&has_bits); max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float mean = 5 [default = 0]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { _Internal::set_has_mean(&has_bits); mean_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float std = 6 [default = 1]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { _Internal::set_has_std(&has_bits); std_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional int32 sparse = 7 [default = -1]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_sparse(&has_bits); sparse_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::FillerParameter_VarianceNorm_IsValid(val))) { _internal_set_variance_norm(static_cast<::opencv_caffe::FillerParameter_VarianceNorm>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* FillerParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.FillerParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string type = 1 [default = "constant"]; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_type().data(), static_cast(this->_internal_type().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.FillerParameter.type"); target = stream->WriteStringMaybeAliased( 1, this->_internal_type(), target); } // optional float value = 2 [default = 0]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_value(), target); } // optional float min = 3 [default = 0]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_min(), target); } // optional float max = 4 [default = 1]; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_max(), target); } // optional float mean = 5 [default = 0]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_mean(), target); } // optional float std = 6 [default = 1]; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_std(), target); } // optional int32 sparse = 7 [default = -1]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_sparse(), target); } // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 8, this->_internal_variance_norm(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.FillerParameter) return target; } size_t FillerParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.FillerParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional string type = 1 [default = "constant"]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_type()); } // optional float value = 2 [default = 0]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 4; } // optional float min = 3 [default = 0]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } // optional float mean = 5 [default = 0]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 4; } // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; if (cached_has_bits & 0x00000010u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_variance_norm()); } // optional int32 sparse = 7 [default = -1]; if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_sparse()); } // optional float max = 4 [default = 1]; if (cached_has_bits & 0x00000040u) { total_size += 1 + 4; } // optional float std = 6 [default = 1]; if (cached_has_bits & 0x00000080u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FillerParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, FillerParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FillerParameter::GetClassData() const { return &_class_data_; } void FillerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void FillerParameter::MergeFrom(const FillerParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.FillerParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_type(from._internal_type()); } if (cached_has_bits & 0x00000002u) { value_ = from.value_; } if (cached_has_bits & 0x00000004u) { min_ = from.min_; } if (cached_has_bits & 0x00000008u) { mean_ = from.mean_; } if (cached_has_bits & 0x00000010u) { variance_norm_ = from.variance_norm_; } if (cached_has_bits & 0x00000020u) { sparse_ = from.sparse_; } if (cached_has_bits & 0x00000040u) { max_ = from.max_; } if (cached_has_bits & 0x00000080u) { std_ = from.std_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FillerParameter::CopyFrom(const FillerParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.FillerParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool FillerParameter::IsInitialized() const { return true; } void FillerParameter::InternalSwap(FillerParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( nullptr, &type_, lhs_arena, &other->type_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(FillerParameter, variance_norm_) + sizeof(FillerParameter::variance_norm_) - PROTOBUF_FIELD_OFFSET(FillerParameter, value_)>( reinterpret_cast(&value_), reinterpret_cast(&other->value_)); swap(sparse_, other->sparse_); swap(max_, other->max_); swap(std_, other->std_); } ::PROTOBUF_NAMESPACE_ID::Metadata FillerParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[8]); } // =================================================================== class NetParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_name(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_force_backward(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static const ::opencv_caffe::NetState& state(const NetParameter* msg); static void set_has_state(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_debug_info(HasBits* has_bits) { (*has_bits)[0] |= 8u; } }; const ::opencv_caffe::NetState& NetParameter::_Internal::state(const NetParameter* msg) { return *msg->state_; } NetParameter::NetParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), layers_(arena), input_(arena), input_dim_(arena), input_shape_(arena), layer_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.NetParameter) } NetParameter::NetParameter(const NetParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), layers_(from.layers_), input_(from.input_), input_dim_(from.input_dim_), input_shape_(from.input_shape_), layer_(from.layer_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_name()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), GetArenaForAllocation()); } if (from._internal_has_state()) { state_ = new ::opencv_caffe::NetState(*from.state_); } else { state_ = nullptr; } ::memcpy(&force_backward_, &from.force_backward_, static_cast(reinterpret_cast(&debug_info_) - reinterpret_cast(&force_backward_)) + sizeof(debug_info_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetParameter) } inline void NetParameter::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&state_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&debug_info_) - reinterpret_cast(&state_)) + sizeof(debug_info_)); } NetParameter::~NetParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.NetParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void NetParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete state_; } void NetParameter::ArenaDtor(void* object) { NetParameter* _this = reinterpret_cast< NetParameter* >(object); (void)_this; } void NetParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NetParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void NetParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.NetParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; layers_.Clear(); input_.Clear(); input_dim_.Clear(); input_shape_.Clear(); layer_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { name_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(state_ != nullptr); state_->Clear(); } } ::memset(&force_backward_, 0, static_cast( reinterpret_cast(&debug_info_) - reinterpret_cast(&force_backward_)) + sizeof(debug_info_)); _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NetParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetParameter.name"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // repeated .opencv_caffe.V1LayerParameter layers = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_layers(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; // repeated string input = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_input(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetParameter.input"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; // repeated int32 input_dim = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { ptr -= 1; do { ptr += 1; _internal_add_input_dim(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); } else if (static_cast(tag) == 34) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_input_dim(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional bool force_backward = 5 [default = false]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_force_backward(&has_bits); force_backward_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.NetState state = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_state(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool debug_info = 7 [default = false]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_debug_info(&has_bits); debug_info_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated .opencv_caffe.BlobShape input_shape = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_input_shape(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); } else goto handle_unusual; continue; // repeated .opencv_caffe.LayerParameter layer = 100; case 100: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr -= 2; do { ptr += 2; ptr = ctx->ParseMessage(_internal_add_layer(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<802>(ptr)); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* NetParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NetParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string name = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.NetParameter.name"); target = stream->WriteStringMaybeAliased( 1, this->_internal_name(), target); } // repeated .opencv_caffe.V1LayerParameter layers = 2; for (unsigned int i = 0, n = static_cast(this->_internal_layers_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(2, this->_internal_layers(i), target, stream); } // repeated string input = 3; for (int i = 0, n = this->_internal_input_size(); i < n; i++) { const auto& s = this->_internal_input(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.NetParameter.input"); target = stream->WriteString(3, s, target); } // repeated int32 input_dim = 4; for (int i = 0, n = this->_internal_input_dim_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_input_dim(i), target); } // optional bool force_backward = 5 [default = false]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_force_backward(), target); } // optional .opencv_caffe.NetState state = 6; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 6, _Internal::state(this), target, stream); } // optional bool debug_info = 7 [default = false]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_debug_info(), target); } // repeated .opencv_caffe.BlobShape input_shape = 8; for (unsigned int i = 0, n = static_cast(this->_internal_input_shape_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(8, this->_internal_input_shape(i), target, stream); } // repeated .opencv_caffe.LayerParameter layer = 100; for (unsigned int i = 0, n = static_cast(this->_internal_layer_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(100, this->_internal_layer(i), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NetParameter) return target; } size_t NetParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NetParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated .opencv_caffe.V1LayerParameter layers = 2; total_size += 1UL * this->_internal_layers_size(); for (const auto& msg : this->layers_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated string input = 3; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size()); for (int i = 0, n = input_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( input_.Get(i)); } // repeated int32 input_dim = 4; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: Int32Size(this->input_dim_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_input_dim_size()); total_size += data_size; } // repeated .opencv_caffe.BlobShape input_shape = 8; total_size += 1UL * this->_internal_input_shape_size(); for (const auto& msg : this->input_shape_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated .opencv_caffe.LayerParameter layer = 100; total_size += 2UL * this->_internal_layer_size(); for (const auto& msg : this->layer_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000fu) { // optional string name = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // optional .opencv_caffe.NetState state = 6; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *state_); } // optional bool force_backward = 5 [default = false]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 1; } // optional bool debug_info = 7 [default = false]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, NetParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetParameter::GetClassData() const { return &_class_data_; } void NetParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void NetParameter::MergeFrom(const NetParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NetParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; layers_.MergeFrom(from.layers_); input_.MergeFrom(from.input_); input_dim_.MergeFrom(from.input_dim_); input_shape_.MergeFrom(from.input_shape_); layer_.MergeFrom(from.layer_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { _internal_set_name(from._internal_name()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_state()->::opencv_caffe::NetState::MergeFrom(from._internal_state()); } if (cached_has_bits & 0x00000004u) { force_backward_ = from.force_backward_; } if (cached_has_bits & 0x00000008u) { debug_info_ = from.debug_info_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void NetParameter::CopyFrom(const NetParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NetParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool NetParameter::IsInitialized() const { if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(layer_)) return false; return true; } void NetParameter::InternalSwap(NetParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); layers_.InternalSwap(&other->layers_); input_.InternalSwap(&other->input_); input_dim_.InternalSwap(&other->input_dim_); input_shape_.InternalSwap(&other->input_shape_); layer_.InternalSwap(&other->layer_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &name_, lhs_arena, &other->name_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(NetParameter, debug_info_) + sizeof(NetParameter::debug_info_) - PROTOBUF_FIELD_OFFSET(NetParameter, state_)>( reinterpret_cast(&state_), reinterpret_cast(&other->state_)); } ::PROTOBUF_NAMESPACE_ID::Metadata NetParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[9]); } // =================================================================== class SolverParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_net(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static const ::opencv_caffe::NetParameter& net_param(const SolverParameter* msg); static void set_has_net_param(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static void set_has_train_net(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static const ::opencv_caffe::NetParameter& train_net_param(const SolverParameter* msg); static void set_has_train_net_param(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static const ::opencv_caffe::NetState& train_state(const SolverParameter* msg); static void set_has_train_state(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static void set_has_test_interval(HasBits* has_bits) { (*has_bits)[0] |= 512u; } static void set_has_test_compute_loss(HasBits* has_bits) { (*has_bits)[0] |= 1048576u; } static void set_has_test_initialization(HasBits* has_bits) { (*has_bits)[0] |= 134217728u; } static void set_has_base_lr(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } static void set_has_display(HasBits* has_bits) { (*has_bits)[0] |= 2048u; } static void set_has_average_loss(HasBits* has_bits) { (*has_bits)[0] |= 1073741824u; } static void set_has_max_iter(HasBits* has_bits) { (*has_bits)[0] |= 4096u; } static void set_has_iter_size(HasBits* has_bits) { (*has_bits)[1] |= 1u; } static void set_has_lr_policy(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_gamma(HasBits* has_bits) { (*has_bits)[0] |= 8192u; } static void set_has_power(HasBits* has_bits) { (*has_bits)[0] |= 16384u; } static void set_has_momentum(HasBits* has_bits) { (*has_bits)[0] |= 32768u; } static void set_has_weight_decay(HasBits* has_bits) { (*has_bits)[0] |= 65536u; } static void set_has_regularization_type(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_stepsize(HasBits* has_bits) { (*has_bits)[0] |= 131072u; } static void set_has_clip_gradients(HasBits* has_bits) { (*has_bits)[0] |= 2147483648u; } static void set_has_snapshot(HasBits* has_bits) { (*has_bits)[0] |= 262144u; } static void set_has_snapshot_prefix(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_snapshot_diff(HasBits* has_bits) { (*has_bits)[0] |= 2097152u; } static void set_has_snapshot_format(HasBits* has_bits) { (*has_bits)[1] |= 2u; } static void set_has_solver_mode(HasBits* has_bits) { (*has_bits)[0] |= 67108864u; } static void set_has_device_id(HasBits* has_bits) { (*has_bits)[0] |= 524288u; } static void set_has_random_seed(HasBits* has_bits) { (*has_bits)[0] |= 33554432u; } static void set_has_type(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_delta(HasBits* has_bits) { (*has_bits)[0] |= 536870912u; } static void set_has_momentum2(HasBits* has_bits) { (*has_bits)[0] |= 16777216u; } static void set_has_rms_decay(HasBits* has_bits) { (*has_bits)[1] |= 4u; } static void set_has_debug_info(HasBits* has_bits) { (*has_bits)[0] |= 4194304u; } static void set_has_snapshot_after_train(HasBits* has_bits) { (*has_bits)[0] |= 268435456u; } static void set_has_solver_type(HasBits* has_bits) { (*has_bits)[0] |= 8388608u; } }; const ::opencv_caffe::NetParameter& SolverParameter::_Internal::net_param(const SolverParameter* msg) { return *msg->net_param_; } const ::opencv_caffe::NetParameter& SolverParameter::_Internal::train_net_param(const SolverParameter* msg) { return *msg->train_net_param_; } const ::opencv_caffe::NetState& SolverParameter::_Internal::train_state(const SolverParameter* msg) { return *msg->train_state_; } const ::PROTOBUF_NAMESPACE_ID::internal::LazyString SolverParameter::_i_give_permission_to_break_this_code_default_regularization_type_{{{"L2", 2}}, {nullptr}}; const ::PROTOBUF_NAMESPACE_ID::internal::LazyString SolverParameter::_i_give_permission_to_break_this_code_default_type_{{{"SGD", 3}}, {nullptr}}; SolverParameter::SolverParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), test_net_(arena), test_iter_(arena), test_net_param_(arena), test_state_(arena), stepvalue_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.SolverParameter) } SolverParameter::SolverParameter(const SolverParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), test_net_(from.test_net_), test_iter_(from.test_iter_), test_net_param_(from.test_net_param_), test_state_(from.test_state_), stepvalue_(from.stepvalue_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); train_net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING train_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_train_net()) { train_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_train_net(), GetArenaForAllocation()); } lr_policy_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING lr_policy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_lr_policy()) { lr_policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_lr_policy(), GetArenaForAllocation()); } snapshot_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING snapshot_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_snapshot_prefix()) { snapshot_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_snapshot_prefix(), GetArenaForAllocation()); } net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_net()) { net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_net(), GetArenaForAllocation()); } regularization_type_.UnsafeSetDefault(nullptr); if (from._internal_has_regularization_type()) { regularization_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_regularization_type(), GetArenaForAllocation()); } type_.UnsafeSetDefault(nullptr); if (from._internal_has_type()) { type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_type(), GetArenaForAllocation()); } if (from._internal_has_train_net_param()) { train_net_param_ = new ::opencv_caffe::NetParameter(*from.train_net_param_); } else { train_net_param_ = nullptr; } if (from._internal_has_net_param()) { net_param_ = new ::opencv_caffe::NetParameter(*from.net_param_); } else { net_param_ = nullptr; } if (from._internal_has_train_state()) { train_state_ = new ::opencv_caffe::NetState(*from.train_state_); } else { train_state_ = nullptr; } ::memcpy(&test_interval_, &from.test_interval_, static_cast(reinterpret_cast(&rms_decay_) - reinterpret_cast(&test_interval_)) + sizeof(rms_decay_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.SolverParameter) } inline void SolverParameter::SharedCtor() { train_net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING train_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING lr_policy_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING lr_policy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING snapshot_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING snapshot_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING regularization_type_.UnsafeSetDefault(nullptr); type_.UnsafeSetDefault(nullptr); ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&train_net_param_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&solver_type_) - reinterpret_cast(&train_net_param_)) + sizeof(solver_type_)); momentum2_ = 0.999f; random_seed_ = int64_t{-1}; solver_mode_ = 1; test_initialization_ = true; snapshot_after_train_ = true; delta_ = 1e-08f; average_loss_ = 1; clip_gradients_ = -1; iter_size_ = 1; snapshot_format_ = 1; rms_decay_ = 0.99f; } SolverParameter::~SolverParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.SolverParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void SolverParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); train_net_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); lr_policy_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); snapshot_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); net_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); regularization_type_.DestroyNoArena(nullptr); type_.DestroyNoArena(nullptr); if (this != internal_default_instance()) delete train_net_param_; if (this != internal_default_instance()) delete net_param_; if (this != internal_default_instance()) delete train_state_; } void SolverParameter::ArenaDtor(void* object) { SolverParameter* _this = reinterpret_cast< SolverParameter* >(object); (void)_this; } void SolverParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SolverParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void SolverParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.SolverParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; test_net_.Clear(); test_iter_.Clear(); test_net_param_.Clear(); test_state_.Clear(); stepvalue_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { train_net_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { lr_policy_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000004u) { snapshot_prefix_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000008u) { net_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000010u) { regularization_type_.ClearToDefault(::opencv_caffe::SolverParameter::_i_give_permission_to_break_this_code_default_regularization_type_, GetArenaForAllocation()); } if (cached_has_bits & 0x00000020u) { type_.ClearToDefault(::opencv_caffe::SolverParameter::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation()); } if (cached_has_bits & 0x00000040u) { GOOGLE_DCHECK(train_net_param_ != nullptr); train_net_param_->Clear(); } if (cached_has_bits & 0x00000080u) { GOOGLE_DCHECK(net_param_ != nullptr); net_param_->Clear(); } } if (cached_has_bits & 0x00000100u) { GOOGLE_DCHECK(train_state_ != nullptr); train_state_->Clear(); } if (cached_has_bits & 0x0000fe00u) { ::memset(&test_interval_, 0, static_cast( reinterpret_cast(&momentum_) - reinterpret_cast(&test_interval_)) + sizeof(momentum_)); } if (cached_has_bits & 0x00ff0000u) { ::memset(&weight_decay_, 0, static_cast( reinterpret_cast(&solver_type_) - reinterpret_cast(&weight_decay_)) + sizeof(solver_type_)); } if (cached_has_bits & 0xff000000u) { momentum2_ = 0.999f; random_seed_ = int64_t{-1}; solver_mode_ = 1; test_initialization_ = true; snapshot_after_train_ = true; delta_ = 1e-08f; average_loss_ = 1; clip_gradients_ = -1; } cached_has_bits = _has_bits_[1]; if (cached_has_bits & 0x00000007u) { iter_size_ = 1; snapshot_format_ = 1; rms_decay_ = 0.99f; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SolverParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string train_net = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_train_net(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.train_net"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // repeated string test_net = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_test_net(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.test_net"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; // repeated int32 test_iter = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { ptr -= 1; do { ptr += 1; _internal_add_test_iter(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); } else if (static_cast(tag) == 26) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_test_iter(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 test_interval = 4 [default = 0]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_test_interval(&_has_bits_); test_interval_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float base_lr = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { _Internal::set_has_base_lr(&_has_bits_); base_lr_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional int32 display = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_display(&_has_bits_); display_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 max_iter = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_max_iter(&_has_bits_); max_iter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string lr_policy = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { auto str = _internal_mutable_lr_policy(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.lr_policy"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional float gamma = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 77)) { _Internal::set_has_gamma(&_has_bits_); gamma_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float power = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 85)) { _Internal::set_has_power(&_has_bits_); power_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float momentum = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 93)) { _Internal::set_has_momentum(&_has_bits_); momentum_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float weight_decay = 12; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 101)) { _Internal::set_has_weight_decay(&_has_bits_); weight_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional int32 stepsize = 13; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { _Internal::set_has_stepsize(&_has_bits_); stepsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 snapshot = 14 [default = 0]; case 14: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { _Internal::set_has_snapshot(&_has_bits_); snapshot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string snapshot_prefix = 15; case 15: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { auto str = _internal_mutable_snapshot_prefix(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.snapshot_prefix"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional bool snapshot_diff = 16 [default = false]; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { _Internal::set_has_snapshot_diff(&_has_bits_); snapshot_diff_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; case 17: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SolverParameter_SolverMode_IsValid(val))) { _internal_set_solver_mode(static_cast<::opencv_caffe::SolverParameter_SolverMode>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(17, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional int32 device_id = 18 [default = 0]; case 18: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { _Internal::set_has_device_id(&_has_bits_); device_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool test_compute_loss = 19 [default = false]; case 19: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { _Internal::set_has_test_compute_loss(&_has_bits_); test_compute_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int64 random_seed = 20 [default = -1]; case 20: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { _Internal::set_has_random_seed(&_has_bits_); random_seed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.NetParameter train_net_param = 21; case 21: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_train_net_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated .opencv_caffe.NetParameter test_net_param = 22; case 22: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { ptr -= 2; do { ptr += 2; ptr = ctx->ParseMessage(_internal_add_test_net_param(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<178>(ptr)); } else goto handle_unusual; continue; // optional bool debug_info = 23 [default = false]; case 23: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { _Internal::set_has_debug_info(&_has_bits_); debug_info_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string net = 24; case 24: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { auto str = _internal_mutable_net(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.net"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.NetParameter net_param = 25; case 25: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_net_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.NetState train_state = 26; case 26: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { ptr = ctx->ParseMessage(_internal_mutable_train_state(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated .opencv_caffe.NetState test_state = 27; case 27: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { ptr -= 2; do { ptr += 2; ptr = ctx->ParseMessage(_internal_add_test_state(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<218>(ptr)); } else goto handle_unusual; continue; // optional bool snapshot_after_train = 28 [default = true]; case 28: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 224)) { _Internal::set_has_snapshot_after_train(&_has_bits_); snapshot_after_train_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string regularization_type = 29 [default = "L2"]; case 29: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { auto str = _internal_mutable_regularization_type(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.regularization_type"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; case 30: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SolverParameter_SolverType_IsValid(val))) { _internal_set_solver_type(static_cast<::opencv_caffe::SolverParameter_SolverType>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(30, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional float delta = 31 [default = 1e-08]; case 31: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 253)) { _Internal::set_has_delta(&_has_bits_); delta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional bool test_initialization = 32 [default = true]; case 32: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 0)) { _Internal::set_has_test_initialization(&_has_bits_); test_initialization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 average_loss = 33 [default = 1]; case 33: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_average_loss(&_has_bits_); average_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated int32 stepvalue = 34; case 34: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { ptr -= 2; do { ptr += 2; _internal_add_stepvalue(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<272>(ptr)); } else if (static_cast(tag) == 18) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_stepvalue(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional float clip_gradients = 35 [default = -1]; case 35: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_clip_gradients(&_has_bits_); clip_gradients_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional int32 iter_size = 36 [default = 1]; case 36: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_iter_size(&_has_bits_); iter_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; case 37: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SolverParameter_SnapshotFormat_IsValid(val))) { _internal_set_snapshot_format(static_cast<::opencv_caffe::SolverParameter_SnapshotFormat>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(37, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional float rms_decay = 38 [default = 0.99]; case 38: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { _Internal::set_has_rms_decay(&_has_bits_); rms_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float momentum2 = 39 [default = 0.999]; case 39: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { _Internal::set_has_momentum2(&_has_bits_); momentum2_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional string type = 40 [default = "SGD"]; case 40: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { auto str = _internal_mutable_type(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverParameter.type"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* SolverParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SolverParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string train_net = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_train_net().data(), static_cast(this->_internal_train_net().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SolverParameter.train_net"); target = stream->WriteStringMaybeAliased( 1, this->_internal_train_net(), target); } // repeated string test_net = 2; for (int i = 0, n = this->_internal_test_net_size(); i < n; i++) { const auto& s = this->_internal_test_net(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SolverParameter.test_net"); target = stream->WriteString(2, s, target); } // repeated int32 test_iter = 3; for (int i = 0, n = this->_internal_test_iter_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_test_iter(i), target); } // optional int32 test_interval = 4 [default = 0]; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_test_interval(), target); } // optional float base_lr = 5; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_base_lr(), target); } // optional int32 display = 6; if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_display(), target); } // optional int32 max_iter = 7; if (cached_has_bits & 0x00001000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_max_iter(), target); } // optional string lr_policy = 8; if (cached_has_bits & 0x00000002u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_lr_policy().data(), static_cast(this->_internal_lr_policy().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SolverParameter.lr_policy"); target = stream->WriteStringMaybeAliased( 8, this->_internal_lr_policy(), target); } // optional float gamma = 9; if (cached_has_bits & 0x00002000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_gamma(), target); } // optional float power = 10; if (cached_has_bits & 0x00004000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_power(), target); } // optional float momentum = 11; if (cached_has_bits & 0x00008000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(11, this->_internal_momentum(), target); } // optional float weight_decay = 12; if (cached_has_bits & 0x00010000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(12, this->_internal_weight_decay(), target); } // optional int32 stepsize = 13; if (cached_has_bits & 0x00020000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(13, this->_internal_stepsize(), target); } // optional int32 snapshot = 14 [default = 0]; if (cached_has_bits & 0x00040000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(14, this->_internal_snapshot(), target); } // optional string snapshot_prefix = 15; if (cached_has_bits & 0x00000004u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_snapshot_prefix().data(), static_cast(this->_internal_snapshot_prefix().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SolverParameter.snapshot_prefix"); target = stream->WriteStringMaybeAliased( 15, this->_internal_snapshot_prefix(), target); } // optional bool snapshot_diff = 16 [default = false]; if (cached_has_bits & 0x00200000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(16, this->_internal_snapshot_diff(), target); } // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; if (cached_has_bits & 0x04000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 17, this->_internal_solver_mode(), target); } // optional int32 device_id = 18 [default = 0]; if (cached_has_bits & 0x00080000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(18, this->_internal_device_id(), target); } // optional bool test_compute_loss = 19 [default = false]; if (cached_has_bits & 0x00100000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(19, this->_internal_test_compute_loss(), target); } // optional int64 random_seed = 20 [default = -1]; if (cached_has_bits & 0x02000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(20, this->_internal_random_seed(), target); } // optional .opencv_caffe.NetParameter train_net_param = 21; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 21, _Internal::train_net_param(this), target, stream); } // repeated .opencv_caffe.NetParameter test_net_param = 22; for (unsigned int i = 0, n = static_cast(this->_internal_test_net_param_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(22, this->_internal_test_net_param(i), target, stream); } // optional bool debug_info = 23 [default = false]; if (cached_has_bits & 0x00400000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(23, this->_internal_debug_info(), target); } // optional string net = 24; if (cached_has_bits & 0x00000008u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_net().data(), static_cast(this->_internal_net().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SolverParameter.net"); target = stream->WriteStringMaybeAliased( 24, this->_internal_net(), target); } // optional .opencv_caffe.NetParameter net_param = 25; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 25, _Internal::net_param(this), target, stream); } // optional .opencv_caffe.NetState train_state = 26; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 26, _Internal::train_state(this), target, stream); } // repeated .opencv_caffe.NetState test_state = 27; for (unsigned int i = 0, n = static_cast(this->_internal_test_state_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(27, this->_internal_test_state(i), target, stream); } // optional bool snapshot_after_train = 28 [default = true]; if (cached_has_bits & 0x10000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(28, this->_internal_snapshot_after_train(), target); } // optional string regularization_type = 29 [default = "L2"]; if (cached_has_bits & 0x00000010u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_regularization_type().data(), static_cast(this->_internal_regularization_type().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SolverParameter.regularization_type"); target = stream->WriteStringMaybeAliased( 29, this->_internal_regularization_type(), target); } // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; if (cached_has_bits & 0x00800000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 30, this->_internal_solver_type(), target); } // optional float delta = 31 [default = 1e-08]; if (cached_has_bits & 0x20000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(31, this->_internal_delta(), target); } // optional bool test_initialization = 32 [default = true]; if (cached_has_bits & 0x08000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(32, this->_internal_test_initialization(), target); } // optional int32 average_loss = 33 [default = 1]; if (cached_has_bits & 0x40000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(33, this->_internal_average_loss(), target); } // repeated int32 stepvalue = 34; for (int i = 0, n = this->_internal_stepvalue_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(34, this->_internal_stepvalue(i), target); } // optional float clip_gradients = 35 [default = -1]; if (cached_has_bits & 0x80000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(35, this->_internal_clip_gradients(), target); } cached_has_bits = _has_bits_[1]; // optional int32 iter_size = 36 [default = 1]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(36, this->_internal_iter_size(), target); } // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 37, this->_internal_snapshot_format(), target); } // optional float rms_decay = 38 [default = 0.99]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(38, this->_internal_rms_decay(), target); } cached_has_bits = _has_bits_[0]; // optional float momentum2 = 39 [default = 0.999]; if (cached_has_bits & 0x01000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(39, this->_internal_momentum2(), target); } // optional string type = 40 [default = "SGD"]; if (cached_has_bits & 0x00000020u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_type().data(), static_cast(this->_internal_type().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SolverParameter.type"); target = stream->WriteStringMaybeAliased( 40, this->_internal_type(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SolverParameter) return target; } size_t SolverParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SolverParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string test_net = 2; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(test_net_.size()); for (int i = 0, n = test_net_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( test_net_.Get(i)); } // repeated int32 test_iter = 3; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: Int32Size(this->test_iter_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_test_iter_size()); total_size += data_size; } // repeated .opencv_caffe.NetParameter test_net_param = 22; total_size += 2UL * this->_internal_test_net_param_size(); for (const auto& msg : this->test_net_param_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated .opencv_caffe.NetState test_state = 27; total_size += 2UL * this->_internal_test_state_size(); for (const auto& msg : this->test_state_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated int32 stepvalue = 34; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: Int32Size(this->stepvalue_); total_size += 2 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_stepvalue_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional string train_net = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_train_net()); } // optional string lr_policy = 8; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_lr_policy()); } // optional string snapshot_prefix = 15; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_snapshot_prefix()); } // optional string net = 24; if (cached_has_bits & 0x00000008u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_net()); } // optional string regularization_type = 29 [default = "L2"]; if (cached_has_bits & 0x00000010u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_regularization_type()); } // optional string type = 40 [default = "SGD"]; if (cached_has_bits & 0x00000020u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_type()); } // optional .opencv_caffe.NetParameter train_net_param = 21; if (cached_has_bits & 0x00000040u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *train_net_param_); } // optional .opencv_caffe.NetParameter net_param = 25; if (cached_has_bits & 0x00000080u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *net_param_); } } if (cached_has_bits & 0x0000ff00u) { // optional .opencv_caffe.NetState train_state = 26; if (cached_has_bits & 0x00000100u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *train_state_); } // optional int32 test_interval = 4 [default = 0]; if (cached_has_bits & 0x00000200u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_test_interval()); } // optional float base_lr = 5; if (cached_has_bits & 0x00000400u) { total_size += 1 + 4; } // optional int32 display = 6; if (cached_has_bits & 0x00000800u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_display()); } // optional int32 max_iter = 7; if (cached_has_bits & 0x00001000u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_max_iter()); } // optional float gamma = 9; if (cached_has_bits & 0x00002000u) { total_size += 1 + 4; } // optional float power = 10; if (cached_has_bits & 0x00004000u) { total_size += 1 + 4; } // optional float momentum = 11; if (cached_has_bits & 0x00008000u) { total_size += 1 + 4; } } if (cached_has_bits & 0x00ff0000u) { // optional float weight_decay = 12; if (cached_has_bits & 0x00010000u) { total_size += 1 + 4; } // optional int32 stepsize = 13; if (cached_has_bits & 0x00020000u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_stepsize()); } // optional int32 snapshot = 14 [default = 0]; if (cached_has_bits & 0x00040000u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_snapshot()); } // optional int32 device_id = 18 [default = 0]; if (cached_has_bits & 0x00080000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( this->_internal_device_id()); } // optional bool test_compute_loss = 19 [default = false]; if (cached_has_bits & 0x00100000u) { total_size += 2 + 1; } // optional bool snapshot_diff = 16 [default = false]; if (cached_has_bits & 0x00200000u) { total_size += 2 + 1; } // optional bool debug_info = 23 [default = false]; if (cached_has_bits & 0x00400000u) { total_size += 2 + 1; } // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; if (cached_has_bits & 0x00800000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_solver_type()); } } if (cached_has_bits & 0xff000000u) { // optional float momentum2 = 39 [default = 0.999]; if (cached_has_bits & 0x01000000u) { total_size += 2 + 4; } // optional int64 random_seed = 20 [default = -1]; if (cached_has_bits & 0x02000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( this->_internal_random_seed()); } // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; if (cached_has_bits & 0x04000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_solver_mode()); } // optional bool test_initialization = 32 [default = true]; if (cached_has_bits & 0x08000000u) { total_size += 2 + 1; } // optional bool snapshot_after_train = 28 [default = true]; if (cached_has_bits & 0x10000000u) { total_size += 2 + 1; } // optional float delta = 31 [default = 1e-08]; if (cached_has_bits & 0x20000000u) { total_size += 2 + 4; } // optional int32 average_loss = 33 [default = 1]; if (cached_has_bits & 0x40000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( this->_internal_average_loss()); } // optional float clip_gradients = 35 [default = -1]; if (cached_has_bits & 0x80000000u) { total_size += 2 + 4; } } cached_has_bits = _has_bits_[1]; if (cached_has_bits & 0x00000007u) { // optional int32 iter_size = 36 [default = 1]; if (cached_has_bits & 0x00000001u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( this->_internal_iter_size()); } // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; if (cached_has_bits & 0x00000002u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_snapshot_format()); } // optional float rms_decay = 38 [default = 0.99]; if (cached_has_bits & 0x00000004u) { total_size += 2 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SolverParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, SolverParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SolverParameter::GetClassData() const { return &_class_data_; } void SolverParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void SolverParameter::MergeFrom(const SolverParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SolverParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; test_net_.MergeFrom(from.test_net_); test_iter_.MergeFrom(from.test_iter_); test_net_param_.MergeFrom(from.test_net_param_); test_state_.MergeFrom(from.test_state_); stepvalue_.MergeFrom(from.stepvalue_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_train_net(from._internal_train_net()); } if (cached_has_bits & 0x00000002u) { _internal_set_lr_policy(from._internal_lr_policy()); } if (cached_has_bits & 0x00000004u) { _internal_set_snapshot_prefix(from._internal_snapshot_prefix()); } if (cached_has_bits & 0x00000008u) { _internal_set_net(from._internal_net()); } if (cached_has_bits & 0x00000010u) { _internal_set_regularization_type(from._internal_regularization_type()); } if (cached_has_bits & 0x00000020u) { _internal_set_type(from._internal_type()); } if (cached_has_bits & 0x00000040u) { _internal_mutable_train_net_param()->::opencv_caffe::NetParameter::MergeFrom(from._internal_train_net_param()); } if (cached_has_bits & 0x00000080u) { _internal_mutable_net_param()->::opencv_caffe::NetParameter::MergeFrom(from._internal_net_param()); } } if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { _internal_mutable_train_state()->::opencv_caffe::NetState::MergeFrom(from._internal_train_state()); } if (cached_has_bits & 0x00000200u) { test_interval_ = from.test_interval_; } if (cached_has_bits & 0x00000400u) { base_lr_ = from.base_lr_; } if (cached_has_bits & 0x00000800u) { display_ = from.display_; } if (cached_has_bits & 0x00001000u) { max_iter_ = from.max_iter_; } if (cached_has_bits & 0x00002000u) { gamma_ = from.gamma_; } if (cached_has_bits & 0x00004000u) { power_ = from.power_; } if (cached_has_bits & 0x00008000u) { momentum_ = from.momentum_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0x00ff0000u) { if (cached_has_bits & 0x00010000u) { weight_decay_ = from.weight_decay_; } if (cached_has_bits & 0x00020000u) { stepsize_ = from.stepsize_; } if (cached_has_bits & 0x00040000u) { snapshot_ = from.snapshot_; } if (cached_has_bits & 0x00080000u) { device_id_ = from.device_id_; } if (cached_has_bits & 0x00100000u) { test_compute_loss_ = from.test_compute_loss_; } if (cached_has_bits & 0x00200000u) { snapshot_diff_ = from.snapshot_diff_; } if (cached_has_bits & 0x00400000u) { debug_info_ = from.debug_info_; } if (cached_has_bits & 0x00800000u) { solver_type_ = from.solver_type_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0xff000000u) { if (cached_has_bits & 0x01000000u) { momentum2_ = from.momentum2_; } if (cached_has_bits & 0x02000000u) { random_seed_ = from.random_seed_; } if (cached_has_bits & 0x04000000u) { solver_mode_ = from.solver_mode_; } if (cached_has_bits & 0x08000000u) { test_initialization_ = from.test_initialization_; } if (cached_has_bits & 0x10000000u) { snapshot_after_train_ = from.snapshot_after_train_; } if (cached_has_bits & 0x20000000u) { delta_ = from.delta_; } if (cached_has_bits & 0x40000000u) { average_loss_ = from.average_loss_; } if (cached_has_bits & 0x80000000u) { clip_gradients_ = from.clip_gradients_; } _has_bits_[0] |= cached_has_bits; } cached_has_bits = from._has_bits_[1]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { iter_size_ = from.iter_size_; } if (cached_has_bits & 0x00000002u) { snapshot_format_ = from.snapshot_format_; } if (cached_has_bits & 0x00000004u) { rms_decay_ = from.rms_decay_; } _has_bits_[1] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SolverParameter::CopyFrom(const SolverParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SolverParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool SolverParameter::IsInitialized() const { if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(test_net_param_)) return false; if (_internal_has_train_net_param()) { if (!train_net_param_->IsInitialized()) return false; } if (_internal_has_net_param()) { if (!net_param_->IsInitialized()) return false; } return true; } void SolverParameter::InternalSwap(SolverParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(_has_bits_[1], other->_has_bits_[1]); test_net_.InternalSwap(&other->test_net_); test_iter_.InternalSwap(&other->test_iter_); test_net_param_.InternalSwap(&other->test_net_param_); test_state_.InternalSwap(&other->test_state_); stepvalue_.InternalSwap(&other->stepvalue_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &train_net_, lhs_arena, &other->train_net_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &lr_policy_, lhs_arena, &other->lr_policy_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &snapshot_prefix_, lhs_arena, &other->snapshot_prefix_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &net_, lhs_arena, &other->net_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( nullptr, ®ularization_type_, lhs_arena, &other->regularization_type_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( nullptr, &type_, lhs_arena, &other->type_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SolverParameter, solver_type_) + sizeof(SolverParameter::solver_type_) - PROTOBUF_FIELD_OFFSET(SolverParameter, train_net_param_)>( reinterpret_cast(&train_net_param_), reinterpret_cast(&other->train_net_param_)); swap(momentum2_, other->momentum2_); swap(random_seed_, other->random_seed_); swap(solver_mode_, other->solver_mode_); swap(test_initialization_, other->test_initialization_); swap(snapshot_after_train_, other->snapshot_after_train_); swap(delta_, other->delta_); swap(average_loss_, other->average_loss_); swap(clip_gradients_, other->clip_gradients_); swap(iter_size_, other->iter_size_); swap(snapshot_format_, other->snapshot_format_); swap(rms_decay_, other->rms_decay_); } ::PROTOBUF_NAMESPACE_ID::Metadata SolverParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[10]); } // =================================================================== class SolverState::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_iter(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_learned_net(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_current_step(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; SolverState::SolverState(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), history_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.SolverState) } SolverState::SolverState(const SolverState& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), history_(from.history_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); learned_net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING learned_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_learned_net()) { learned_net_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_learned_net(), GetArenaForAllocation()); } ::memcpy(&iter_, &from.iter_, static_cast(reinterpret_cast(¤t_step_) - reinterpret_cast(&iter_)) + sizeof(current_step_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.SolverState) } inline void SolverState::SharedCtor() { learned_net_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING learned_net_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&iter_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(¤t_step_) - reinterpret_cast(&iter_)) + sizeof(current_step_)); } SolverState::~SolverState() { // @@protoc_insertion_point(destructor:opencv_caffe.SolverState) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void SolverState::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); learned_net_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SolverState::ArenaDtor(void* object) { SolverState* _this = reinterpret_cast< SolverState* >(object); (void)_this; } void SolverState::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SolverState::SetCachedSize(int size) const { _cached_size_.Set(size); } void SolverState::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.SolverState) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; history_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { learned_net_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000006u) { ::memset(&iter_, 0, static_cast( reinterpret_cast(¤t_step_) - reinterpret_cast(&iter_)) + sizeof(current_step_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SolverState::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional int32 iter = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_iter(&has_bits); iter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string learned_net = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_learned_net(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SolverState.learned_net"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // repeated .opencv_caffe.BlobProto history = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_history(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; // optional int32 current_step = 4 [default = 0]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_current_step(&has_bits); current_step_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* SolverState::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SolverState) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional int32 iter = 1; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_iter(), target); } // optional string learned_net = 2; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_learned_net().data(), static_cast(this->_internal_learned_net().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SolverState.learned_net"); target = stream->WriteStringMaybeAliased( 2, this->_internal_learned_net(), target); } // repeated .opencv_caffe.BlobProto history = 3; for (unsigned int i = 0, n = static_cast(this->_internal_history_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(3, this->_internal_history(i), target, stream); } // optional int32 current_step = 4 [default = 0]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_current_step(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SolverState) return target; } size_t SolverState::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SolverState) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated .opencv_caffe.BlobProto history = 3; total_size += 1UL * this->_internal_history_size(); for (const auto& msg : this->history_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional string learned_net = 2; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_learned_net()); } // optional int32 iter = 1; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_iter()); } // optional int32 current_step = 4 [default = 0]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_current_step()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SolverState::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, SolverState::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SolverState::GetClassData() const { return &_class_data_; } void SolverState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void SolverState::MergeFrom(const SolverState& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SolverState) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; history_.MergeFrom(from.history_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { _internal_set_learned_net(from._internal_learned_net()); } if (cached_has_bits & 0x00000002u) { iter_ = from.iter_; } if (cached_has_bits & 0x00000004u) { current_step_ = from.current_step_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SolverState::CopyFrom(const SolverState& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SolverState) if (&from == this) return; Clear(); MergeFrom(from); } bool SolverState::IsInitialized() const { return true; } void SolverState::InternalSwap(SolverState* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); history_.InternalSwap(&other->history_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &learned_net_, lhs_arena, &other->learned_net_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SolverState, current_step_) + sizeof(SolverState::current_step_) - PROTOBUF_FIELD_OFFSET(SolverState, iter_)>( reinterpret_cast(&iter_), reinterpret_cast(&other->iter_)); } ::PROTOBUF_NAMESPACE_ID::Metadata SolverState::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[11]); } // =================================================================== class NetState::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_phase(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_level(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; NetState::NetState(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), stage_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.NetState) } NetState::NetState(const NetState& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), stage_(from.stage_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&level_, &from.level_, static_cast(reinterpret_cast(&phase_) - reinterpret_cast(&level_)) + sizeof(phase_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetState) } inline void NetState::SharedCtor() { level_ = 0; phase_ = 1; } NetState::~NetState() { // @@protoc_insertion_point(destructor:opencv_caffe.NetState) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void NetState::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void NetState::ArenaDtor(void* object) { NetState* _this = reinterpret_cast< NetState* >(object); (void)_this; } void NetState::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NetState::SetCachedSize(int size) const { _cached_size_.Set(size); } void NetState::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.NetState) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; stage_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { level_ = 0; phase_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NetState::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.Phase phase = 1 [default = TEST]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::Phase_IsValid(val))) { _internal_set_phase(static_cast<::opencv_caffe::Phase>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional int32 level = 2 [default = 0]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_level(&has_bits); level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated string stage = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_stage(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetState.stage"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* NetState::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NetState) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.Phase phase = 1 [default = TEST]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_phase(), target); } // optional int32 level = 2 [default = 0]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_level(), target); } // repeated string stage = 3; for (int i = 0, n = this->_internal_stage_size(); i < n; i++) { const auto& s = this->_internal_stage(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.NetState.stage"); target = stream->WriteString(3, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NetState) return target; } size_t NetState::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NetState) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string stage = 3; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(stage_.size()); for (int i = 0, n = stage_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( stage_.Get(i)); } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional int32 level = 2 [default = 0]; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_level()); } // optional .opencv_caffe.Phase phase = 1 [default = TEST]; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetState::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, NetState::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetState::GetClassData() const { return &_class_data_; } void NetState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void NetState::MergeFrom(const NetState& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NetState) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; stage_.MergeFrom(from.stage_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { level_ = from.level_; } if (cached_has_bits & 0x00000002u) { phase_ = from.phase_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void NetState::CopyFrom(const NetState& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NetState) if (&from == this) return; Clear(); MergeFrom(from); } bool NetState::IsInitialized() const { return true; } void NetState::InternalSwap(NetState* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); stage_.InternalSwap(&other->stage_); swap(level_, other->level_); swap(phase_, other->phase_); } ::PROTOBUF_NAMESPACE_ID::Metadata NetState::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[12]); } // =================================================================== class NetStateRule::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_phase(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_min_level(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_max_level(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; NetStateRule::NetStateRule(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), stage_(arena), not_stage_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.NetStateRule) } NetStateRule::NetStateRule(const NetStateRule& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), stage_(from.stage_), not_stage_(from.not_stage_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&phase_, &from.phase_, static_cast(reinterpret_cast(&max_level_) - reinterpret_cast(&phase_)) + sizeof(max_level_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetStateRule) } inline void NetStateRule::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&phase_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&max_level_) - reinterpret_cast(&phase_)) + sizeof(max_level_)); } NetStateRule::~NetStateRule() { // @@protoc_insertion_point(destructor:opencv_caffe.NetStateRule) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void NetStateRule::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void NetStateRule::ArenaDtor(void* object) { NetStateRule* _this = reinterpret_cast< NetStateRule* >(object); (void)_this; } void NetStateRule::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NetStateRule::SetCachedSize(int size) const { _cached_size_.Set(size); } void NetStateRule::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.NetStateRule) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; stage_.Clear(); not_stage_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { ::memset(&phase_, 0, static_cast( reinterpret_cast(&max_level_) - reinterpret_cast(&phase_)) + sizeof(max_level_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NetStateRule::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.Phase phase = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::Phase_IsValid(val))) { _internal_set_phase(static_cast<::opencv_caffe::Phase>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional int32 min_level = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_min_level(&has_bits); min_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 max_level = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_max_level(&has_bits); max_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated string stage = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_stage(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetStateRule.stage"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); } else goto handle_unusual; continue; // repeated string not_stage = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_not_stage(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.NetStateRule.not_stage"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* NetStateRule::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NetStateRule) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.Phase phase = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_phase(), target); } // optional int32 min_level = 2; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_min_level(), target); } // optional int32 max_level = 3; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_max_level(), target); } // repeated string stage = 4; for (int i = 0, n = this->_internal_stage_size(); i < n; i++) { const auto& s = this->_internal_stage(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.NetStateRule.stage"); target = stream->WriteString(4, s, target); } // repeated string not_stage = 5; for (int i = 0, n = this->_internal_not_stage_size(); i < n; i++) { const auto& s = this->_internal_not_stage(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.NetStateRule.not_stage"); target = stream->WriteString(5, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NetStateRule) return target; } size_t NetStateRule::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NetStateRule) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string stage = 4; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(stage_.size()); for (int i = 0, n = stage_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( stage_.Get(i)); } // repeated string not_stage = 5; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(not_stage_.size()); for (int i = 0, n = not_stage_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( not_stage_.Get(i)); } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional .opencv_caffe.Phase phase = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); } // optional int32 min_level = 2; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_min_level()); } // optional int32 max_level = 3; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_max_level()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetStateRule::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, NetStateRule::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetStateRule::GetClassData() const { return &_class_data_; } void NetStateRule::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void NetStateRule::MergeFrom(const NetStateRule& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NetStateRule) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; stage_.MergeFrom(from.stage_); not_stage_.MergeFrom(from.not_stage_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { phase_ = from.phase_; } if (cached_has_bits & 0x00000002u) { min_level_ = from.min_level_; } if (cached_has_bits & 0x00000004u) { max_level_ = from.max_level_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void NetStateRule::CopyFrom(const NetStateRule& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NetStateRule) if (&from == this) return; Clear(); MergeFrom(from); } bool NetStateRule::IsInitialized() const { return true; } void NetStateRule::InternalSwap(NetStateRule* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); stage_.InternalSwap(&other->stage_); not_stage_.InternalSwap(&other->not_stage_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(NetStateRule, max_level_) + sizeof(NetStateRule::max_level_) - PROTOBUF_FIELD_OFFSET(NetStateRule, phase_)>( reinterpret_cast(&phase_), reinterpret_cast(&other->phase_)); } ::PROTOBUF_NAMESPACE_ID::Metadata NetStateRule::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[13]); } // =================================================================== class ParamSpec::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_name(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_share_mode(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_lr_mult(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_decay_mult(HasBits* has_bits) { (*has_bits)[0] |= 8u; } }; ParamSpec::ParamSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ParamSpec) } ParamSpec::ParamSpec(const ParamSpec& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_name()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), GetArenaForAllocation()); } ::memcpy(&share_mode_, &from.share_mode_, static_cast(reinterpret_cast(&decay_mult_) - reinterpret_cast(&share_mode_)) + sizeof(decay_mult_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ParamSpec) } inline void ParamSpec::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING share_mode_ = 0; lr_mult_ = 1; decay_mult_ = 1; } ParamSpec::~ParamSpec() { // @@protoc_insertion_point(destructor:opencv_caffe.ParamSpec) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ParamSpec::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void ParamSpec::ArenaDtor(void* object) { ParamSpec* _this = reinterpret_cast< ParamSpec* >(object); (void)_this; } void ParamSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ParamSpec::SetCachedSize(int size) const { _cached_size_.Set(size); } void ParamSpec::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ParamSpec) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { name_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x0000000eu) { share_mode_ = 0; lr_mult_ = 1; decay_mult_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ParamSpec::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.ParamSpec.name"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::ParamSpec_DimCheckMode_IsValid(val))) { _internal_set_share_mode(static_cast<::opencv_caffe::ParamSpec_DimCheckMode>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional float lr_mult = 3 [default = 1]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_lr_mult(&has_bits); lr_mult_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float decay_mult = 4 [default = 1]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { _Internal::set_has_decay_mult(&has_bits); decay_mult_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ParamSpec::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ParamSpec) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string name = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.ParamSpec.name"); target = stream->WriteStringMaybeAliased( 1, this->_internal_name(), target); } // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_share_mode(), target); } // optional float lr_mult = 3 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_lr_mult(), target); } // optional float decay_mult = 4 [default = 1]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_decay_mult(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ParamSpec) return target; } size_t ParamSpec::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ParamSpec) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000fu) { // optional string name = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_share_mode()); } // optional float lr_mult = 3 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } // optional float decay_mult = 4 [default = 1]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParamSpec::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ParamSpec::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParamSpec::GetClassData() const { return &_class_data_; } void ParamSpec::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ParamSpec::MergeFrom(const ParamSpec& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ParamSpec) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { _internal_set_name(from._internal_name()); } if (cached_has_bits & 0x00000002u) { share_mode_ = from.share_mode_; } if (cached_has_bits & 0x00000004u) { lr_mult_ = from.lr_mult_; } if (cached_has_bits & 0x00000008u) { decay_mult_ = from.decay_mult_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParamSpec::CopyFrom(const ParamSpec& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ParamSpec) if (&from == this) return; Clear(); MergeFrom(from); } bool ParamSpec::IsInitialized() const { return true; } void ParamSpec::InternalSwap(ParamSpec* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &name_, lhs_arena, &other->name_, rhs_arena ); swap(share_mode_, other->share_mode_); swap(lr_mult_, other->lr_mult_); swap(decay_mult_, other->decay_mult_); } ::PROTOBUF_NAMESPACE_ID::Metadata ParamSpec::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[14]); } // =================================================================== class LayerParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_name(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_type(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_phase(HasBits* has_bits) { (*has_bits)[1] |= 16777216u; } static const ::opencv_caffe::TransformationParameter& transform_param(const LayerParameter* msg); static void set_has_transform_param(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static const ::opencv_caffe::LossParameter& loss_param(const LayerParameter* msg); static void set_has_loss_param(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static const ::opencv_caffe::AccuracyParameter& accuracy_param(const LayerParameter* msg); static void set_has_accuracy_param(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static const ::opencv_caffe::ArgMaxParameter& argmax_param(const LayerParameter* msg); static void set_has_argmax_param(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static const ::opencv_caffe::BatchNormParameter& batch_norm_param(const LayerParameter* msg); static void set_has_batch_norm_param(HasBits* has_bits) { (*has_bits)[1] |= 512u; } static const ::opencv_caffe::BiasParameter& bias_param(const LayerParameter* msg); static void set_has_bias_param(HasBits* has_bits) { (*has_bits)[1] |= 2048u; } static const ::opencv_caffe::ConcatParameter& concat_param(const LayerParameter* msg); static void set_has_concat_param(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param(const LayerParameter* msg); static void set_has_contrastive_loss_param(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static const ::opencv_caffe::ConvolutionParameter& convolution_param(const LayerParameter* msg); static void set_has_convolution_param(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static const ::opencv_caffe::CropParameter& crop_param(const LayerParameter* msg); static void set_has_crop_param(HasBits* has_bits) { (*has_bits)[1] |= 16384u; } static const ::opencv_caffe::DataParameter& data_param(const LayerParameter* msg); static void set_has_data_param(HasBits* has_bits) { (*has_bits)[0] |= 512u; } static const ::opencv_caffe::DetectionOutputParameter& detection_output_param(const LayerParameter* msg); static void set_has_detection_output_param(HasBits* has_bits) { (*has_bits)[1] |= 131072u; } static const ::opencv_caffe::DropoutParameter& dropout_param(const LayerParameter* msg); static void set_has_dropout_param(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } static const ::opencv_caffe::DummyDataParameter& dummy_data_param(const LayerParameter* msg); static void set_has_dummy_data_param(HasBits* has_bits) { (*has_bits)[0] |= 2048u; } static const ::opencv_caffe::EltwiseParameter& eltwise_param(const LayerParameter* msg); static void set_has_eltwise_param(HasBits* has_bits) { (*has_bits)[0] |= 4096u; } static const ::opencv_caffe::ELUParameter& elu_param(const LayerParameter* msg); static void set_has_elu_param(HasBits* has_bits) { (*has_bits)[1] |= 1024u; } static const ::opencv_caffe::EmbedParameter& embed_param(const LayerParameter* msg); static void set_has_embed_param(HasBits* has_bits) { (*has_bits)[1] |= 128u; } static const ::opencv_caffe::ExpParameter& exp_param(const LayerParameter* msg); static void set_has_exp_param(HasBits* has_bits) { (*has_bits)[0] |= 8192u; } static const ::opencv_caffe::FlattenParameter& flatten_param(const LayerParameter* msg); static void set_has_flatten_param(HasBits* has_bits) { (*has_bits)[1] |= 32u; } static const ::opencv_caffe::HDF5DataParameter& hdf5_data_param(const LayerParameter* msg); static void set_has_hdf5_data_param(HasBits* has_bits) { (*has_bits)[0] |= 16384u; } static const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param(const LayerParameter* msg); static void set_has_hdf5_output_param(HasBits* has_bits) { (*has_bits)[0] |= 32768u; } static const ::opencv_caffe::HingeLossParameter& hinge_loss_param(const LayerParameter* msg); static void set_has_hinge_loss_param(HasBits* has_bits) { (*has_bits)[0] |= 65536u; } static const ::opencv_caffe::ImageDataParameter& image_data_param(const LayerParameter* msg); static void set_has_image_data_param(HasBits* has_bits) { (*has_bits)[0] |= 131072u; } static const ::opencv_caffe::InfogainLossParameter& infogain_loss_param(const LayerParameter* msg); static void set_has_infogain_loss_param(HasBits* has_bits) { (*has_bits)[0] |= 262144u; } static const ::opencv_caffe::InnerProductParameter& inner_product_param(const LayerParameter* msg); static void set_has_inner_product_param(HasBits* has_bits) { (*has_bits)[0] |= 524288u; } static const ::opencv_caffe::InputParameter& input_param(const LayerParameter* msg); static void set_has_input_param(HasBits* has_bits) { (*has_bits)[1] |= 8192u; } static const ::opencv_caffe::LogParameter& log_param(const LayerParameter* msg); static void set_has_log_param(HasBits* has_bits) { (*has_bits)[1] |= 16u; } static const ::opencv_caffe::LRNParameter& lrn_param(const LayerParameter* msg); static void set_has_lrn_param(HasBits* has_bits) { (*has_bits)[0] |= 1048576u; } static const ::opencv_caffe::MemoryDataParameter& memory_data_param(const LayerParameter* msg); static void set_has_memory_data_param(HasBits* has_bits) { (*has_bits)[0] |= 2097152u; } static const ::opencv_caffe::MVNParameter& mvn_param(const LayerParameter* msg); static void set_has_mvn_param(HasBits* has_bits) { (*has_bits)[0] |= 4194304u; } static const ::opencv_caffe::NormalizeBBoxParameter& norm_param(const LayerParameter* msg); static void set_has_norm_param(HasBits* has_bits) { (*has_bits)[1] |= 524288u; } static const ::opencv_caffe::PermuteParameter& permute_param(const LayerParameter* msg); static void set_has_permute_param(HasBits* has_bits) { (*has_bits)[1] |= 262144u; } static const ::opencv_caffe::ParameterParameter& parameter_param(const LayerParameter* msg); static void set_has_parameter_param(HasBits* has_bits) { (*has_bits)[1] |= 32768u; } static const ::opencv_caffe::PoolingParameter& pooling_param(const LayerParameter* msg); static void set_has_pooling_param(HasBits* has_bits) { (*has_bits)[0] |= 8388608u; } static const ::opencv_caffe::PowerParameter& power_param(const LayerParameter* msg); static void set_has_power_param(HasBits* has_bits) { (*has_bits)[0] |= 16777216u; } static const ::opencv_caffe::PReLUParameter& prelu_param(const LayerParameter* msg); static void set_has_prelu_param(HasBits* has_bits) { (*has_bits)[1] |= 2u; } static const ::opencv_caffe::PriorBoxParameter& prior_box_param(const LayerParameter* msg); static void set_has_prior_box_param(HasBits* has_bits) { (*has_bits)[1] |= 1048576u; } static const ::opencv_caffe::ProposalParameter& proposal_param(const LayerParameter* msg); static void set_has_proposal_param(HasBits* has_bits) { (*has_bits)[1] |= 2097152u; } static const ::opencv_caffe::PSROIPoolingParameter& psroi_pooling_param(const LayerParameter* msg); static void set_has_psroi_pooling_param(HasBits* has_bits) { (*has_bits)[1] |= 4194304u; } static const ::opencv_caffe::PythonParameter& python_param(const LayerParameter* msg); static void set_has_python_param(HasBits* has_bits) { (*has_bits)[1] |= 1u; } static const ::opencv_caffe::RecurrentParameter& recurrent_param(const LayerParameter* msg); static void set_has_recurrent_param(HasBits* has_bits) { (*has_bits)[1] |= 65536u; } static const ::opencv_caffe::ReductionParameter& reduction_param(const LayerParameter* msg); static void set_has_reduction_param(HasBits* has_bits) { (*has_bits)[1] |= 64u; } static const ::opencv_caffe::ReLUParameter& relu_param(const LayerParameter* msg); static void set_has_relu_param(HasBits* has_bits) { (*has_bits)[0] |= 33554432u; } static const ::opencv_caffe::ReshapeParameter& reshape_param(const LayerParameter* msg); static void set_has_reshape_param(HasBits* has_bits) { (*has_bits)[1] |= 8u; } static const ::opencv_caffe::ROIPoolingParameter& roi_pooling_param(const LayerParameter* msg); static void set_has_roi_pooling_param(HasBits* has_bits) { (*has_bits)[1] |= 8388608u; } static const ::opencv_caffe::ScaleParameter& scale_param(const LayerParameter* msg); static void set_has_scale_param(HasBits* has_bits) { (*has_bits)[1] |= 4096u; } static const ::opencv_caffe::SigmoidParameter& sigmoid_param(const LayerParameter* msg); static void set_has_sigmoid_param(HasBits* has_bits) { (*has_bits)[0] |= 67108864u; } static const ::opencv_caffe::SoftmaxParameter& softmax_param(const LayerParameter* msg); static void set_has_softmax_param(HasBits* has_bits) { (*has_bits)[0] |= 134217728u; } static const ::opencv_caffe::SPPParameter& spp_param(const LayerParameter* msg); static void set_has_spp_param(HasBits* has_bits) { (*has_bits)[1] |= 4u; } static const ::opencv_caffe::SliceParameter& slice_param(const LayerParameter* msg); static void set_has_slice_param(HasBits* has_bits) { (*has_bits)[0] |= 268435456u; } static const ::opencv_caffe::TanHParameter& tanh_param(const LayerParameter* msg); static void set_has_tanh_param(HasBits* has_bits) { (*has_bits)[0] |= 536870912u; } static const ::opencv_caffe::ThresholdParameter& threshold_param(const LayerParameter* msg); static void set_has_threshold_param(HasBits* has_bits) { (*has_bits)[0] |= 1073741824u; } static const ::opencv_caffe::TileParameter& tile_param(const LayerParameter* msg); static void set_has_tile_param(HasBits* has_bits) { (*has_bits)[1] |= 256u; } static const ::opencv_caffe::WindowDataParameter& window_data_param(const LayerParameter* msg); static void set_has_window_data_param(HasBits* has_bits) { (*has_bits)[0] |= 2147483648u; } }; const ::opencv_caffe::TransformationParameter& LayerParameter::_Internal::transform_param(const LayerParameter* msg) { return *msg->transform_param_; } const ::opencv_caffe::LossParameter& LayerParameter::_Internal::loss_param(const LayerParameter* msg) { return *msg->loss_param_; } const ::opencv_caffe::AccuracyParameter& LayerParameter::_Internal::accuracy_param(const LayerParameter* msg) { return *msg->accuracy_param_; } const ::opencv_caffe::ArgMaxParameter& LayerParameter::_Internal::argmax_param(const LayerParameter* msg) { return *msg->argmax_param_; } const ::opencv_caffe::BatchNormParameter& LayerParameter::_Internal::batch_norm_param(const LayerParameter* msg) { return *msg->batch_norm_param_; } const ::opencv_caffe::BiasParameter& LayerParameter::_Internal::bias_param(const LayerParameter* msg) { return *msg->bias_param_; } const ::opencv_caffe::ConcatParameter& LayerParameter::_Internal::concat_param(const LayerParameter* msg) { return *msg->concat_param_; } const ::opencv_caffe::ContrastiveLossParameter& LayerParameter::_Internal::contrastive_loss_param(const LayerParameter* msg) { return *msg->contrastive_loss_param_; } const ::opencv_caffe::ConvolutionParameter& LayerParameter::_Internal::convolution_param(const LayerParameter* msg) { return *msg->convolution_param_; } const ::opencv_caffe::CropParameter& LayerParameter::_Internal::crop_param(const LayerParameter* msg) { return *msg->crop_param_; } const ::opencv_caffe::DataParameter& LayerParameter::_Internal::data_param(const LayerParameter* msg) { return *msg->data_param_; } const ::opencv_caffe::DetectionOutputParameter& LayerParameter::_Internal::detection_output_param(const LayerParameter* msg) { return *msg->detection_output_param_; } const ::opencv_caffe::DropoutParameter& LayerParameter::_Internal::dropout_param(const LayerParameter* msg) { return *msg->dropout_param_; } const ::opencv_caffe::DummyDataParameter& LayerParameter::_Internal::dummy_data_param(const LayerParameter* msg) { return *msg->dummy_data_param_; } const ::opencv_caffe::EltwiseParameter& LayerParameter::_Internal::eltwise_param(const LayerParameter* msg) { return *msg->eltwise_param_; } const ::opencv_caffe::ELUParameter& LayerParameter::_Internal::elu_param(const LayerParameter* msg) { return *msg->elu_param_; } const ::opencv_caffe::EmbedParameter& LayerParameter::_Internal::embed_param(const LayerParameter* msg) { return *msg->embed_param_; } const ::opencv_caffe::ExpParameter& LayerParameter::_Internal::exp_param(const LayerParameter* msg) { return *msg->exp_param_; } const ::opencv_caffe::FlattenParameter& LayerParameter::_Internal::flatten_param(const LayerParameter* msg) { return *msg->flatten_param_; } const ::opencv_caffe::HDF5DataParameter& LayerParameter::_Internal::hdf5_data_param(const LayerParameter* msg) { return *msg->hdf5_data_param_; } const ::opencv_caffe::HDF5OutputParameter& LayerParameter::_Internal::hdf5_output_param(const LayerParameter* msg) { return *msg->hdf5_output_param_; } const ::opencv_caffe::HingeLossParameter& LayerParameter::_Internal::hinge_loss_param(const LayerParameter* msg) { return *msg->hinge_loss_param_; } const ::opencv_caffe::ImageDataParameter& LayerParameter::_Internal::image_data_param(const LayerParameter* msg) { return *msg->image_data_param_; } const ::opencv_caffe::InfogainLossParameter& LayerParameter::_Internal::infogain_loss_param(const LayerParameter* msg) { return *msg->infogain_loss_param_; } const ::opencv_caffe::InnerProductParameter& LayerParameter::_Internal::inner_product_param(const LayerParameter* msg) { return *msg->inner_product_param_; } const ::opencv_caffe::InputParameter& LayerParameter::_Internal::input_param(const LayerParameter* msg) { return *msg->input_param_; } const ::opencv_caffe::LogParameter& LayerParameter::_Internal::log_param(const LayerParameter* msg) { return *msg->log_param_; } const ::opencv_caffe::LRNParameter& LayerParameter::_Internal::lrn_param(const LayerParameter* msg) { return *msg->lrn_param_; } const ::opencv_caffe::MemoryDataParameter& LayerParameter::_Internal::memory_data_param(const LayerParameter* msg) { return *msg->memory_data_param_; } const ::opencv_caffe::MVNParameter& LayerParameter::_Internal::mvn_param(const LayerParameter* msg) { return *msg->mvn_param_; } const ::opencv_caffe::NormalizeBBoxParameter& LayerParameter::_Internal::norm_param(const LayerParameter* msg) { return *msg->norm_param_; } const ::opencv_caffe::PermuteParameter& LayerParameter::_Internal::permute_param(const LayerParameter* msg) { return *msg->permute_param_; } const ::opencv_caffe::ParameterParameter& LayerParameter::_Internal::parameter_param(const LayerParameter* msg) { return *msg->parameter_param_; } const ::opencv_caffe::PoolingParameter& LayerParameter::_Internal::pooling_param(const LayerParameter* msg) { return *msg->pooling_param_; } const ::opencv_caffe::PowerParameter& LayerParameter::_Internal::power_param(const LayerParameter* msg) { return *msg->power_param_; } const ::opencv_caffe::PReLUParameter& LayerParameter::_Internal::prelu_param(const LayerParameter* msg) { return *msg->prelu_param_; } const ::opencv_caffe::PriorBoxParameter& LayerParameter::_Internal::prior_box_param(const LayerParameter* msg) { return *msg->prior_box_param_; } const ::opencv_caffe::ProposalParameter& LayerParameter::_Internal::proposal_param(const LayerParameter* msg) { return *msg->proposal_param_; } const ::opencv_caffe::PSROIPoolingParameter& LayerParameter::_Internal::psroi_pooling_param(const LayerParameter* msg) { return *msg->psroi_pooling_param_; } const ::opencv_caffe::PythonParameter& LayerParameter::_Internal::python_param(const LayerParameter* msg) { return *msg->python_param_; } const ::opencv_caffe::RecurrentParameter& LayerParameter::_Internal::recurrent_param(const LayerParameter* msg) { return *msg->recurrent_param_; } const ::opencv_caffe::ReductionParameter& LayerParameter::_Internal::reduction_param(const LayerParameter* msg) { return *msg->reduction_param_; } const ::opencv_caffe::ReLUParameter& LayerParameter::_Internal::relu_param(const LayerParameter* msg) { return *msg->relu_param_; } const ::opencv_caffe::ReshapeParameter& LayerParameter::_Internal::reshape_param(const LayerParameter* msg) { return *msg->reshape_param_; } const ::opencv_caffe::ROIPoolingParameter& LayerParameter::_Internal::roi_pooling_param(const LayerParameter* msg) { return *msg->roi_pooling_param_; } const ::opencv_caffe::ScaleParameter& LayerParameter::_Internal::scale_param(const LayerParameter* msg) { return *msg->scale_param_; } const ::opencv_caffe::SigmoidParameter& LayerParameter::_Internal::sigmoid_param(const LayerParameter* msg) { return *msg->sigmoid_param_; } const ::opencv_caffe::SoftmaxParameter& LayerParameter::_Internal::softmax_param(const LayerParameter* msg) { return *msg->softmax_param_; } const ::opencv_caffe::SPPParameter& LayerParameter::_Internal::spp_param(const LayerParameter* msg) { return *msg->spp_param_; } const ::opencv_caffe::SliceParameter& LayerParameter::_Internal::slice_param(const LayerParameter* msg) { return *msg->slice_param_; } const ::opencv_caffe::TanHParameter& LayerParameter::_Internal::tanh_param(const LayerParameter* msg) { return *msg->tanh_param_; } const ::opencv_caffe::ThresholdParameter& LayerParameter::_Internal::threshold_param(const LayerParameter* msg) { return *msg->threshold_param_; } const ::opencv_caffe::TileParameter& LayerParameter::_Internal::tile_param(const LayerParameter* msg) { return *msg->tile_param_; } const ::opencv_caffe::WindowDataParameter& LayerParameter::_Internal::window_data_param(const LayerParameter* msg) { return *msg->window_data_param_; } LayerParameter::LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), bottom_(arena), top_(arena), loss_weight_(arena), param_(arena), blobs_(arena), include_(arena), exclude_(arena), propagate_down_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.LayerParameter) } LayerParameter::LayerParameter(const LayerParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), bottom_(from.bottom_), top_(from.top_), loss_weight_(from.loss_weight_), param_(from.param_), blobs_(from.blobs_), include_(from.include_), exclude_(from.exclude_), propagate_down_(from.propagate_down_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_name()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), GetArenaForAllocation()); } type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_type()) { type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_type(), GetArenaForAllocation()); } if (from._internal_has_transform_param()) { transform_param_ = new ::opencv_caffe::TransformationParameter(*from.transform_param_); } else { transform_param_ = nullptr; } if (from._internal_has_loss_param()) { loss_param_ = new ::opencv_caffe::LossParameter(*from.loss_param_); } else { loss_param_ = nullptr; } if (from._internal_has_accuracy_param()) { accuracy_param_ = new ::opencv_caffe::AccuracyParameter(*from.accuracy_param_); } else { accuracy_param_ = nullptr; } if (from._internal_has_argmax_param()) { argmax_param_ = new ::opencv_caffe::ArgMaxParameter(*from.argmax_param_); } else { argmax_param_ = nullptr; } if (from._internal_has_concat_param()) { concat_param_ = new ::opencv_caffe::ConcatParameter(*from.concat_param_); } else { concat_param_ = nullptr; } if (from._internal_has_contrastive_loss_param()) { contrastive_loss_param_ = new ::opencv_caffe::ContrastiveLossParameter(*from.contrastive_loss_param_); } else { contrastive_loss_param_ = nullptr; } if (from._internal_has_convolution_param()) { convolution_param_ = new ::opencv_caffe::ConvolutionParameter(*from.convolution_param_); } else { convolution_param_ = nullptr; } if (from._internal_has_data_param()) { data_param_ = new ::opencv_caffe::DataParameter(*from.data_param_); } else { data_param_ = nullptr; } if (from._internal_has_dropout_param()) { dropout_param_ = new ::opencv_caffe::DropoutParameter(*from.dropout_param_); } else { dropout_param_ = nullptr; } if (from._internal_has_dummy_data_param()) { dummy_data_param_ = new ::opencv_caffe::DummyDataParameter(*from.dummy_data_param_); } else { dummy_data_param_ = nullptr; } if (from._internal_has_eltwise_param()) { eltwise_param_ = new ::opencv_caffe::EltwiseParameter(*from.eltwise_param_); } else { eltwise_param_ = nullptr; } if (from._internal_has_exp_param()) { exp_param_ = new ::opencv_caffe::ExpParameter(*from.exp_param_); } else { exp_param_ = nullptr; } if (from._internal_has_hdf5_data_param()) { hdf5_data_param_ = new ::opencv_caffe::HDF5DataParameter(*from.hdf5_data_param_); } else { hdf5_data_param_ = nullptr; } if (from._internal_has_hdf5_output_param()) { hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter(*from.hdf5_output_param_); } else { hdf5_output_param_ = nullptr; } if (from._internal_has_hinge_loss_param()) { hinge_loss_param_ = new ::opencv_caffe::HingeLossParameter(*from.hinge_loss_param_); } else { hinge_loss_param_ = nullptr; } if (from._internal_has_image_data_param()) { image_data_param_ = new ::opencv_caffe::ImageDataParameter(*from.image_data_param_); } else { image_data_param_ = nullptr; } if (from._internal_has_infogain_loss_param()) { infogain_loss_param_ = new ::opencv_caffe::InfogainLossParameter(*from.infogain_loss_param_); } else { infogain_loss_param_ = nullptr; } if (from._internal_has_inner_product_param()) { inner_product_param_ = new ::opencv_caffe::InnerProductParameter(*from.inner_product_param_); } else { inner_product_param_ = nullptr; } if (from._internal_has_lrn_param()) { lrn_param_ = new ::opencv_caffe::LRNParameter(*from.lrn_param_); } else { lrn_param_ = nullptr; } if (from._internal_has_memory_data_param()) { memory_data_param_ = new ::opencv_caffe::MemoryDataParameter(*from.memory_data_param_); } else { memory_data_param_ = nullptr; } if (from._internal_has_mvn_param()) { mvn_param_ = new ::opencv_caffe::MVNParameter(*from.mvn_param_); } else { mvn_param_ = nullptr; } if (from._internal_has_pooling_param()) { pooling_param_ = new ::opencv_caffe::PoolingParameter(*from.pooling_param_); } else { pooling_param_ = nullptr; } if (from._internal_has_power_param()) { power_param_ = new ::opencv_caffe::PowerParameter(*from.power_param_); } else { power_param_ = nullptr; } if (from._internal_has_relu_param()) { relu_param_ = new ::opencv_caffe::ReLUParameter(*from.relu_param_); } else { relu_param_ = nullptr; } if (from._internal_has_sigmoid_param()) { sigmoid_param_ = new ::opencv_caffe::SigmoidParameter(*from.sigmoid_param_); } else { sigmoid_param_ = nullptr; } if (from._internal_has_softmax_param()) { softmax_param_ = new ::opencv_caffe::SoftmaxParameter(*from.softmax_param_); } else { softmax_param_ = nullptr; } if (from._internal_has_slice_param()) { slice_param_ = new ::opencv_caffe::SliceParameter(*from.slice_param_); } else { slice_param_ = nullptr; } if (from._internal_has_tanh_param()) { tanh_param_ = new ::opencv_caffe::TanHParameter(*from.tanh_param_); } else { tanh_param_ = nullptr; } if (from._internal_has_threshold_param()) { threshold_param_ = new ::opencv_caffe::ThresholdParameter(*from.threshold_param_); } else { threshold_param_ = nullptr; } if (from._internal_has_window_data_param()) { window_data_param_ = new ::opencv_caffe::WindowDataParameter(*from.window_data_param_); } else { window_data_param_ = nullptr; } if (from._internal_has_python_param()) { python_param_ = new ::opencv_caffe::PythonParameter(*from.python_param_); } else { python_param_ = nullptr; } if (from._internal_has_prelu_param()) { prelu_param_ = new ::opencv_caffe::PReLUParameter(*from.prelu_param_); } else { prelu_param_ = nullptr; } if (from._internal_has_spp_param()) { spp_param_ = new ::opencv_caffe::SPPParameter(*from.spp_param_); } else { spp_param_ = nullptr; } if (from._internal_has_reshape_param()) { reshape_param_ = new ::opencv_caffe::ReshapeParameter(*from.reshape_param_); } else { reshape_param_ = nullptr; } if (from._internal_has_log_param()) { log_param_ = new ::opencv_caffe::LogParameter(*from.log_param_); } else { log_param_ = nullptr; } if (from._internal_has_flatten_param()) { flatten_param_ = new ::opencv_caffe::FlattenParameter(*from.flatten_param_); } else { flatten_param_ = nullptr; } if (from._internal_has_reduction_param()) { reduction_param_ = new ::opencv_caffe::ReductionParameter(*from.reduction_param_); } else { reduction_param_ = nullptr; } if (from._internal_has_embed_param()) { embed_param_ = new ::opencv_caffe::EmbedParameter(*from.embed_param_); } else { embed_param_ = nullptr; } if (from._internal_has_tile_param()) { tile_param_ = new ::opencv_caffe::TileParameter(*from.tile_param_); } else { tile_param_ = nullptr; } if (from._internal_has_batch_norm_param()) { batch_norm_param_ = new ::opencv_caffe::BatchNormParameter(*from.batch_norm_param_); } else { batch_norm_param_ = nullptr; } if (from._internal_has_elu_param()) { elu_param_ = new ::opencv_caffe::ELUParameter(*from.elu_param_); } else { elu_param_ = nullptr; } if (from._internal_has_bias_param()) { bias_param_ = new ::opencv_caffe::BiasParameter(*from.bias_param_); } else { bias_param_ = nullptr; } if (from._internal_has_scale_param()) { scale_param_ = new ::opencv_caffe::ScaleParameter(*from.scale_param_); } else { scale_param_ = nullptr; } if (from._internal_has_input_param()) { input_param_ = new ::opencv_caffe::InputParameter(*from.input_param_); } else { input_param_ = nullptr; } if (from._internal_has_crop_param()) { crop_param_ = new ::opencv_caffe::CropParameter(*from.crop_param_); } else { crop_param_ = nullptr; } if (from._internal_has_parameter_param()) { parameter_param_ = new ::opencv_caffe::ParameterParameter(*from.parameter_param_); } else { parameter_param_ = nullptr; } if (from._internal_has_recurrent_param()) { recurrent_param_ = new ::opencv_caffe::RecurrentParameter(*from.recurrent_param_); } else { recurrent_param_ = nullptr; } if (from._internal_has_detection_output_param()) { detection_output_param_ = new ::opencv_caffe::DetectionOutputParameter(*from.detection_output_param_); } else { detection_output_param_ = nullptr; } if (from._internal_has_permute_param()) { permute_param_ = new ::opencv_caffe::PermuteParameter(*from.permute_param_); } else { permute_param_ = nullptr; } if (from._internal_has_norm_param()) { norm_param_ = new ::opencv_caffe::NormalizeBBoxParameter(*from.norm_param_); } else { norm_param_ = nullptr; } if (from._internal_has_prior_box_param()) { prior_box_param_ = new ::opencv_caffe::PriorBoxParameter(*from.prior_box_param_); } else { prior_box_param_ = nullptr; } if (from._internal_has_proposal_param()) { proposal_param_ = new ::opencv_caffe::ProposalParameter(*from.proposal_param_); } else { proposal_param_ = nullptr; } if (from._internal_has_psroi_pooling_param()) { psroi_pooling_param_ = new ::opencv_caffe::PSROIPoolingParameter(*from.psroi_pooling_param_); } else { psroi_pooling_param_ = nullptr; } if (from._internal_has_roi_pooling_param()) { roi_pooling_param_ = new ::opencv_caffe::ROIPoolingParameter(*from.roi_pooling_param_); } else { roi_pooling_param_ = nullptr; } phase_ = from.phase_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.LayerParameter) } inline void LayerParameter::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&transform_param_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&phase_) - reinterpret_cast(&transform_param_)) + sizeof(phase_)); } LayerParameter::~LayerParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.LayerParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void LayerParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete transform_param_; if (this != internal_default_instance()) delete loss_param_; if (this != internal_default_instance()) delete accuracy_param_; if (this != internal_default_instance()) delete argmax_param_; if (this != internal_default_instance()) delete concat_param_; if (this != internal_default_instance()) delete contrastive_loss_param_; if (this != internal_default_instance()) delete convolution_param_; if (this != internal_default_instance()) delete data_param_; if (this != internal_default_instance()) delete dropout_param_; if (this != internal_default_instance()) delete dummy_data_param_; if (this != internal_default_instance()) delete eltwise_param_; if (this != internal_default_instance()) delete exp_param_; if (this != internal_default_instance()) delete hdf5_data_param_; if (this != internal_default_instance()) delete hdf5_output_param_; if (this != internal_default_instance()) delete hinge_loss_param_; if (this != internal_default_instance()) delete image_data_param_; if (this != internal_default_instance()) delete infogain_loss_param_; if (this != internal_default_instance()) delete inner_product_param_; if (this != internal_default_instance()) delete lrn_param_; if (this != internal_default_instance()) delete memory_data_param_; if (this != internal_default_instance()) delete mvn_param_; if (this != internal_default_instance()) delete pooling_param_; if (this != internal_default_instance()) delete power_param_; if (this != internal_default_instance()) delete relu_param_; if (this != internal_default_instance()) delete sigmoid_param_; if (this != internal_default_instance()) delete softmax_param_; if (this != internal_default_instance()) delete slice_param_; if (this != internal_default_instance()) delete tanh_param_; if (this != internal_default_instance()) delete threshold_param_; if (this != internal_default_instance()) delete window_data_param_; if (this != internal_default_instance()) delete python_param_; if (this != internal_default_instance()) delete prelu_param_; if (this != internal_default_instance()) delete spp_param_; if (this != internal_default_instance()) delete reshape_param_; if (this != internal_default_instance()) delete log_param_; if (this != internal_default_instance()) delete flatten_param_; if (this != internal_default_instance()) delete reduction_param_; if (this != internal_default_instance()) delete embed_param_; if (this != internal_default_instance()) delete tile_param_; if (this != internal_default_instance()) delete batch_norm_param_; if (this != internal_default_instance()) delete elu_param_; if (this != internal_default_instance()) delete bias_param_; if (this != internal_default_instance()) delete scale_param_; if (this != internal_default_instance()) delete input_param_; if (this != internal_default_instance()) delete crop_param_; if (this != internal_default_instance()) delete parameter_param_; if (this != internal_default_instance()) delete recurrent_param_; if (this != internal_default_instance()) delete detection_output_param_; if (this != internal_default_instance()) delete permute_param_; if (this != internal_default_instance()) delete norm_param_; if (this != internal_default_instance()) delete prior_box_param_; if (this != internal_default_instance()) delete proposal_param_; if (this != internal_default_instance()) delete psroi_pooling_param_; if (this != internal_default_instance()) delete roi_pooling_param_; } void LayerParameter::ArenaDtor(void* object) { LayerParameter* _this = reinterpret_cast< LayerParameter* >(object); (void)_this; } void LayerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void LayerParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void LayerParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.LayerParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; bottom_.Clear(); top_.Clear(); loss_weight_.Clear(); param_.Clear(); blobs_.Clear(); include_.Clear(); exclude_.Clear(); propagate_down_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { name_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { type_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000004u) { GOOGLE_DCHECK(transform_param_ != nullptr); transform_param_->Clear(); } if (cached_has_bits & 0x00000008u) { GOOGLE_DCHECK(loss_param_ != nullptr); loss_param_->Clear(); } if (cached_has_bits & 0x00000010u) { GOOGLE_DCHECK(accuracy_param_ != nullptr); accuracy_param_->Clear(); } if (cached_has_bits & 0x00000020u) { GOOGLE_DCHECK(argmax_param_ != nullptr); argmax_param_->Clear(); } if (cached_has_bits & 0x00000040u) { GOOGLE_DCHECK(concat_param_ != nullptr); concat_param_->Clear(); } if (cached_has_bits & 0x00000080u) { GOOGLE_DCHECK(contrastive_loss_param_ != nullptr); contrastive_loss_param_->Clear(); } } if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { GOOGLE_DCHECK(convolution_param_ != nullptr); convolution_param_->Clear(); } if (cached_has_bits & 0x00000200u) { GOOGLE_DCHECK(data_param_ != nullptr); data_param_->Clear(); } if (cached_has_bits & 0x00000400u) { GOOGLE_DCHECK(dropout_param_ != nullptr); dropout_param_->Clear(); } if (cached_has_bits & 0x00000800u) { GOOGLE_DCHECK(dummy_data_param_ != nullptr); dummy_data_param_->Clear(); } if (cached_has_bits & 0x00001000u) { GOOGLE_DCHECK(eltwise_param_ != nullptr); eltwise_param_->Clear(); } if (cached_has_bits & 0x00002000u) { GOOGLE_DCHECK(exp_param_ != nullptr); exp_param_->Clear(); } if (cached_has_bits & 0x00004000u) { GOOGLE_DCHECK(hdf5_data_param_ != nullptr); hdf5_data_param_->Clear(); } if (cached_has_bits & 0x00008000u) { GOOGLE_DCHECK(hdf5_output_param_ != nullptr); hdf5_output_param_->Clear(); } } if (cached_has_bits & 0x00ff0000u) { if (cached_has_bits & 0x00010000u) { GOOGLE_DCHECK(hinge_loss_param_ != nullptr); hinge_loss_param_->Clear(); } if (cached_has_bits & 0x00020000u) { GOOGLE_DCHECK(image_data_param_ != nullptr); image_data_param_->Clear(); } if (cached_has_bits & 0x00040000u) { GOOGLE_DCHECK(infogain_loss_param_ != nullptr); infogain_loss_param_->Clear(); } if (cached_has_bits & 0x00080000u) { GOOGLE_DCHECK(inner_product_param_ != nullptr); inner_product_param_->Clear(); } if (cached_has_bits & 0x00100000u) { GOOGLE_DCHECK(lrn_param_ != nullptr); lrn_param_->Clear(); } if (cached_has_bits & 0x00200000u) { GOOGLE_DCHECK(memory_data_param_ != nullptr); memory_data_param_->Clear(); } if (cached_has_bits & 0x00400000u) { GOOGLE_DCHECK(mvn_param_ != nullptr); mvn_param_->Clear(); } if (cached_has_bits & 0x00800000u) { GOOGLE_DCHECK(pooling_param_ != nullptr); pooling_param_->Clear(); } } if (cached_has_bits & 0xff000000u) { if (cached_has_bits & 0x01000000u) { GOOGLE_DCHECK(power_param_ != nullptr); power_param_->Clear(); } if (cached_has_bits & 0x02000000u) { GOOGLE_DCHECK(relu_param_ != nullptr); relu_param_->Clear(); } if (cached_has_bits & 0x04000000u) { GOOGLE_DCHECK(sigmoid_param_ != nullptr); sigmoid_param_->Clear(); } if (cached_has_bits & 0x08000000u) { GOOGLE_DCHECK(softmax_param_ != nullptr); softmax_param_->Clear(); } if (cached_has_bits & 0x10000000u) { GOOGLE_DCHECK(slice_param_ != nullptr); slice_param_->Clear(); } if (cached_has_bits & 0x20000000u) { GOOGLE_DCHECK(tanh_param_ != nullptr); tanh_param_->Clear(); } if (cached_has_bits & 0x40000000u) { GOOGLE_DCHECK(threshold_param_ != nullptr); threshold_param_->Clear(); } if (cached_has_bits & 0x80000000u) { GOOGLE_DCHECK(window_data_param_ != nullptr); window_data_param_->Clear(); } } cached_has_bits = _has_bits_[1]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(python_param_ != nullptr); python_param_->Clear(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(prelu_param_ != nullptr); prelu_param_->Clear(); } if (cached_has_bits & 0x00000004u) { GOOGLE_DCHECK(spp_param_ != nullptr); spp_param_->Clear(); } if (cached_has_bits & 0x00000008u) { GOOGLE_DCHECK(reshape_param_ != nullptr); reshape_param_->Clear(); } if (cached_has_bits & 0x00000010u) { GOOGLE_DCHECK(log_param_ != nullptr); log_param_->Clear(); } if (cached_has_bits & 0x00000020u) { GOOGLE_DCHECK(flatten_param_ != nullptr); flatten_param_->Clear(); } if (cached_has_bits & 0x00000040u) { GOOGLE_DCHECK(reduction_param_ != nullptr); reduction_param_->Clear(); } if (cached_has_bits & 0x00000080u) { GOOGLE_DCHECK(embed_param_ != nullptr); embed_param_->Clear(); } } if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { GOOGLE_DCHECK(tile_param_ != nullptr); tile_param_->Clear(); } if (cached_has_bits & 0x00000200u) { GOOGLE_DCHECK(batch_norm_param_ != nullptr); batch_norm_param_->Clear(); } if (cached_has_bits & 0x00000400u) { GOOGLE_DCHECK(elu_param_ != nullptr); elu_param_->Clear(); } if (cached_has_bits & 0x00000800u) { GOOGLE_DCHECK(bias_param_ != nullptr); bias_param_->Clear(); } if (cached_has_bits & 0x00001000u) { GOOGLE_DCHECK(scale_param_ != nullptr); scale_param_->Clear(); } if (cached_has_bits & 0x00002000u) { GOOGLE_DCHECK(input_param_ != nullptr); input_param_->Clear(); } if (cached_has_bits & 0x00004000u) { GOOGLE_DCHECK(crop_param_ != nullptr); crop_param_->Clear(); } if (cached_has_bits & 0x00008000u) { GOOGLE_DCHECK(parameter_param_ != nullptr); parameter_param_->Clear(); } } if (cached_has_bits & 0x00ff0000u) { if (cached_has_bits & 0x00010000u) { GOOGLE_DCHECK(recurrent_param_ != nullptr); recurrent_param_->Clear(); } if (cached_has_bits & 0x00020000u) { GOOGLE_DCHECK(detection_output_param_ != nullptr); detection_output_param_->Clear(); } if (cached_has_bits & 0x00040000u) { GOOGLE_DCHECK(permute_param_ != nullptr); permute_param_->Clear(); } if (cached_has_bits & 0x00080000u) { GOOGLE_DCHECK(norm_param_ != nullptr); norm_param_->Clear(); } if (cached_has_bits & 0x00100000u) { GOOGLE_DCHECK(prior_box_param_ != nullptr); prior_box_param_->Clear(); } if (cached_has_bits & 0x00200000u) { GOOGLE_DCHECK(proposal_param_ != nullptr); proposal_param_->Clear(); } if (cached_has_bits & 0x00400000u) { GOOGLE_DCHECK(psroi_pooling_param_ != nullptr); psroi_pooling_param_->Clear(); } if (cached_has_bits & 0x00800000u) { GOOGLE_DCHECK(roi_pooling_param_ != nullptr); roi_pooling_param_->Clear(); } } phase_ = 0; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* LayerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.LayerParameter.name"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional string type = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_type(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.LayerParameter.type"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // repeated string bottom = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_bottom(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.LayerParameter.bottom"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; // repeated string top = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_top(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.LayerParameter.top"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); } else goto handle_unusual; continue; // repeated float loss_weight = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { ptr -= 1; do { ptr += 1; _internal_add_loss_weight(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<45>(ptr)); } else if (static_cast(tag) == 42) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_loss_weight(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated .opencv_caffe.ParamSpec param = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_param(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); } else goto handle_unusual; continue; // repeated .opencv_caffe.BlobProto blobs = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_blobs(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr)); } else goto handle_unusual; continue; // repeated .opencv_caffe.NetStateRule include = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_include(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); } else goto handle_unusual; continue; // repeated .opencv_caffe.NetStateRule exclude = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_exclude(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); } else goto handle_unusual; continue; // optional .opencv_caffe.Phase phase = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::Phase_IsValid(val))) { _internal_set_phase(static_cast<::opencv_caffe::Phase>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // repeated bool propagate_down = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { ptr -= 1; do { ptr += 1; _internal_add_propagate_down(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<88>(ptr)); } else if (static_cast(tag) == 90) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedBoolParser(_internal_mutable_propagate_down(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.TransformationParameter transform_param = 100; case 100: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_transform_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.LossParameter loss_param = 101; case 101: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_loss_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.AccuracyParameter accuracy_param = 102; case 102: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_accuracy_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ArgMaxParameter argmax_param = 103; case 103: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_argmax_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ConcatParameter concat_param = 104; case 104: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_concat_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105; case 105: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_contrastive_loss_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ConvolutionParameter convolution_param = 106; case 106: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_convolution_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.DataParameter data_param = 107; case 107: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.DropoutParameter dropout_param = 108; case 108: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { ptr = ctx->ParseMessage(_internal_mutable_dropout_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109; case 109: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_dummy_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.EltwiseParameter eltwise_param = 110; case 110: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { ptr = ctx->ParseMessage(_internal_mutable_eltwise_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ExpParameter exp_param = 111; case 111: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { ptr = ctx->ParseMessage(_internal_mutable_exp_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112; case 112: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_hdf5_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113; case 113: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_hdf5_output_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114; case 114: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { ptr = ctx->ParseMessage(_internal_mutable_hinge_loss_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ImageDataParameter image_data_param = 115; case 115: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_image_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116; case 116: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_infogain_loss_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.InnerProductParameter inner_product_param = 117; case 117: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_inner_product_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.LRNParameter lrn_param = 118; case 118: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_lrn_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119; case 119: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { ptr = ctx->ParseMessage(_internal_mutable_memory_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.MVNParameter mvn_param = 120; case 120: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_mvn_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PoolingParameter pooling_param = 121; case 121: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_pooling_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PowerParameter power_param = 122; case 122: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { ptr = ctx->ParseMessage(_internal_mutable_power_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ReLUParameter relu_param = 123; case 123: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { ptr = ctx->ParseMessage(_internal_mutable_relu_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124; case 124: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { ptr = ctx->ParseMessage(_internal_mutable_sigmoid_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SoftmaxParameter softmax_param = 125; case 125: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_softmax_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SliceParameter slice_param = 126; case 126: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { ptr = ctx->ParseMessage(_internal_mutable_slice_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.TanHParameter tanh_param = 127; case 127: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { ptr = ctx->ParseMessage(_internal_mutable_tanh_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ThresholdParameter threshold_param = 128; case 128: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { ptr = ctx->ParseMessage(_internal_mutable_threshold_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.WindowDataParameter window_data_param = 129; case 129: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_window_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PythonParameter python_param = 130; case 130: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_python_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PReLUParameter prelu_param = 131; case 131: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_prelu_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SPPParameter spp_param = 132; case 132: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_spp_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ReshapeParameter reshape_param = 133; case 133: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_reshape_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.LogParameter log_param = 134; case 134: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_log_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FlattenParameter flatten_param = 135; case 135: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_flatten_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ReductionParameter reduction_param = 136; case 136: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_reduction_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.EmbedParameter embed_param = 137; case 137: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_embed_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.TileParameter tile_param = 138; case 138: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_tile_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139; case 139: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_batch_norm_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ELUParameter elu_param = 140; case 140: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { ptr = ctx->ParseMessage(_internal_mutable_elu_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.BiasParameter bias_param = 141; case 141: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_bias_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ScaleParameter scale_param = 142; case 142: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { ptr = ctx->ParseMessage(_internal_mutable_scale_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.InputParameter input_param = 143; case 143: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { ptr = ctx->ParseMessage(_internal_mutable_input_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.CropParameter crop_param = 144; case 144: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_crop_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ParameterParameter parameter_param = 145; case 145: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_parameter_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.RecurrentParameter recurrent_param = 146; case 146: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { ptr = ctx->ParseMessage(_internal_mutable_recurrent_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147; case 147: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_detection_output_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PermuteParameter permute_param = 148; case 148: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_permute_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149; case 149: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_norm_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150; case 150: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_prior_box_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ProposalParameter proposal_param = 201; case 201: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_proposal_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002; case 10002: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { ptr = ctx->ParseMessage(_internal_mutable_psroi_pooling_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711; case 8266711: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { ptr = ctx->ParseMessage(_internal_mutable_roi_pooling_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* LayerParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LayerParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string name = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.LayerParameter.name"); target = stream->WriteStringMaybeAliased( 1, this->_internal_name(), target); } // optional string type = 2; if (cached_has_bits & 0x00000002u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_type().data(), static_cast(this->_internal_type().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.LayerParameter.type"); target = stream->WriteStringMaybeAliased( 2, this->_internal_type(), target); } // repeated string bottom = 3; for (int i = 0, n = this->_internal_bottom_size(); i < n; i++) { const auto& s = this->_internal_bottom(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.LayerParameter.bottom"); target = stream->WriteString(3, s, target); } // repeated string top = 4; for (int i = 0, n = this->_internal_top_size(); i < n; i++) { const auto& s = this->_internal_top(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.LayerParameter.top"); target = stream->WriteString(4, s, target); } // repeated float loss_weight = 5; for (int i = 0, n = this->_internal_loss_weight_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_loss_weight(i), target); } // repeated .opencv_caffe.ParamSpec param = 6; for (unsigned int i = 0, n = static_cast(this->_internal_param_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(6, this->_internal_param(i), target, stream); } // repeated .opencv_caffe.BlobProto blobs = 7; for (unsigned int i = 0, n = static_cast(this->_internal_blobs_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(7, this->_internal_blobs(i), target, stream); } // repeated .opencv_caffe.NetStateRule include = 8; for (unsigned int i = 0, n = static_cast(this->_internal_include_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(8, this->_internal_include(i), target, stream); } // repeated .opencv_caffe.NetStateRule exclude = 9; for (unsigned int i = 0, n = static_cast(this->_internal_exclude_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(9, this->_internal_exclude(i), target, stream); } cached_has_bits = _has_bits_[1]; // optional .opencv_caffe.Phase phase = 10; if (cached_has_bits & 0x01000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 10, this->_internal_phase(), target); } // repeated bool propagate_down = 11; for (int i = 0, n = this->_internal_propagate_down_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_propagate_down(i), target); } cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.TransformationParameter transform_param = 100; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 100, _Internal::transform_param(this), target, stream); } // optional .opencv_caffe.LossParameter loss_param = 101; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 101, _Internal::loss_param(this), target, stream); } // optional .opencv_caffe.AccuracyParameter accuracy_param = 102; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 102, _Internal::accuracy_param(this), target, stream); } // optional .opencv_caffe.ArgMaxParameter argmax_param = 103; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 103, _Internal::argmax_param(this), target, stream); } // optional .opencv_caffe.ConcatParameter concat_param = 104; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 104, _Internal::concat_param(this), target, stream); } // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 105, _Internal::contrastive_loss_param(this), target, stream); } // optional .opencv_caffe.ConvolutionParameter convolution_param = 106; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 106, _Internal::convolution_param(this), target, stream); } // optional .opencv_caffe.DataParameter data_param = 107; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 107, _Internal::data_param(this), target, stream); } // optional .opencv_caffe.DropoutParameter dropout_param = 108; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 108, _Internal::dropout_param(this), target, stream); } // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109; if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 109, _Internal::dummy_data_param(this), target, stream); } // optional .opencv_caffe.EltwiseParameter eltwise_param = 110; if (cached_has_bits & 0x00001000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 110, _Internal::eltwise_param(this), target, stream); } // optional .opencv_caffe.ExpParameter exp_param = 111; if (cached_has_bits & 0x00002000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 111, _Internal::exp_param(this), target, stream); } // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112; if (cached_has_bits & 0x00004000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 112, _Internal::hdf5_data_param(this), target, stream); } // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113; if (cached_has_bits & 0x00008000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 113, _Internal::hdf5_output_param(this), target, stream); } // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114; if (cached_has_bits & 0x00010000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 114, _Internal::hinge_loss_param(this), target, stream); } // optional .opencv_caffe.ImageDataParameter image_data_param = 115; if (cached_has_bits & 0x00020000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 115, _Internal::image_data_param(this), target, stream); } // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116; if (cached_has_bits & 0x00040000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 116, _Internal::infogain_loss_param(this), target, stream); } // optional .opencv_caffe.InnerProductParameter inner_product_param = 117; if (cached_has_bits & 0x00080000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 117, _Internal::inner_product_param(this), target, stream); } // optional .opencv_caffe.LRNParameter lrn_param = 118; if (cached_has_bits & 0x00100000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 118, _Internal::lrn_param(this), target, stream); } // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119; if (cached_has_bits & 0x00200000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 119, _Internal::memory_data_param(this), target, stream); } // optional .opencv_caffe.MVNParameter mvn_param = 120; if (cached_has_bits & 0x00400000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 120, _Internal::mvn_param(this), target, stream); } // optional .opencv_caffe.PoolingParameter pooling_param = 121; if (cached_has_bits & 0x00800000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 121, _Internal::pooling_param(this), target, stream); } // optional .opencv_caffe.PowerParameter power_param = 122; if (cached_has_bits & 0x01000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 122, _Internal::power_param(this), target, stream); } // optional .opencv_caffe.ReLUParameter relu_param = 123; if (cached_has_bits & 0x02000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 123, _Internal::relu_param(this), target, stream); } // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124; if (cached_has_bits & 0x04000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 124, _Internal::sigmoid_param(this), target, stream); } // optional .opencv_caffe.SoftmaxParameter softmax_param = 125; if (cached_has_bits & 0x08000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 125, _Internal::softmax_param(this), target, stream); } // optional .opencv_caffe.SliceParameter slice_param = 126; if (cached_has_bits & 0x10000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 126, _Internal::slice_param(this), target, stream); } // optional .opencv_caffe.TanHParameter tanh_param = 127; if (cached_has_bits & 0x20000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 127, _Internal::tanh_param(this), target, stream); } // optional .opencv_caffe.ThresholdParameter threshold_param = 128; if (cached_has_bits & 0x40000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 128, _Internal::threshold_param(this), target, stream); } // optional .opencv_caffe.WindowDataParameter window_data_param = 129; if (cached_has_bits & 0x80000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 129, _Internal::window_data_param(this), target, stream); } cached_has_bits = _has_bits_[1]; // optional .opencv_caffe.PythonParameter python_param = 130; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 130, _Internal::python_param(this), target, stream); } // optional .opencv_caffe.PReLUParameter prelu_param = 131; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 131, _Internal::prelu_param(this), target, stream); } // optional .opencv_caffe.SPPParameter spp_param = 132; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 132, _Internal::spp_param(this), target, stream); } // optional .opencv_caffe.ReshapeParameter reshape_param = 133; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 133, _Internal::reshape_param(this), target, stream); } // optional .opencv_caffe.LogParameter log_param = 134; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 134, _Internal::log_param(this), target, stream); } // optional .opencv_caffe.FlattenParameter flatten_param = 135; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 135, _Internal::flatten_param(this), target, stream); } // optional .opencv_caffe.ReductionParameter reduction_param = 136; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 136, _Internal::reduction_param(this), target, stream); } // optional .opencv_caffe.EmbedParameter embed_param = 137; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 137, _Internal::embed_param(this), target, stream); } // optional .opencv_caffe.TileParameter tile_param = 138; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 138, _Internal::tile_param(this), target, stream); } // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 139, _Internal::batch_norm_param(this), target, stream); } // optional .opencv_caffe.ELUParameter elu_param = 140; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 140, _Internal::elu_param(this), target, stream); } // optional .opencv_caffe.BiasParameter bias_param = 141; if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 141, _Internal::bias_param(this), target, stream); } // optional .opencv_caffe.ScaleParameter scale_param = 142; if (cached_has_bits & 0x00001000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 142, _Internal::scale_param(this), target, stream); } // optional .opencv_caffe.InputParameter input_param = 143; if (cached_has_bits & 0x00002000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 143, _Internal::input_param(this), target, stream); } // optional .opencv_caffe.CropParameter crop_param = 144; if (cached_has_bits & 0x00004000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 144, _Internal::crop_param(this), target, stream); } // optional .opencv_caffe.ParameterParameter parameter_param = 145; if (cached_has_bits & 0x00008000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 145, _Internal::parameter_param(this), target, stream); } // optional .opencv_caffe.RecurrentParameter recurrent_param = 146; if (cached_has_bits & 0x00010000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 146, _Internal::recurrent_param(this), target, stream); } // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147; if (cached_has_bits & 0x00020000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 147, _Internal::detection_output_param(this), target, stream); } // optional .opencv_caffe.PermuteParameter permute_param = 148; if (cached_has_bits & 0x00040000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 148, _Internal::permute_param(this), target, stream); } // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149; if (cached_has_bits & 0x00080000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 149, _Internal::norm_param(this), target, stream); } // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150; if (cached_has_bits & 0x00100000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 150, _Internal::prior_box_param(this), target, stream); } // optional .opencv_caffe.ProposalParameter proposal_param = 201; if (cached_has_bits & 0x00200000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 201, _Internal::proposal_param(this), target, stream); } // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002; if (cached_has_bits & 0x00400000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 10002, _Internal::psroi_pooling_param(this), target, stream); } // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711; if (cached_has_bits & 0x00800000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 8266711, _Internal::roi_pooling_param(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LayerParameter) return target; } size_t LayerParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LayerParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string bottom = 3; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(bottom_.size()); for (int i = 0, n = bottom_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( bottom_.Get(i)); } // repeated string top = 4; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(top_.size()); for (int i = 0, n = top_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( top_.Get(i)); } // repeated float loss_weight = 5; { unsigned int count = static_cast(this->_internal_loss_weight_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_loss_weight_size()); total_size += data_size; } // repeated .opencv_caffe.ParamSpec param = 6; total_size += 1UL * this->_internal_param_size(); for (const auto& msg : this->param_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated .opencv_caffe.BlobProto blobs = 7; total_size += 1UL * this->_internal_blobs_size(); for (const auto& msg : this->blobs_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated .opencv_caffe.NetStateRule include = 8; total_size += 1UL * this->_internal_include_size(); for (const auto& msg : this->include_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated .opencv_caffe.NetStateRule exclude = 9; total_size += 1UL * this->_internal_exclude_size(); for (const auto& msg : this->exclude_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated bool propagate_down = 11; { unsigned int count = static_cast(this->_internal_propagate_down_size()); size_t data_size = 1UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_propagate_down_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional string name = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // optional string type = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_type()); } // optional .opencv_caffe.TransformationParameter transform_param = 100; if (cached_has_bits & 0x00000004u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *transform_param_); } // optional .opencv_caffe.LossParameter loss_param = 101; if (cached_has_bits & 0x00000008u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *loss_param_); } // optional .opencv_caffe.AccuracyParameter accuracy_param = 102; if (cached_has_bits & 0x00000010u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *accuracy_param_); } // optional .opencv_caffe.ArgMaxParameter argmax_param = 103; if (cached_has_bits & 0x00000020u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *argmax_param_); } // optional .opencv_caffe.ConcatParameter concat_param = 104; if (cached_has_bits & 0x00000040u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *concat_param_); } // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105; if (cached_has_bits & 0x00000080u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *contrastive_loss_param_); } } if (cached_has_bits & 0x0000ff00u) { // optional .opencv_caffe.ConvolutionParameter convolution_param = 106; if (cached_has_bits & 0x00000100u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *convolution_param_); } // optional .opencv_caffe.DataParameter data_param = 107; if (cached_has_bits & 0x00000200u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_param_); } // optional .opencv_caffe.DropoutParameter dropout_param = 108; if (cached_has_bits & 0x00000400u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *dropout_param_); } // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109; if (cached_has_bits & 0x00000800u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *dummy_data_param_); } // optional .opencv_caffe.EltwiseParameter eltwise_param = 110; if (cached_has_bits & 0x00001000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *eltwise_param_); } // optional .opencv_caffe.ExpParameter exp_param = 111; if (cached_has_bits & 0x00002000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *exp_param_); } // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112; if (cached_has_bits & 0x00004000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *hdf5_data_param_); } // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113; if (cached_has_bits & 0x00008000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *hdf5_output_param_); } } if (cached_has_bits & 0x00ff0000u) { // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114; if (cached_has_bits & 0x00010000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *hinge_loss_param_); } // optional .opencv_caffe.ImageDataParameter image_data_param = 115; if (cached_has_bits & 0x00020000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *image_data_param_); } // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116; if (cached_has_bits & 0x00040000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *infogain_loss_param_); } // optional .opencv_caffe.InnerProductParameter inner_product_param = 117; if (cached_has_bits & 0x00080000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *inner_product_param_); } // optional .opencv_caffe.LRNParameter lrn_param = 118; if (cached_has_bits & 0x00100000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *lrn_param_); } // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119; if (cached_has_bits & 0x00200000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *memory_data_param_); } // optional .opencv_caffe.MVNParameter mvn_param = 120; if (cached_has_bits & 0x00400000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *mvn_param_); } // optional .opencv_caffe.PoolingParameter pooling_param = 121; if (cached_has_bits & 0x00800000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *pooling_param_); } } if (cached_has_bits & 0xff000000u) { // optional .opencv_caffe.PowerParameter power_param = 122; if (cached_has_bits & 0x01000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *power_param_); } // optional .opencv_caffe.ReLUParameter relu_param = 123; if (cached_has_bits & 0x02000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *relu_param_); } // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124; if (cached_has_bits & 0x04000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *sigmoid_param_); } // optional .opencv_caffe.SoftmaxParameter softmax_param = 125; if (cached_has_bits & 0x08000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *softmax_param_); } // optional .opencv_caffe.SliceParameter slice_param = 126; if (cached_has_bits & 0x10000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *slice_param_); } // optional .opencv_caffe.TanHParameter tanh_param = 127; if (cached_has_bits & 0x20000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *tanh_param_); } // optional .opencv_caffe.ThresholdParameter threshold_param = 128; if (cached_has_bits & 0x40000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *threshold_param_); } // optional .opencv_caffe.WindowDataParameter window_data_param = 129; if (cached_has_bits & 0x80000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *window_data_param_); } } cached_has_bits = _has_bits_[1]; if (cached_has_bits & 0x000000ffu) { // optional .opencv_caffe.PythonParameter python_param = 130; if (cached_has_bits & 0x00000001u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *python_param_); } // optional .opencv_caffe.PReLUParameter prelu_param = 131; if (cached_has_bits & 0x00000002u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *prelu_param_); } // optional .opencv_caffe.SPPParameter spp_param = 132; if (cached_has_bits & 0x00000004u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *spp_param_); } // optional .opencv_caffe.ReshapeParameter reshape_param = 133; if (cached_has_bits & 0x00000008u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *reshape_param_); } // optional .opencv_caffe.LogParameter log_param = 134; if (cached_has_bits & 0x00000010u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *log_param_); } // optional .opencv_caffe.FlattenParameter flatten_param = 135; if (cached_has_bits & 0x00000020u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *flatten_param_); } // optional .opencv_caffe.ReductionParameter reduction_param = 136; if (cached_has_bits & 0x00000040u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *reduction_param_); } // optional .opencv_caffe.EmbedParameter embed_param = 137; if (cached_has_bits & 0x00000080u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *embed_param_); } } if (cached_has_bits & 0x0000ff00u) { // optional .opencv_caffe.TileParameter tile_param = 138; if (cached_has_bits & 0x00000100u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *tile_param_); } // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139; if (cached_has_bits & 0x00000200u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *batch_norm_param_); } // optional .opencv_caffe.ELUParameter elu_param = 140; if (cached_has_bits & 0x00000400u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *elu_param_); } // optional .opencv_caffe.BiasParameter bias_param = 141; if (cached_has_bits & 0x00000800u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *bias_param_); } // optional .opencv_caffe.ScaleParameter scale_param = 142; if (cached_has_bits & 0x00001000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *scale_param_); } // optional .opencv_caffe.InputParameter input_param = 143; if (cached_has_bits & 0x00002000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_param_); } // optional .opencv_caffe.CropParameter crop_param = 144; if (cached_has_bits & 0x00004000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *crop_param_); } // optional .opencv_caffe.ParameterParameter parameter_param = 145; if (cached_has_bits & 0x00008000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *parameter_param_); } } if (cached_has_bits & 0x00ff0000u) { // optional .opencv_caffe.RecurrentParameter recurrent_param = 146; if (cached_has_bits & 0x00010000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *recurrent_param_); } // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147; if (cached_has_bits & 0x00020000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *detection_output_param_); } // optional .opencv_caffe.PermuteParameter permute_param = 148; if (cached_has_bits & 0x00040000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *permute_param_); } // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149; if (cached_has_bits & 0x00080000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *norm_param_); } // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150; if (cached_has_bits & 0x00100000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *prior_box_param_); } // optional .opencv_caffe.ProposalParameter proposal_param = 201; if (cached_has_bits & 0x00200000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *proposal_param_); } // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002; if (cached_has_bits & 0x00400000u) { total_size += 3 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *psroi_pooling_param_); } // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711; if (cached_has_bits & 0x00800000u) { total_size += 4 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *roi_pooling_param_); } } // optional .opencv_caffe.Phase phase = 10; if (cached_has_bits & 0x01000000u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LayerParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, LayerParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LayerParameter::GetClassData() const { return &_class_data_; } void LayerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void LayerParameter::MergeFrom(const LayerParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LayerParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; bottom_.MergeFrom(from.bottom_); top_.MergeFrom(from.top_); loss_weight_.MergeFrom(from.loss_weight_); param_.MergeFrom(from.param_); blobs_.MergeFrom(from.blobs_); include_.MergeFrom(from.include_); exclude_.MergeFrom(from.exclude_); propagate_down_.MergeFrom(from.propagate_down_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_name(from._internal_name()); } if (cached_has_bits & 0x00000002u) { _internal_set_type(from._internal_type()); } if (cached_has_bits & 0x00000004u) { _internal_mutable_transform_param()->::opencv_caffe::TransformationParameter::MergeFrom(from._internal_transform_param()); } if (cached_has_bits & 0x00000008u) { _internal_mutable_loss_param()->::opencv_caffe::LossParameter::MergeFrom(from._internal_loss_param()); } if (cached_has_bits & 0x00000010u) { _internal_mutable_accuracy_param()->::opencv_caffe::AccuracyParameter::MergeFrom(from._internal_accuracy_param()); } if (cached_has_bits & 0x00000020u) { _internal_mutable_argmax_param()->::opencv_caffe::ArgMaxParameter::MergeFrom(from._internal_argmax_param()); } if (cached_has_bits & 0x00000040u) { _internal_mutable_concat_param()->::opencv_caffe::ConcatParameter::MergeFrom(from._internal_concat_param()); } if (cached_has_bits & 0x00000080u) { _internal_mutable_contrastive_loss_param()->::opencv_caffe::ContrastiveLossParameter::MergeFrom(from._internal_contrastive_loss_param()); } } if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { _internal_mutable_convolution_param()->::opencv_caffe::ConvolutionParameter::MergeFrom(from._internal_convolution_param()); } if (cached_has_bits & 0x00000200u) { _internal_mutable_data_param()->::opencv_caffe::DataParameter::MergeFrom(from._internal_data_param()); } if (cached_has_bits & 0x00000400u) { _internal_mutable_dropout_param()->::opencv_caffe::DropoutParameter::MergeFrom(from._internal_dropout_param()); } if (cached_has_bits & 0x00000800u) { _internal_mutable_dummy_data_param()->::opencv_caffe::DummyDataParameter::MergeFrom(from._internal_dummy_data_param()); } if (cached_has_bits & 0x00001000u) { _internal_mutable_eltwise_param()->::opencv_caffe::EltwiseParameter::MergeFrom(from._internal_eltwise_param()); } if (cached_has_bits & 0x00002000u) { _internal_mutable_exp_param()->::opencv_caffe::ExpParameter::MergeFrom(from._internal_exp_param()); } if (cached_has_bits & 0x00004000u) { _internal_mutable_hdf5_data_param()->::opencv_caffe::HDF5DataParameter::MergeFrom(from._internal_hdf5_data_param()); } if (cached_has_bits & 0x00008000u) { _internal_mutable_hdf5_output_param()->::opencv_caffe::HDF5OutputParameter::MergeFrom(from._internal_hdf5_output_param()); } } if (cached_has_bits & 0x00ff0000u) { if (cached_has_bits & 0x00010000u) { _internal_mutable_hinge_loss_param()->::opencv_caffe::HingeLossParameter::MergeFrom(from._internal_hinge_loss_param()); } if (cached_has_bits & 0x00020000u) { _internal_mutable_image_data_param()->::opencv_caffe::ImageDataParameter::MergeFrom(from._internal_image_data_param()); } if (cached_has_bits & 0x00040000u) { _internal_mutable_infogain_loss_param()->::opencv_caffe::InfogainLossParameter::MergeFrom(from._internal_infogain_loss_param()); } if (cached_has_bits & 0x00080000u) { _internal_mutable_inner_product_param()->::opencv_caffe::InnerProductParameter::MergeFrom(from._internal_inner_product_param()); } if (cached_has_bits & 0x00100000u) { _internal_mutable_lrn_param()->::opencv_caffe::LRNParameter::MergeFrom(from._internal_lrn_param()); } if (cached_has_bits & 0x00200000u) { _internal_mutable_memory_data_param()->::opencv_caffe::MemoryDataParameter::MergeFrom(from._internal_memory_data_param()); } if (cached_has_bits & 0x00400000u) { _internal_mutable_mvn_param()->::opencv_caffe::MVNParameter::MergeFrom(from._internal_mvn_param()); } if (cached_has_bits & 0x00800000u) { _internal_mutable_pooling_param()->::opencv_caffe::PoolingParameter::MergeFrom(from._internal_pooling_param()); } } if (cached_has_bits & 0xff000000u) { if (cached_has_bits & 0x01000000u) { _internal_mutable_power_param()->::opencv_caffe::PowerParameter::MergeFrom(from._internal_power_param()); } if (cached_has_bits & 0x02000000u) { _internal_mutable_relu_param()->::opencv_caffe::ReLUParameter::MergeFrom(from._internal_relu_param()); } if (cached_has_bits & 0x04000000u) { _internal_mutable_sigmoid_param()->::opencv_caffe::SigmoidParameter::MergeFrom(from._internal_sigmoid_param()); } if (cached_has_bits & 0x08000000u) { _internal_mutable_softmax_param()->::opencv_caffe::SoftmaxParameter::MergeFrom(from._internal_softmax_param()); } if (cached_has_bits & 0x10000000u) { _internal_mutable_slice_param()->::opencv_caffe::SliceParameter::MergeFrom(from._internal_slice_param()); } if (cached_has_bits & 0x20000000u) { _internal_mutable_tanh_param()->::opencv_caffe::TanHParameter::MergeFrom(from._internal_tanh_param()); } if (cached_has_bits & 0x40000000u) { _internal_mutable_threshold_param()->::opencv_caffe::ThresholdParameter::MergeFrom(from._internal_threshold_param()); } if (cached_has_bits & 0x80000000u) { _internal_mutable_window_data_param()->::opencv_caffe::WindowDataParameter::MergeFrom(from._internal_window_data_param()); } } cached_has_bits = from._has_bits_[1]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_python_param()->::opencv_caffe::PythonParameter::MergeFrom(from._internal_python_param()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_prelu_param()->::opencv_caffe::PReLUParameter::MergeFrom(from._internal_prelu_param()); } if (cached_has_bits & 0x00000004u) { _internal_mutable_spp_param()->::opencv_caffe::SPPParameter::MergeFrom(from._internal_spp_param()); } if (cached_has_bits & 0x00000008u) { _internal_mutable_reshape_param()->::opencv_caffe::ReshapeParameter::MergeFrom(from._internal_reshape_param()); } if (cached_has_bits & 0x00000010u) { _internal_mutable_log_param()->::opencv_caffe::LogParameter::MergeFrom(from._internal_log_param()); } if (cached_has_bits & 0x00000020u) { _internal_mutable_flatten_param()->::opencv_caffe::FlattenParameter::MergeFrom(from._internal_flatten_param()); } if (cached_has_bits & 0x00000040u) { _internal_mutable_reduction_param()->::opencv_caffe::ReductionParameter::MergeFrom(from._internal_reduction_param()); } if (cached_has_bits & 0x00000080u) { _internal_mutable_embed_param()->::opencv_caffe::EmbedParameter::MergeFrom(from._internal_embed_param()); } } if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { _internal_mutable_tile_param()->::opencv_caffe::TileParameter::MergeFrom(from._internal_tile_param()); } if (cached_has_bits & 0x00000200u) { _internal_mutable_batch_norm_param()->::opencv_caffe::BatchNormParameter::MergeFrom(from._internal_batch_norm_param()); } if (cached_has_bits & 0x00000400u) { _internal_mutable_elu_param()->::opencv_caffe::ELUParameter::MergeFrom(from._internal_elu_param()); } if (cached_has_bits & 0x00000800u) { _internal_mutable_bias_param()->::opencv_caffe::BiasParameter::MergeFrom(from._internal_bias_param()); } if (cached_has_bits & 0x00001000u) { _internal_mutable_scale_param()->::opencv_caffe::ScaleParameter::MergeFrom(from._internal_scale_param()); } if (cached_has_bits & 0x00002000u) { _internal_mutable_input_param()->::opencv_caffe::InputParameter::MergeFrom(from._internal_input_param()); } if (cached_has_bits & 0x00004000u) { _internal_mutable_crop_param()->::opencv_caffe::CropParameter::MergeFrom(from._internal_crop_param()); } if (cached_has_bits & 0x00008000u) { _internal_mutable_parameter_param()->::opencv_caffe::ParameterParameter::MergeFrom(from._internal_parameter_param()); } } if (cached_has_bits & 0x00ff0000u) { if (cached_has_bits & 0x00010000u) { _internal_mutable_recurrent_param()->::opencv_caffe::RecurrentParameter::MergeFrom(from._internal_recurrent_param()); } if (cached_has_bits & 0x00020000u) { _internal_mutable_detection_output_param()->::opencv_caffe::DetectionOutputParameter::MergeFrom(from._internal_detection_output_param()); } if (cached_has_bits & 0x00040000u) { _internal_mutable_permute_param()->::opencv_caffe::PermuteParameter::MergeFrom(from._internal_permute_param()); } if (cached_has_bits & 0x00080000u) { _internal_mutable_norm_param()->::opencv_caffe::NormalizeBBoxParameter::MergeFrom(from._internal_norm_param()); } if (cached_has_bits & 0x00100000u) { _internal_mutable_prior_box_param()->::opencv_caffe::PriorBoxParameter::MergeFrom(from._internal_prior_box_param()); } if (cached_has_bits & 0x00200000u) { _internal_mutable_proposal_param()->::opencv_caffe::ProposalParameter::MergeFrom(from._internal_proposal_param()); } if (cached_has_bits & 0x00400000u) { _internal_mutable_psroi_pooling_param()->::opencv_caffe::PSROIPoolingParameter::MergeFrom(from._internal_psroi_pooling_param()); } if (cached_has_bits & 0x00800000u) { _internal_mutable_roi_pooling_param()->::opencv_caffe::ROIPoolingParameter::MergeFrom(from._internal_roi_pooling_param()); } } if (cached_has_bits & 0x01000000u) { _internal_set_phase(from._internal_phase()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void LayerParameter::CopyFrom(const LayerParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LayerParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool LayerParameter::IsInitialized() const { if (_internal_has_psroi_pooling_param()) { if (!psroi_pooling_param_->IsInitialized()) return false; } return true; } void LayerParameter::InternalSwap(LayerParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(_has_bits_[1], other->_has_bits_[1]); bottom_.InternalSwap(&other->bottom_); top_.InternalSwap(&other->top_); loss_weight_.InternalSwap(&other->loss_weight_); param_.InternalSwap(&other->param_); blobs_.InternalSwap(&other->blobs_); include_.InternalSwap(&other->include_); exclude_.InternalSwap(&other->exclude_); propagate_down_.InternalSwap(&other->propagate_down_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &name_, lhs_arena, &other->name_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &type_, lhs_arena, &other->type_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(LayerParameter, phase_) + sizeof(LayerParameter::phase_) - PROTOBUF_FIELD_OFFSET(LayerParameter, transform_param_)>( reinterpret_cast(&transform_param_), reinterpret_cast(&other->transform_param_)); } ::PROTOBUF_NAMESPACE_ID::Metadata LayerParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[15]); } // =================================================================== class TransformationParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_scale(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_mirror(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_crop_size(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_mean_file(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_force_color(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_force_gray(HasBits* has_bits) { (*has_bits)[0] |= 16u; } }; TransformationParameter::TransformationParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), mean_value_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.TransformationParameter) } TransformationParameter::TransformationParameter(const TransformationParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), mean_value_(from.mean_value_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_mean_file()) { mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mean_file(), GetArenaForAllocation()); } ::memcpy(&crop_size_, &from.crop_size_, static_cast(reinterpret_cast(&scale_) - reinterpret_cast(&crop_size_)) + sizeof(scale_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.TransformationParameter) } inline void TransformationParameter::SharedCtor() { mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&crop_size_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&force_gray_) - reinterpret_cast(&crop_size_)) + sizeof(force_gray_)); scale_ = 1; } TransformationParameter::~TransformationParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.TransformationParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void TransformationParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); mean_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void TransformationParameter::ArenaDtor(void* object) { TransformationParameter* _this = reinterpret_cast< TransformationParameter* >(object); (void)_this; } void TransformationParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void TransformationParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void TransformationParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.TransformationParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; mean_value_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { mean_file_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x0000003eu) { ::memset(&crop_size_, 0, static_cast( reinterpret_cast(&force_gray_) - reinterpret_cast(&crop_size_)) + sizeof(force_gray_)); scale_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* TransformationParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float scale = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_scale(&has_bits); scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional bool mirror = 2 [default = false]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_mirror(&has_bits); mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 crop_size = 3 [default = 0]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_crop_size(&has_bits); crop_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string mean_file = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { auto str = _internal_mutable_mean_file(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.TransformationParameter.mean_file"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // repeated float mean_value = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { ptr -= 1; do { ptr += 1; _internal_add_mean_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<45>(ptr)); } else if (static_cast(tag) == 42) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_mean_value(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional bool force_color = 6 [default = false]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_force_color(&has_bits); force_color_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool force_gray = 7 [default = false]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_force_gray(&has_bits); force_gray_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* TransformationParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.TransformationParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float scale = 1 [default = 1]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_scale(), target); } // optional bool mirror = 2 [default = false]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_mirror(), target); } // optional uint32 crop_size = 3 [default = 0]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_crop_size(), target); } // optional string mean_file = 4; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_mean_file().data(), static_cast(this->_internal_mean_file().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.TransformationParameter.mean_file"); target = stream->WriteStringMaybeAliased( 4, this->_internal_mean_file(), target); } // repeated float mean_value = 5; for (int i = 0, n = this->_internal_mean_value_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_mean_value(i), target); } // optional bool force_color = 6 [default = false]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_force_color(), target); } // optional bool force_gray = 7 [default = false]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_force_gray(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.TransformationParameter) return target; } size_t TransformationParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.TransformationParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated float mean_value = 5; { unsigned int count = static_cast(this->_internal_mean_value_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_mean_value_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000003fu) { // optional string mean_file = 4; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_mean_file()); } // optional uint32 crop_size = 3 [default = 0]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_crop_size()); } // optional bool mirror = 2 [default = false]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 1; } // optional bool force_color = 6 [default = false]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 1; } // optional bool force_gray = 7 [default = false]; if (cached_has_bits & 0x00000010u) { total_size += 1 + 1; } // optional float scale = 1 [default = 1]; if (cached_has_bits & 0x00000020u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TransformationParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, TransformationParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TransformationParameter::GetClassData() const { return &_class_data_; } void TransformationParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void TransformationParameter::MergeFrom(const TransformationParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.TransformationParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; mean_value_.MergeFrom(from.mean_value_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { _internal_set_mean_file(from._internal_mean_file()); } if (cached_has_bits & 0x00000002u) { crop_size_ = from.crop_size_; } if (cached_has_bits & 0x00000004u) { mirror_ = from.mirror_; } if (cached_has_bits & 0x00000008u) { force_color_ = from.force_color_; } if (cached_has_bits & 0x00000010u) { force_gray_ = from.force_gray_; } if (cached_has_bits & 0x00000020u) { scale_ = from.scale_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void TransformationParameter::CopyFrom(const TransformationParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.TransformationParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool TransformationParameter::IsInitialized() const { return true; } void TransformationParameter::InternalSwap(TransformationParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); mean_value_.InternalSwap(&other->mean_value_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &mean_file_, lhs_arena, &other->mean_file_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(TransformationParameter, force_gray_) + sizeof(TransformationParameter::force_gray_) - PROTOBUF_FIELD_OFFSET(TransformationParameter, crop_size_)>( reinterpret_cast(&crop_size_), reinterpret_cast(&other->crop_size_)); swap(scale_, other->scale_); } ::PROTOBUF_NAMESPACE_ID::Metadata TransformationParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[16]); } // =================================================================== class LossParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_ignore_label(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_normalization(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_normalize(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; LossParameter::LossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.LossParameter) } LossParameter::LossParameter(const LossParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&ignore_label_, &from.ignore_label_, static_cast(reinterpret_cast(&normalization_) - reinterpret_cast(&ignore_label_)) + sizeof(normalization_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.LossParameter) } inline void LossParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&ignore_label_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&normalize_) - reinterpret_cast(&ignore_label_)) + sizeof(normalize_)); normalization_ = 1; } LossParameter::~LossParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.LossParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void LossParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void LossParameter::ArenaDtor(void* object) { LossParameter* _this = reinterpret_cast< LossParameter* >(object); (void)_this; } void LossParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void LossParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void LossParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.LossParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { ::memset(&ignore_label_, 0, static_cast( reinterpret_cast(&normalize_) - reinterpret_cast(&ignore_label_)) + sizeof(normalize_)); normalization_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* LossParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional int32 ignore_label = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_ignore_label(&has_bits); ignore_label_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool normalize = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_normalize(&has_bits); normalize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::LossParameter_NormalizationMode_IsValid(val))) { _internal_set_normalization(static_cast<::opencv_caffe::LossParameter_NormalizationMode>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* LossParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LossParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional int32 ignore_label = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_ignore_label(), target); } // optional bool normalize = 2; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_normalize(), target); } // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_normalization(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LossParameter) return target; } size_t LossParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LossParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional int32 ignore_label = 1; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_ignore_label()); } // optional bool normalize = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + 1; } // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_normalization()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LossParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, LossParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LossParameter::GetClassData() const { return &_class_data_; } void LossParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void LossParameter::MergeFrom(const LossParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LossParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { ignore_label_ = from.ignore_label_; } if (cached_has_bits & 0x00000002u) { normalize_ = from.normalize_; } if (cached_has_bits & 0x00000004u) { normalization_ = from.normalization_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void LossParameter::CopyFrom(const LossParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LossParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool LossParameter::IsInitialized() const { return true; } void LossParameter::InternalSwap(LossParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(LossParameter, normalize_) + sizeof(LossParameter::normalize_) - PROTOBUF_FIELD_OFFSET(LossParameter, ignore_label_)>( reinterpret_cast(&ignore_label_), reinterpret_cast(&other->ignore_label_)); swap(normalization_, other->normalization_); } ::PROTOBUF_NAMESPACE_ID::Metadata LossParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[17]); } // =================================================================== class AccuracyParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_top_k(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_ignore_label(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; AccuracyParameter::AccuracyParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.AccuracyParameter) } AccuracyParameter::AccuracyParameter(const AccuracyParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&ignore_label_, &from.ignore_label_, static_cast(reinterpret_cast(&axis_) - reinterpret_cast(&ignore_label_)) + sizeof(axis_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.AccuracyParameter) } inline void AccuracyParameter::SharedCtor() { ignore_label_ = 0; top_k_ = 1u; axis_ = 1; } AccuracyParameter::~AccuracyParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.AccuracyParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void AccuracyParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void AccuracyParameter::ArenaDtor(void* object) { AccuracyParameter* _this = reinterpret_cast< AccuracyParameter* >(object); (void)_this; } void AccuracyParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void AccuracyParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void AccuracyParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.AccuracyParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { ignore_label_ = 0; top_k_ = 1u; axis_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* AccuracyParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 top_k = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_top_k(&has_bits); top_k_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 axis = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 ignore_label = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_ignore_label(&has_bits); ignore_label_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* AccuracyParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.AccuracyParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 top_k = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_top_k(), target); } // optional int32 axis = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); } // optional int32 ignore_label = 3; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_ignore_label(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.AccuracyParameter) return target; } size_t AccuracyParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.AccuracyParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional int32 ignore_label = 3; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_ignore_label()); } // optional uint32 top_k = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_top_k()); } // optional int32 axis = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AccuracyParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, AccuracyParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AccuracyParameter::GetClassData() const { return &_class_data_; } void AccuracyParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void AccuracyParameter::MergeFrom(const AccuracyParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.AccuracyParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { ignore_label_ = from.ignore_label_; } if (cached_has_bits & 0x00000002u) { top_k_ = from.top_k_; } if (cached_has_bits & 0x00000004u) { axis_ = from.axis_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void AccuracyParameter::CopyFrom(const AccuracyParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.AccuracyParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool AccuracyParameter::IsInitialized() const { return true; } void AccuracyParameter::InternalSwap(AccuracyParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(ignore_label_, other->ignore_label_); swap(top_k_, other->top_k_); swap(axis_, other->axis_); } ::PROTOBUF_NAMESPACE_ID::Metadata AccuracyParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[18]); } // =================================================================== class ArgMaxParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_out_max_val(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_top_k(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; ArgMaxParameter::ArgMaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ArgMaxParameter) } ArgMaxParameter::ArgMaxParameter(const ArgMaxParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&out_max_val_, &from.out_max_val_, static_cast(reinterpret_cast(&top_k_) - reinterpret_cast(&out_max_val_)) + sizeof(top_k_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ArgMaxParameter) } inline void ArgMaxParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&out_max_val_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&axis_) - reinterpret_cast(&out_max_val_)) + sizeof(axis_)); top_k_ = 1u; } ArgMaxParameter::~ArgMaxParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ArgMaxParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ArgMaxParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ArgMaxParameter::ArenaDtor(void* object) { ArgMaxParameter* _this = reinterpret_cast< ArgMaxParameter* >(object); (void)_this; } void ArgMaxParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ArgMaxParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ArgMaxParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ArgMaxParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { ::memset(&out_max_val_, 0, static_cast( reinterpret_cast(&axis_) - reinterpret_cast(&out_max_val_)) + sizeof(axis_)); top_k_ = 1u; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ArgMaxParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional bool out_max_val = 1 [default = false]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_out_max_val(&has_bits); out_max_val_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 top_k = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_top_k(&has_bits); top_k_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 axis = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ArgMaxParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ArgMaxParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional bool out_max_val = 1 [default = false]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_out_max_val(), target); } // optional uint32 top_k = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_top_k(), target); } // optional int32 axis = 3; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_axis(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ArgMaxParameter) return target; } size_t ArgMaxParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ArgMaxParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional bool out_max_val = 1 [default = false]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 1; } // optional int32 axis = 3; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } // optional uint32 top_k = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_top_k()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ArgMaxParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ArgMaxParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ArgMaxParameter::GetClassData() const { return &_class_data_; } void ArgMaxParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ArgMaxParameter::MergeFrom(const ArgMaxParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ArgMaxParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { out_max_val_ = from.out_max_val_; } if (cached_has_bits & 0x00000002u) { axis_ = from.axis_; } if (cached_has_bits & 0x00000004u) { top_k_ = from.top_k_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ArgMaxParameter::CopyFrom(const ArgMaxParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ArgMaxParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ArgMaxParameter::IsInitialized() const { return true; } void ArgMaxParameter::InternalSwap(ArgMaxParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ArgMaxParameter, axis_) + sizeof(ArgMaxParameter::axis_) - PROTOBUF_FIELD_OFFSET(ArgMaxParameter, out_max_val_)>( reinterpret_cast(&out_max_val_), reinterpret_cast(&other->out_max_val_)); swap(top_k_, other->top_k_); } ::PROTOBUF_NAMESPACE_ID::Metadata ArgMaxParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[19]); } // =================================================================== class ConcatParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_concat_dim(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; ConcatParameter::ConcatParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ConcatParameter) } ConcatParameter::ConcatParameter(const ConcatParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&concat_dim_, &from.concat_dim_, static_cast(reinterpret_cast(&axis_) - reinterpret_cast(&concat_dim_)) + sizeof(axis_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ConcatParameter) } inline void ConcatParameter::SharedCtor() { concat_dim_ = 1u; axis_ = 1; } ConcatParameter::~ConcatParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ConcatParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ConcatParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ConcatParameter::ArenaDtor(void* object) { ConcatParameter* _this = reinterpret_cast< ConcatParameter* >(object); (void)_this; } void ConcatParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ConcatParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ConcatParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ConcatParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { concat_dim_ = 1u; axis_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ConcatParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 concat_dim = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_concat_dim(&has_bits); concat_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 axis = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ConcatParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ConcatParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 concat_dim = 1 [default = 1]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_concat_dim(), target); } // optional int32 axis = 2 [default = 1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ConcatParameter) return target; } size_t ConcatParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ConcatParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional uint32 concat_dim = 1 [default = 1]; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_concat_dim()); } // optional int32 axis = 2 [default = 1]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ConcatParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ConcatParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ConcatParameter::GetClassData() const { return &_class_data_; } void ConcatParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ConcatParameter::MergeFrom(const ConcatParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ConcatParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { concat_dim_ = from.concat_dim_; } if (cached_has_bits & 0x00000002u) { axis_ = from.axis_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ConcatParameter::CopyFrom(const ConcatParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ConcatParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ConcatParameter::IsInitialized() const { return true; } void ConcatParameter::InternalSwap(ConcatParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(concat_dim_, other->concat_dim_); swap(axis_, other->axis_); } ::PROTOBUF_NAMESPACE_ID::Metadata ConcatParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[20]); } // =================================================================== class BatchNormParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_use_global_stats(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_moving_average_fraction(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_eps(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_scale_bias(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; BatchNormParameter::BatchNormParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.BatchNormParameter) } BatchNormParameter::BatchNormParameter(const BatchNormParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&use_global_stats_, &from.use_global_stats_, static_cast(reinterpret_cast(&eps_) - reinterpret_cast(&use_global_stats_)) + sizeof(eps_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.BatchNormParameter) } inline void BatchNormParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&use_global_stats_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&scale_bias_) - reinterpret_cast(&use_global_stats_)) + sizeof(scale_bias_)); moving_average_fraction_ = 0.999f; eps_ = 1e-05f; } BatchNormParameter::~BatchNormParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.BatchNormParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void BatchNormParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void BatchNormParameter::ArenaDtor(void* object) { BatchNormParameter* _this = reinterpret_cast< BatchNormParameter* >(object); (void)_this; } void BatchNormParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void BatchNormParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void BatchNormParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.BatchNormParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&use_global_stats_, 0, static_cast( reinterpret_cast(&scale_bias_) - reinterpret_cast(&use_global_stats_)) + sizeof(scale_bias_)); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000cu) { moving_average_fraction_ = 0.999f; eps_ = 1e-05f; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* BatchNormParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional bool use_global_stats = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_use_global_stats(&has_bits); use_global_stats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float moving_average_fraction = 2 [default = 0.999]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_moving_average_fraction(&has_bits); moving_average_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float eps = 3 [default = 1e-05]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_eps(&has_bits); eps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional bool scale_bias = 7 [default = false]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_scale_bias(&has_bits); scale_bias_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* BatchNormParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BatchNormParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional bool use_global_stats = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_use_global_stats(), target); } // optional float moving_average_fraction = 2 [default = 0.999]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_moving_average_fraction(), target); } // optional float eps = 3 [default = 1e-05]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_eps(), target); } // optional bool scale_bias = 7 [default = false]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_scale_bias(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BatchNormParameter) return target; } size_t BatchNormParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BatchNormParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000fu) { // optional bool use_global_stats = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + 1; } // optional bool scale_bias = 7 [default = false]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 1; } // optional float moving_average_fraction = 2 [default = 0.999]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } // optional float eps = 3 [default = 1e-05]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BatchNormParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, BatchNormParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BatchNormParameter::GetClassData() const { return &_class_data_; } void BatchNormParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void BatchNormParameter::MergeFrom(const BatchNormParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BatchNormParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { use_global_stats_ = from.use_global_stats_; } if (cached_has_bits & 0x00000002u) { scale_bias_ = from.scale_bias_; } if (cached_has_bits & 0x00000004u) { moving_average_fraction_ = from.moving_average_fraction_; } if (cached_has_bits & 0x00000008u) { eps_ = from.eps_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void BatchNormParameter::CopyFrom(const BatchNormParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BatchNormParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool BatchNormParameter::IsInitialized() const { return true; } void BatchNormParameter::InternalSwap(BatchNormParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(BatchNormParameter, scale_bias_) + sizeof(BatchNormParameter::scale_bias_) - PROTOBUF_FIELD_OFFSET(BatchNormParameter, use_global_stats_)>( reinterpret_cast(&use_global_stats_), reinterpret_cast(&other->use_global_stats_)); swap(moving_average_fraction_, other->moving_average_fraction_); swap(eps_, other->eps_); } ::PROTOBUF_NAMESPACE_ID::Metadata BatchNormParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[21]); } // =================================================================== class BiasParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_num_axes(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static const ::opencv_caffe::FillerParameter& filler(const BiasParameter* msg); static void set_has_filler(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; const ::opencv_caffe::FillerParameter& BiasParameter::_Internal::filler(const BiasParameter* msg) { return *msg->filler_; } BiasParameter::BiasParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.BiasParameter) } BiasParameter::BiasParameter(const BiasParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_filler()) { filler_ = new ::opencv_caffe::FillerParameter(*from.filler_); } else { filler_ = nullptr; } ::memcpy(&axis_, &from.axis_, static_cast(reinterpret_cast(&num_axes_) - reinterpret_cast(&axis_)) + sizeof(num_axes_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.BiasParameter) } inline void BiasParameter::SharedCtor() { filler_ = nullptr; axis_ = 1; num_axes_ = 1; } BiasParameter::~BiasParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.BiasParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void BiasParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete filler_; } void BiasParameter::ArenaDtor(void* object) { BiasParameter* _this = reinterpret_cast< BiasParameter* >(object); (void)_this; } void BiasParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void BiasParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void BiasParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.BiasParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(filler_ != nullptr); filler_->Clear(); } axis_ = 1; num_axes_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* BiasParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional int32 axis = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 num_axes = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_num_axes(&has_bits); num_axes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter filler = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* BiasParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BiasParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional int32 axis = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); } // optional int32 num_axes = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_num_axes(), target); } // optional .opencv_caffe.FillerParameter filler = 3; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 3, _Internal::filler(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BiasParameter) return target; } size_t BiasParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BiasParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional .opencv_caffe.FillerParameter filler = 3; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *filler_); } // optional int32 axis = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } // optional int32 num_axes = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_axes()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BiasParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, BiasParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BiasParameter::GetClassData() const { return &_class_data_; } void BiasParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void BiasParameter::MergeFrom(const BiasParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BiasParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { _internal_mutable_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_filler()); } if (cached_has_bits & 0x00000002u) { axis_ = from.axis_; } if (cached_has_bits & 0x00000004u) { num_axes_ = from.num_axes_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void BiasParameter::CopyFrom(const BiasParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BiasParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool BiasParameter::IsInitialized() const { return true; } void BiasParameter::InternalSwap(BiasParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(filler_, other->filler_); swap(axis_, other->axis_); swap(num_axes_, other->num_axes_); } ::PROTOBUF_NAMESPACE_ID::Metadata BiasParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[22]); } // =================================================================== class ContrastiveLossParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_margin(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_legacy_version(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; ContrastiveLossParameter::ContrastiveLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ContrastiveLossParameter) } ContrastiveLossParameter::ContrastiveLossParameter(const ContrastiveLossParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&legacy_version_, &from.legacy_version_, static_cast(reinterpret_cast(&margin_) - reinterpret_cast(&legacy_version_)) + sizeof(margin_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ContrastiveLossParameter) } inline void ContrastiveLossParameter::SharedCtor() { legacy_version_ = false; margin_ = 1; } ContrastiveLossParameter::~ContrastiveLossParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ContrastiveLossParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ContrastiveLossParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ContrastiveLossParameter::ArenaDtor(void* object) { ContrastiveLossParameter* _this = reinterpret_cast< ContrastiveLossParameter* >(object); (void)_this; } void ContrastiveLossParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ContrastiveLossParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ContrastiveLossParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ContrastiveLossParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { legacy_version_ = false; margin_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ContrastiveLossParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float margin = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_margin(&has_bits); margin_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional bool legacy_version = 2 [default = false]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_legacy_version(&has_bits); legacy_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ContrastiveLossParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ContrastiveLossParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float margin = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_margin(), target); } // optional bool legacy_version = 2 [default = false]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_legacy_version(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ContrastiveLossParameter) return target; } size_t ContrastiveLossParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ContrastiveLossParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional bool legacy_version = 2 [default = false]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 1; } // optional float margin = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContrastiveLossParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ContrastiveLossParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContrastiveLossParameter::GetClassData() const { return &_class_data_; } void ContrastiveLossParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ContrastiveLossParameter::MergeFrom(const ContrastiveLossParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ContrastiveLossParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { legacy_version_ = from.legacy_version_; } if (cached_has_bits & 0x00000002u) { margin_ = from.margin_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ContrastiveLossParameter::CopyFrom(const ContrastiveLossParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ContrastiveLossParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ContrastiveLossParameter::IsInitialized() const { return true; } void ContrastiveLossParameter::InternalSwap(ContrastiveLossParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(legacy_version_, other->legacy_version_); swap(margin_, other->margin_); } ::PROTOBUF_NAMESPACE_ID::Metadata ContrastiveLossParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[23]); } // =================================================================== class ConvolutionParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_num_output(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_bias_term(HasBits* has_bits) { (*has_bits)[0] |= 4096u; } static void set_has_pad_h(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_pad_w(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_kernel_h(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_kernel_w(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_stride_h(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static void set_has_stride_w(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static void set_has_group(HasBits* has_bits) { (*has_bits)[0] |= 8192u; } static const ::opencv_caffe::FillerParameter& weight_filler(const ConvolutionParameter* msg); static void set_has_weight_filler(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static const ::opencv_caffe::FillerParameter& bias_filler(const ConvolutionParameter* msg); static void set_has_bias_filler(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_engine(HasBits* has_bits) { (*has_bits)[0] |= 512u; } static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 2048u; } static void set_has_force_nd_im2col(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } }; const ::opencv_caffe::FillerParameter& ConvolutionParameter::_Internal::weight_filler(const ConvolutionParameter* msg) { return *msg->weight_filler_; } const ::opencv_caffe::FillerParameter& ConvolutionParameter::_Internal::bias_filler(const ConvolutionParameter* msg) { return *msg->bias_filler_; } ConvolutionParameter::ConvolutionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), pad_(arena), kernel_size_(arena), stride_(arena), dilation_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ConvolutionParameter) } ConvolutionParameter::ConvolutionParameter(const ConvolutionParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), pad_(from.pad_), kernel_size_(from.kernel_size_), stride_(from.stride_), dilation_(from.dilation_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_weight_filler()) { weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); } else { weight_filler_ = nullptr; } if (from._internal_has_bias_filler()) { bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); } else { bias_filler_ = nullptr; } ::memcpy(&num_output_, &from.num_output_, static_cast(reinterpret_cast(&group_) - reinterpret_cast(&num_output_)) + sizeof(group_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ConvolutionParameter) } inline void ConvolutionParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&force_nd_im2col_) - reinterpret_cast(&weight_filler_)) + sizeof(force_nd_im2col_)); axis_ = 1; bias_term_ = true; group_ = 1u; } ConvolutionParameter::~ConvolutionParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ConvolutionParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ConvolutionParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete weight_filler_; if (this != internal_default_instance()) delete bias_filler_; } void ConvolutionParameter::ArenaDtor(void* object) { ConvolutionParameter* _this = reinterpret_cast< ConvolutionParameter* >(object); (void)_this; } void ConvolutionParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ConvolutionParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ConvolutionParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ConvolutionParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; pad_.Clear(); kernel_size_.Clear(); stride_.Clear(); dilation_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(weight_filler_ != nullptr); weight_filler_->Clear(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(bias_filler_ != nullptr); bias_filler_->Clear(); } } if (cached_has_bits & 0x000000fcu) { ::memset(&num_output_, 0, static_cast( reinterpret_cast(&stride_h_) - reinterpret_cast(&num_output_)) + sizeof(stride_h_)); } if (cached_has_bits & 0x00003f00u) { ::memset(&stride_w_, 0, static_cast( reinterpret_cast(&force_nd_im2col_) - reinterpret_cast(&stride_w_)) + sizeof(force_nd_im2col_)); axis_ = 1; bias_term_ = true; group_ = 1u; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ConvolutionParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 num_output = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_num_output(&has_bits); num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool bias_term = 2 [default = true]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_bias_term(&has_bits); bias_term_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated uint32 pad = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { ptr -= 1; do { ptr += 1; _internal_add_pad(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); } else if (static_cast(tag) == 26) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_pad(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated uint32 kernel_size = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { ptr -= 1; do { ptr += 1; _internal_add_kernel_size(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); } else if (static_cast(tag) == 34) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_kernel_size(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 group = 5 [default = 1]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_group(&has_bits); group_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated uint32 stride = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { ptr -= 1; do { ptr += 1; _internal_add_stride(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<48>(ptr)); } else if (static_cast(tag) == 50) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_stride(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter weight_filler = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter bias_filler = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 pad_h = 9 [default = 0]; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { _Internal::set_has_pad_h(&has_bits); pad_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 pad_w = 10 [default = 0]; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { _Internal::set_has_pad_w(&has_bits); pad_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 kernel_h = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { _Internal::set_has_kernel_h(&has_bits); kernel_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 kernel_w = 12; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { _Internal::set_has_kernel_w(&has_bits); kernel_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 stride_h = 13; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { _Internal::set_has_stride_h(&has_bits); stride_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 stride_w = 14; case 14: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { _Internal::set_has_stride_w(&has_bits); stride_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; case 15: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::ConvolutionParameter_Engine_IsValid(val))) { _internal_set_engine(static_cast<::opencv_caffe::ConvolutionParameter_Engine>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional int32 axis = 16 [default = 1]; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool force_nd_im2col = 17 [default = false]; case 17: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { _Internal::set_has_force_nd_im2col(&has_bits); force_nd_im2col_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated uint32 dilation = 18; case 18: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { ptr -= 2; do { ptr += 2; _internal_add_dilation(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<144>(ptr)); } else if (static_cast(tag) == 146) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_dilation(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ConvolutionParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ConvolutionParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 num_output = 1; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_output(), target); } // optional bool bias_term = 2 [default = true]; if (cached_has_bits & 0x00001000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_bias_term(), target); } // repeated uint32 pad = 3; for (int i = 0, n = this->_internal_pad_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_pad(i), target); } // repeated uint32 kernel_size = 4; for (int i = 0, n = this->_internal_kernel_size_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_kernel_size(i), target); } // optional uint32 group = 5 [default = 1]; if (cached_has_bits & 0x00002000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_group(), target); } // repeated uint32 stride = 6; for (int i = 0, n = this->_internal_stride_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_stride(i), target); } // optional .opencv_caffe.FillerParameter weight_filler = 7; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 7, _Internal::weight_filler(this), target, stream); } // optional .opencv_caffe.FillerParameter bias_filler = 8; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 8, _Internal::bias_filler(this), target, stream); } // optional uint32 pad_h = 9 [default = 0]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_pad_h(), target); } // optional uint32 pad_w = 10 [default = 0]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_pad_w(), target); } // optional uint32 kernel_h = 11; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(11, this->_internal_kernel_h(), target); } // optional uint32 kernel_w = 12; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(12, this->_internal_kernel_w(), target); } // optional uint32 stride_h = 13; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(13, this->_internal_stride_h(), target); } // optional uint32 stride_w = 14; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(14, this->_internal_stride_w(), target); } // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 15, this->_internal_engine(), target); } // optional int32 axis = 16 [default = 1]; if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(16, this->_internal_axis(), target); } // optional bool force_nd_im2col = 17 [default = false]; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(17, this->_internal_force_nd_im2col(), target); } // repeated uint32 dilation = 18; for (int i = 0, n = this->_internal_dilation_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(18, this->_internal_dilation(i), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ConvolutionParameter) return target; } size_t ConvolutionParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ConvolutionParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated uint32 pad = 3; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->pad_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_pad_size()); total_size += data_size; } // repeated uint32 kernel_size = 4; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->kernel_size_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_kernel_size_size()); total_size += data_size; } // repeated uint32 stride = 6; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->stride_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_stride_size()); total_size += data_size; } // repeated uint32 dilation = 18; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->dilation_); total_size += 2 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_dilation_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional .opencv_caffe.FillerParameter weight_filler = 7; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *weight_filler_); } // optional .opencv_caffe.FillerParameter bias_filler = 8; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *bias_filler_); } // optional uint32 num_output = 1; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); } // optional uint32 pad_h = 9 [default = 0]; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad_h()); } // optional uint32 pad_w = 10 [default = 0]; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad_w()); } // optional uint32 kernel_h = 11; if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_h()); } // optional uint32 kernel_w = 12; if (cached_has_bits & 0x00000040u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_w()); } // optional uint32 stride_h = 13; if (cached_has_bits & 0x00000080u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride_h()); } } if (cached_has_bits & 0x00003f00u) { // optional uint32 stride_w = 14; if (cached_has_bits & 0x00000100u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride_w()); } // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; if (cached_has_bits & 0x00000200u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); } // optional bool force_nd_im2col = 17 [default = false]; if (cached_has_bits & 0x00000400u) { total_size += 2 + 1; } // optional int32 axis = 16 [default = 1]; if (cached_has_bits & 0x00000800u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( this->_internal_axis()); } // optional bool bias_term = 2 [default = true]; if (cached_has_bits & 0x00001000u) { total_size += 1 + 1; } // optional uint32 group = 5 [default = 1]; if (cached_has_bits & 0x00002000u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_group()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ConvolutionParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ConvolutionParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ConvolutionParameter::GetClassData() const { return &_class_data_; } void ConvolutionParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ConvolutionParameter::MergeFrom(const ConvolutionParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ConvolutionParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; pad_.MergeFrom(from.pad_); kernel_size_.MergeFrom(from.kernel_size_); stride_.MergeFrom(from.stride_); dilation_.MergeFrom(from.dilation_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); } if (cached_has_bits & 0x00000004u) { num_output_ = from.num_output_; } if (cached_has_bits & 0x00000008u) { pad_h_ = from.pad_h_; } if (cached_has_bits & 0x00000010u) { pad_w_ = from.pad_w_; } if (cached_has_bits & 0x00000020u) { kernel_h_ = from.kernel_h_; } if (cached_has_bits & 0x00000040u) { kernel_w_ = from.kernel_w_; } if (cached_has_bits & 0x00000080u) { stride_h_ = from.stride_h_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0x00003f00u) { if (cached_has_bits & 0x00000100u) { stride_w_ = from.stride_w_; } if (cached_has_bits & 0x00000200u) { engine_ = from.engine_; } if (cached_has_bits & 0x00000400u) { force_nd_im2col_ = from.force_nd_im2col_; } if (cached_has_bits & 0x00000800u) { axis_ = from.axis_; } if (cached_has_bits & 0x00001000u) { bias_term_ = from.bias_term_; } if (cached_has_bits & 0x00002000u) { group_ = from.group_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ConvolutionParameter::CopyFrom(const ConvolutionParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ConvolutionParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ConvolutionParameter::IsInitialized() const { return true; } void ConvolutionParameter::InternalSwap(ConvolutionParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); pad_.InternalSwap(&other->pad_); kernel_size_.InternalSwap(&other->kernel_size_); stride_.InternalSwap(&other->stride_); dilation_.InternalSwap(&other->dilation_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ConvolutionParameter, force_nd_im2col_) + sizeof(ConvolutionParameter::force_nd_im2col_) - PROTOBUF_FIELD_OFFSET(ConvolutionParameter, weight_filler_)>( reinterpret_cast(&weight_filler_), reinterpret_cast(&other->weight_filler_)); swap(axis_, other->axis_); swap(bias_term_, other->bias_term_); swap(group_, other->group_); } ::PROTOBUF_NAMESPACE_ID::Metadata ConvolutionParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[24]); } // =================================================================== class CropParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; CropParameter::CropParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), offset_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.CropParameter) } CropParameter::CropParameter(const CropParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), offset_(from.offset_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); axis_ = from.axis_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.CropParameter) } inline void CropParameter::SharedCtor() { axis_ = 2; } CropParameter::~CropParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.CropParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void CropParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void CropParameter::ArenaDtor(void* object) { CropParameter* _this = reinterpret_cast< CropParameter* >(object); (void)_this; } void CropParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void CropParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void CropParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.CropParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; offset_.Clear(); axis_ = 2; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* CropParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional int32 axis = 1 [default = 2]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated uint32 offset = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { ptr -= 1; do { ptr += 1; _internal_add_offset(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr)); } else if (static_cast(tag) == 18) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_offset(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* CropParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.CropParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional int32 axis = 1 [default = 2]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); } // repeated uint32 offset = 2; for (int i = 0, n = this->_internal_offset_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_offset(i), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.CropParameter) return target; } size_t CropParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.CropParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated uint32 offset = 2; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->offset_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_offset_size()); total_size += data_size; } // optional int32 axis = 1 [default = 2]; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CropParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, CropParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CropParameter::GetClassData() const { return &_class_data_; } void CropParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void CropParameter::MergeFrom(const CropParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.CropParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; offset_.MergeFrom(from.offset_); if (from._internal_has_axis()) { _internal_set_axis(from._internal_axis()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void CropParameter::CopyFrom(const CropParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.CropParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool CropParameter::IsInitialized() const { return true; } void CropParameter::InternalSwap(CropParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); offset_.InternalSwap(&other->offset_); swap(axis_, other->axis_); } ::PROTOBUF_NAMESPACE_ID::Metadata CropParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[25]); } // =================================================================== class DataParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_source(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_batch_size(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_rand_skip(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_backend(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static void set_has_scale(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static void set_has_mean_file(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_crop_size(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_mirror(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_force_encoded_color(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_prefetch(HasBits* has_bits) { (*has_bits)[0] |= 512u; } }; DataParameter::DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.DataParameter) } DataParameter::DataParameter(const DataParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_source()) { source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), GetArenaForAllocation()); } mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_mean_file()) { mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mean_file(), GetArenaForAllocation()); } ::memcpy(&batch_size_, &from.batch_size_, static_cast(reinterpret_cast(&prefetch_) - reinterpret_cast(&batch_size_)) + sizeof(prefetch_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.DataParameter) } inline void DataParameter::SharedCtor() { source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&batch_size_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&backend_) - reinterpret_cast(&batch_size_)) + sizeof(backend_)); scale_ = 1; prefetch_ = 4u; } DataParameter::~DataParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.DataParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void DataParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); mean_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void DataParameter::ArenaDtor(void* object) { DataParameter* _this = reinterpret_cast< DataParameter* >(object); (void)_this; } void DataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void DataParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void DataParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.DataParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { source_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { mean_file_.ClearNonDefaultToEmpty(); } } if (cached_has_bits & 0x000000fcu) { ::memset(&batch_size_, 0, static_cast( reinterpret_cast(&backend_) - reinterpret_cast(&batch_size_)) + sizeof(backend_)); } if (cached_has_bits & 0x00000300u) { scale_ = 1; prefetch_ = 4u; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* DataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string source = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_source(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.DataParameter.source"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional float scale = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_scale(&has_bits); scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional string mean_file = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_mean_file(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.DataParameter.mean_file"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 batch_size = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_batch_size(&has_bits); batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 crop_size = 5 [default = 0]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_crop_size(&has_bits); crop_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool mirror = 6 [default = false]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_mirror(&has_bits); mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 rand_skip = 7 [default = 0]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_rand_skip(&has_bits); rand_skip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB]; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::DataParameter_DB_IsValid(val))) { _internal_set_backend(static_cast<::opencv_caffe::DataParameter_DB>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional bool force_encoded_color = 9 [default = false]; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { _Internal::set_has_force_encoded_color(&has_bits); force_encoded_color_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 prefetch = 10 [default = 4]; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { _Internal::set_has_prefetch(&has_bits); prefetch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* DataParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DataParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string source = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_source().data(), static_cast(this->_internal_source().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.DataParameter.source"); target = stream->WriteStringMaybeAliased( 1, this->_internal_source(), target); } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); } // optional string mean_file = 3; if (cached_has_bits & 0x00000002u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_mean_file().data(), static_cast(this->_internal_mean_file().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.DataParameter.mean_file"); target = stream->WriteStringMaybeAliased( 3, this->_internal_mean_file(), target); } // optional uint32 batch_size = 4; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_batch_size(), target); } // optional uint32 crop_size = 5 [default = 0]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_crop_size(), target); } // optional bool mirror = 6 [default = false]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_mirror(), target); } // optional uint32 rand_skip = 7 [default = 0]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_rand_skip(), target); } // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB]; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 8, this->_internal_backend(), target); } // optional bool force_encoded_color = 9 [default = false]; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(9, this->_internal_force_encoded_color(), target); } // optional uint32 prefetch = 10 [default = 4]; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_prefetch(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DataParameter) return target; } size_t DataParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DataParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional string source = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_source()); } // optional string mean_file = 3; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_mean_file()); } // optional uint32 batch_size = 4; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); } // optional uint32 crop_size = 5 [default = 0]; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_crop_size()); } // optional uint32 rand_skip = 7 [default = 0]; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_rand_skip()); } // optional bool mirror = 6 [default = false]; if (cached_has_bits & 0x00000020u) { total_size += 1 + 1; } // optional bool force_encoded_color = 9 [default = false]; if (cached_has_bits & 0x00000040u) { total_size += 1 + 1; } // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB]; if (cached_has_bits & 0x00000080u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_backend()); } } if (cached_has_bits & 0x00000300u) { // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000100u) { total_size += 1 + 4; } // optional uint32 prefetch = 10 [default = 4]; if (cached_has_bits & 0x00000200u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_prefetch()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DataParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, DataParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DataParameter::GetClassData() const { return &_class_data_; } void DataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void DataParameter::MergeFrom(const DataParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DataParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_source(from._internal_source()); } if (cached_has_bits & 0x00000002u) { _internal_set_mean_file(from._internal_mean_file()); } if (cached_has_bits & 0x00000004u) { batch_size_ = from.batch_size_; } if (cached_has_bits & 0x00000008u) { crop_size_ = from.crop_size_; } if (cached_has_bits & 0x00000010u) { rand_skip_ = from.rand_skip_; } if (cached_has_bits & 0x00000020u) { mirror_ = from.mirror_; } if (cached_has_bits & 0x00000040u) { force_encoded_color_ = from.force_encoded_color_; } if (cached_has_bits & 0x00000080u) { backend_ = from.backend_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0x00000300u) { if (cached_has_bits & 0x00000100u) { scale_ = from.scale_; } if (cached_has_bits & 0x00000200u) { prefetch_ = from.prefetch_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DataParameter::CopyFrom(const DataParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DataParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool DataParameter::IsInitialized() const { return true; } void DataParameter::InternalSwap(DataParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &source_, lhs_arena, &other->source_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &mean_file_, lhs_arena, &other->mean_file_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DataParameter, backend_) + sizeof(DataParameter::backend_) - PROTOBUF_FIELD_OFFSET(DataParameter, batch_size_)>( reinterpret_cast(&batch_size_), reinterpret_cast(&other->batch_size_)); swap(scale_, other->scale_); swap(prefetch_, other->prefetch_); } ::PROTOBUF_NAMESPACE_ID::Metadata DataParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[26]); } // =================================================================== class NonMaximumSuppressionParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_nms_threshold(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_top_k(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_eta(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; NonMaximumSuppressionParameter::NonMaximumSuppressionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.NonMaximumSuppressionParameter) } NonMaximumSuppressionParameter::NonMaximumSuppressionParameter(const NonMaximumSuppressionParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&top_k_, &from.top_k_, static_cast(reinterpret_cast(&eta_) - reinterpret_cast(&top_k_)) + sizeof(eta_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.NonMaximumSuppressionParameter) } inline void NonMaximumSuppressionParameter::SharedCtor() { top_k_ = 0; nms_threshold_ = 0.3f; eta_ = 1; } NonMaximumSuppressionParameter::~NonMaximumSuppressionParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.NonMaximumSuppressionParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void NonMaximumSuppressionParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void NonMaximumSuppressionParameter::ArenaDtor(void* object) { NonMaximumSuppressionParameter* _this = reinterpret_cast< NonMaximumSuppressionParameter* >(object); (void)_this; } void NonMaximumSuppressionParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NonMaximumSuppressionParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void NonMaximumSuppressionParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.NonMaximumSuppressionParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { top_k_ = 0; nms_threshold_ = 0.3f; eta_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NonMaximumSuppressionParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float nms_threshold = 1 [default = 0.3]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_nms_threshold(&has_bits); nms_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional int32 top_k = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_top_k(&has_bits); top_k_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float eta = 3 [default = 1]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_eta(&has_bits); eta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* NonMaximumSuppressionParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NonMaximumSuppressionParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float nms_threshold = 1 [default = 0.3]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_nms_threshold(), target); } // optional int32 top_k = 2; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_top_k(), target); } // optional float eta = 3 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_eta(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NonMaximumSuppressionParameter) return target; } size_t NonMaximumSuppressionParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NonMaximumSuppressionParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional int32 top_k = 2; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_top_k()); } // optional float nms_threshold = 1 [default = 0.3]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 4; } // optional float eta = 3 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NonMaximumSuppressionParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, NonMaximumSuppressionParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NonMaximumSuppressionParameter::GetClassData() const { return &_class_data_; } void NonMaximumSuppressionParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void NonMaximumSuppressionParameter::MergeFrom(const NonMaximumSuppressionParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NonMaximumSuppressionParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { top_k_ = from.top_k_; } if (cached_has_bits & 0x00000002u) { nms_threshold_ = from.nms_threshold_; } if (cached_has_bits & 0x00000004u) { eta_ = from.eta_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void NonMaximumSuppressionParameter::CopyFrom(const NonMaximumSuppressionParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NonMaximumSuppressionParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool NonMaximumSuppressionParameter::IsInitialized() const { return true; } void NonMaximumSuppressionParameter::InternalSwap(NonMaximumSuppressionParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(top_k_, other->top_k_); swap(nms_threshold_, other->nms_threshold_); swap(eta_, other->eta_); } ::PROTOBUF_NAMESPACE_ID::Metadata NonMaximumSuppressionParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[27]); } // =================================================================== class SaveOutputParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_output_directory(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_output_name_prefix(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_output_format(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_label_map_file(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_name_size_file(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_num_test_image(HasBits* has_bits) { (*has_bits)[0] |= 32u; } }; SaveOutputParameter::SaveOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.SaveOutputParameter) } SaveOutputParameter::SaveOutputParameter(const SaveOutputParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); output_directory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING output_directory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_output_directory()) { output_directory_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_output_directory(), GetArenaForAllocation()); } output_name_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING output_name_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_output_name_prefix()) { output_name_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_output_name_prefix(), GetArenaForAllocation()); } output_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING output_format_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_output_format()) { output_format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_output_format(), GetArenaForAllocation()); } label_map_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_label_map_file()) { label_map_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_label_map_file(), GetArenaForAllocation()); } name_size_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_name_size_file()) { name_size_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name_size_file(), GetArenaForAllocation()); } num_test_image_ = from.num_test_image_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.SaveOutputParameter) } inline void SaveOutputParameter::SharedCtor() { output_directory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING output_directory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING output_name_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING output_name_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING output_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING output_format_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING label_map_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING label_map_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING name_size_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_size_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING num_test_image_ = 0u; } SaveOutputParameter::~SaveOutputParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.SaveOutputParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void SaveOutputParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); output_directory_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); output_name_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); output_format_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); label_map_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); name_size_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SaveOutputParameter::ArenaDtor(void* object) { SaveOutputParameter* _this = reinterpret_cast< SaveOutputParameter* >(object); (void)_this; } void SaveOutputParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SaveOutputParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void SaveOutputParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.SaveOutputParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000001fu) { if (cached_has_bits & 0x00000001u) { output_directory_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { output_name_prefix_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000004u) { output_format_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000008u) { label_map_file_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000010u) { name_size_file_.ClearNonDefaultToEmpty(); } } num_test_image_ = 0u; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SaveOutputParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string output_directory = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_output_directory(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.output_directory"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional string output_name_prefix = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_output_name_prefix(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.output_name_prefix"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional string output_format = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_output_format(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.output_format"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional string label_map_file = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { auto str = _internal_mutable_label_map_file(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.label_map_file"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional string name_size_file = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { auto str = _internal_mutable_name_size_file(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.SaveOutputParameter.name_size_file"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 num_test_image = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_num_test_image(&has_bits); num_test_image_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* SaveOutputParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SaveOutputParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string output_directory = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_output_directory().data(), static_cast(this->_internal_output_directory().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SaveOutputParameter.output_directory"); target = stream->WriteStringMaybeAliased( 1, this->_internal_output_directory(), target); } // optional string output_name_prefix = 2; if (cached_has_bits & 0x00000002u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_output_name_prefix().data(), static_cast(this->_internal_output_name_prefix().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SaveOutputParameter.output_name_prefix"); target = stream->WriteStringMaybeAliased( 2, this->_internal_output_name_prefix(), target); } // optional string output_format = 3; if (cached_has_bits & 0x00000004u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_output_format().data(), static_cast(this->_internal_output_format().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SaveOutputParameter.output_format"); target = stream->WriteStringMaybeAliased( 3, this->_internal_output_format(), target); } // optional string label_map_file = 4; if (cached_has_bits & 0x00000008u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_label_map_file().data(), static_cast(this->_internal_label_map_file().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SaveOutputParameter.label_map_file"); target = stream->WriteStringMaybeAliased( 4, this->_internal_label_map_file(), target); } // optional string name_size_file = 5; if (cached_has_bits & 0x00000010u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_name_size_file().data(), static_cast(this->_internal_name_size_file().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.SaveOutputParameter.name_size_file"); target = stream->WriteStringMaybeAliased( 5, this->_internal_name_size_file(), target); } // optional uint32 num_test_image = 6; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_num_test_image(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SaveOutputParameter) return target; } size_t SaveOutputParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SaveOutputParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000003fu) { // optional string output_directory = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_output_directory()); } // optional string output_name_prefix = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_output_name_prefix()); } // optional string output_format = 3; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_output_format()); } // optional string label_map_file = 4; if (cached_has_bits & 0x00000008u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_label_map_file()); } // optional string name_size_file = 5; if (cached_has_bits & 0x00000010u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name_size_file()); } // optional uint32 num_test_image = 6; if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_test_image()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SaveOutputParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, SaveOutputParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SaveOutputParameter::GetClassData() const { return &_class_data_; } void SaveOutputParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void SaveOutputParameter::MergeFrom(const SaveOutputParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SaveOutputParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { _internal_set_output_directory(from._internal_output_directory()); } if (cached_has_bits & 0x00000002u) { _internal_set_output_name_prefix(from._internal_output_name_prefix()); } if (cached_has_bits & 0x00000004u) { _internal_set_output_format(from._internal_output_format()); } if (cached_has_bits & 0x00000008u) { _internal_set_label_map_file(from._internal_label_map_file()); } if (cached_has_bits & 0x00000010u) { _internal_set_name_size_file(from._internal_name_size_file()); } if (cached_has_bits & 0x00000020u) { num_test_image_ = from.num_test_image_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SaveOutputParameter::CopyFrom(const SaveOutputParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SaveOutputParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool SaveOutputParameter::IsInitialized() const { return true; } void SaveOutputParameter::InternalSwap(SaveOutputParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &output_directory_, lhs_arena, &other->output_directory_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &output_name_prefix_, lhs_arena, &other->output_name_prefix_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &output_format_, lhs_arena, &other->output_format_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &label_map_file_, lhs_arena, &other->label_map_file_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &name_size_file_, lhs_arena, &other->name_size_file_, rhs_arena ); swap(num_test_image_, other->num_test_image_); } ::PROTOBUF_NAMESPACE_ID::Metadata SaveOutputParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[28]); } // =================================================================== class DropoutParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_dropout_ratio(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_scale_train(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; DropoutParameter::DropoutParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.DropoutParameter) } DropoutParameter::DropoutParameter(const DropoutParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&dropout_ratio_, &from.dropout_ratio_, static_cast(reinterpret_cast(&scale_train_) - reinterpret_cast(&dropout_ratio_)) + sizeof(scale_train_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.DropoutParameter) } inline void DropoutParameter::SharedCtor() { dropout_ratio_ = 0.5f; scale_train_ = true; } DropoutParameter::~DropoutParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.DropoutParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void DropoutParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void DropoutParameter::ArenaDtor(void* object) { DropoutParameter* _this = reinterpret_cast< DropoutParameter* >(object); (void)_this; } void DropoutParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void DropoutParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void DropoutParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.DropoutParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { dropout_ratio_ = 0.5f; scale_train_ = true; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* DropoutParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float dropout_ratio = 1 [default = 0.5]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_dropout_ratio(&has_bits); dropout_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional bool scale_train = 2 [default = true]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_scale_train(&has_bits); scale_train_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* DropoutParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DropoutParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float dropout_ratio = 1 [default = 0.5]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_dropout_ratio(), target); } // optional bool scale_train = 2 [default = true]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_scale_train(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DropoutParameter) return target; } size_t DropoutParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DropoutParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional float dropout_ratio = 1 [default = 0.5]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 4; } // optional bool scale_train = 2 [default = true]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DropoutParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, DropoutParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DropoutParameter::GetClassData() const { return &_class_data_; } void DropoutParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void DropoutParameter::MergeFrom(const DropoutParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DropoutParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { dropout_ratio_ = from.dropout_ratio_; } if (cached_has_bits & 0x00000002u) { scale_train_ = from.scale_train_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DropoutParameter::CopyFrom(const DropoutParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DropoutParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool DropoutParameter::IsInitialized() const { return true; } void DropoutParameter::InternalSwap(DropoutParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(dropout_ratio_, other->dropout_ratio_); swap(scale_train_, other->scale_train_); } ::PROTOBUF_NAMESPACE_ID::Metadata DropoutParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[29]); } // =================================================================== class DummyDataParameter::_Internal { public: }; DummyDataParameter::DummyDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), data_filler_(arena), num_(arena), channels_(arena), height_(arena), width_(arena), shape_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.DummyDataParameter) } DummyDataParameter::DummyDataParameter(const DummyDataParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), data_filler_(from.data_filler_), num_(from.num_), channels_(from.channels_), height_(from.height_), width_(from.width_), shape_(from.shape_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:opencv_caffe.DummyDataParameter) } inline void DummyDataParameter::SharedCtor() { } DummyDataParameter::~DummyDataParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.DummyDataParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void DummyDataParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void DummyDataParameter::ArenaDtor(void* object) { DummyDataParameter* _this = reinterpret_cast< DummyDataParameter* >(object); (void)_this; } void DummyDataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void DummyDataParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void DummyDataParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.DummyDataParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; data_filler_.Clear(); num_.Clear(); channels_.Clear(); height_.Clear(); width_.Clear(); shape_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* DummyDataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .opencv_caffe.FillerParameter data_filler = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_data_filler(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; // repeated uint32 num = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { ptr -= 1; do { ptr += 1; _internal_add_num(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr)); } else if (static_cast(tag) == 18) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_num(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated uint32 channels = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { ptr -= 1; do { ptr += 1; _internal_add_channels(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); } else if (static_cast(tag) == 26) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_channels(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated uint32 height = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { ptr -= 1; do { ptr += 1; _internal_add_height(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); } else if (static_cast(tag) == 34) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_height(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated uint32 width = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { ptr -= 1; do { ptr += 1; _internal_add_width(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<40>(ptr)); } else if (static_cast(tag) == 42) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_width(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated .opencv_caffe.BlobShape shape = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_shape(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* DummyDataParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DummyDataParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .opencv_caffe.FillerParameter data_filler = 1; for (unsigned int i = 0, n = static_cast(this->_internal_data_filler_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(1, this->_internal_data_filler(i), target, stream); } // repeated uint32 num = 2; for (int i = 0, n = this->_internal_num_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_num(i), target); } // repeated uint32 channels = 3; for (int i = 0, n = this->_internal_channels_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_channels(i), target); } // repeated uint32 height = 4; for (int i = 0, n = this->_internal_height_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_height(i), target); } // repeated uint32 width = 5; for (int i = 0, n = this->_internal_width_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_width(i), target); } // repeated .opencv_caffe.BlobShape shape = 6; for (unsigned int i = 0, n = static_cast(this->_internal_shape_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(6, this->_internal_shape(i), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DummyDataParameter) return target; } size_t DummyDataParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DummyDataParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated .opencv_caffe.FillerParameter data_filler = 1; total_size += 1UL * this->_internal_data_filler_size(); for (const auto& msg : this->data_filler_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated uint32 num = 2; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->num_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_num_size()); total_size += data_size; } // repeated uint32 channels = 3; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->channels_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_channels_size()); total_size += data_size; } // repeated uint32 height = 4; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->height_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_height_size()); total_size += data_size; } // repeated uint32 width = 5; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->width_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_width_size()); total_size += data_size; } // repeated .opencv_caffe.BlobShape shape = 6; total_size += 1UL * this->_internal_shape_size(); for (const auto& msg : this->shape_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DummyDataParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, DummyDataParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DummyDataParameter::GetClassData() const { return &_class_data_; } void DummyDataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void DummyDataParameter::MergeFrom(const DummyDataParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DummyDataParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; data_filler_.MergeFrom(from.data_filler_); num_.MergeFrom(from.num_); channels_.MergeFrom(from.channels_); height_.MergeFrom(from.height_); width_.MergeFrom(from.width_); shape_.MergeFrom(from.shape_); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DummyDataParameter::CopyFrom(const DummyDataParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DummyDataParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool DummyDataParameter::IsInitialized() const { return true; } void DummyDataParameter::InternalSwap(DummyDataParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); data_filler_.InternalSwap(&other->data_filler_); num_.InternalSwap(&other->num_); channels_.InternalSwap(&other->channels_); height_.InternalSwap(&other->height_); width_.InternalSwap(&other->width_); shape_.InternalSwap(&other->shape_); } ::PROTOBUF_NAMESPACE_ID::Metadata DummyDataParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[30]); } // =================================================================== class EltwiseParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_operation(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_stable_prod_grad(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; EltwiseParameter::EltwiseParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), coeff_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.EltwiseParameter) } EltwiseParameter::EltwiseParameter(const EltwiseParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), coeff_(from.coeff_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&operation_, &from.operation_, static_cast(reinterpret_cast(&stable_prod_grad_) - reinterpret_cast(&operation_)) + sizeof(stable_prod_grad_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.EltwiseParameter) } inline void EltwiseParameter::SharedCtor() { operation_ = 1; stable_prod_grad_ = true; } EltwiseParameter::~EltwiseParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.EltwiseParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void EltwiseParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void EltwiseParameter::ArenaDtor(void* object) { EltwiseParameter* _this = reinterpret_cast< EltwiseParameter* >(object); (void)_this; } void EltwiseParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void EltwiseParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void EltwiseParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.EltwiseParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; coeff_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { operation_ = 1; stable_prod_grad_ = true; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* EltwiseParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::EltwiseParameter_EltwiseOp_IsValid(val))) { _internal_set_operation(static_cast<::opencv_caffe::EltwiseParameter_EltwiseOp>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // repeated float coeff = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { ptr -= 1; do { ptr += 1; _internal_add_coeff(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<21>(ptr)); } else if (static_cast(tag) == 18) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_coeff(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional bool stable_prod_grad = 3 [default = true]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_stable_prod_grad(&has_bits); stable_prod_grad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* EltwiseParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.EltwiseParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_operation(), target); } // repeated float coeff = 2; for (int i = 0, n = this->_internal_coeff_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_coeff(i), target); } // optional bool stable_prod_grad = 3 [default = true]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_stable_prod_grad(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.EltwiseParameter) return target; } size_t EltwiseParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.EltwiseParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated float coeff = 2; { unsigned int count = static_cast(this->_internal_coeff_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_coeff_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_operation()); } // optional bool stable_prod_grad = 3 [default = true]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData EltwiseParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, EltwiseParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*EltwiseParameter::GetClassData() const { return &_class_data_; } void EltwiseParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void EltwiseParameter::MergeFrom(const EltwiseParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.EltwiseParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; coeff_.MergeFrom(from.coeff_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { operation_ = from.operation_; } if (cached_has_bits & 0x00000002u) { stable_prod_grad_ = from.stable_prod_grad_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void EltwiseParameter::CopyFrom(const EltwiseParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.EltwiseParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool EltwiseParameter::IsInitialized() const { return true; } void EltwiseParameter::InternalSwap(EltwiseParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); coeff_.InternalSwap(&other->coeff_); swap(operation_, other->operation_); swap(stable_prod_grad_, other->stable_prod_grad_); } ::PROTOBUF_NAMESPACE_ID::Metadata EltwiseParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[31]); } // =================================================================== class ELUParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_alpha(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; ELUParameter::ELUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ELUParameter) } ELUParameter::ELUParameter(const ELUParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); alpha_ = from.alpha_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.ELUParameter) } inline void ELUParameter::SharedCtor() { alpha_ = 1; } ELUParameter::~ELUParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ELUParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ELUParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ELUParameter::ArenaDtor(void* object) { ELUParameter* _this = reinterpret_cast< ELUParameter* >(object); (void)_this; } void ELUParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ELUParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ELUParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ELUParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; alpha_ = 1; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ELUParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float alpha = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_alpha(&has_bits); alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ELUParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ELUParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float alpha = 1 [default = 1]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_alpha(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ELUParameter) return target; } size_t ELUParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ELUParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional float alpha = 1 [default = 1]; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 4; } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ELUParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ELUParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ELUParameter::GetClassData() const { return &_class_data_; } void ELUParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ELUParameter::MergeFrom(const ELUParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ELUParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_has_alpha()) { _internal_set_alpha(from._internal_alpha()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ELUParameter::CopyFrom(const ELUParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ELUParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ELUParameter::IsInitialized() const { return true; } void ELUParameter::InternalSwap(ELUParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(alpha_, other->alpha_); } ::PROTOBUF_NAMESPACE_ID::Metadata ELUParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[32]); } // =================================================================== class EmbedParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_num_output(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_input_dim(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_bias_term(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static const ::opencv_caffe::FillerParameter& weight_filler(const EmbedParameter* msg); static void set_has_weight_filler(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static const ::opencv_caffe::FillerParameter& bias_filler(const EmbedParameter* msg); static void set_has_bias_filler(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; const ::opencv_caffe::FillerParameter& EmbedParameter::_Internal::weight_filler(const EmbedParameter* msg) { return *msg->weight_filler_; } const ::opencv_caffe::FillerParameter& EmbedParameter::_Internal::bias_filler(const EmbedParameter* msg) { return *msg->bias_filler_; } EmbedParameter::EmbedParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.EmbedParameter) } EmbedParameter::EmbedParameter(const EmbedParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_weight_filler()) { weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); } else { weight_filler_ = nullptr; } if (from._internal_has_bias_filler()) { bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); } else { bias_filler_ = nullptr; } ::memcpy(&num_output_, &from.num_output_, static_cast(reinterpret_cast(&bias_term_) - reinterpret_cast(&num_output_)) + sizeof(bias_term_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.EmbedParameter) } inline void EmbedParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&input_dim_) - reinterpret_cast(&weight_filler_)) + sizeof(input_dim_)); bias_term_ = true; } EmbedParameter::~EmbedParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.EmbedParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void EmbedParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete weight_filler_; if (this != internal_default_instance()) delete bias_filler_; } void EmbedParameter::ArenaDtor(void* object) { EmbedParameter* _this = reinterpret_cast< EmbedParameter* >(object); (void)_this; } void EmbedParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void EmbedParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void EmbedParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.EmbedParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(weight_filler_ != nullptr); weight_filler_->Clear(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(bias_filler_ != nullptr); bias_filler_->Clear(); } } if (cached_has_bits & 0x0000001cu) { ::memset(&num_output_, 0, static_cast( reinterpret_cast(&input_dim_) - reinterpret_cast(&num_output_)) + sizeof(input_dim_)); bias_term_ = true; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* EmbedParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 num_output = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_num_output(&has_bits); num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 input_dim = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_input_dim(&has_bits); input_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool bias_term = 3 [default = true]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_bias_term(&has_bits); bias_term_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter weight_filler = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter bias_filler = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* EmbedParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.EmbedParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 num_output = 1; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_output(), target); } // optional uint32 input_dim = 2; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_input_dim(), target); } // optional bool bias_term = 3 [default = true]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_bias_term(), target); } // optional .opencv_caffe.FillerParameter weight_filler = 4; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 4, _Internal::weight_filler(this), target, stream); } // optional .opencv_caffe.FillerParameter bias_filler = 5; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 5, _Internal::bias_filler(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.EmbedParameter) return target; } size_t EmbedParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.EmbedParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000001fu) { // optional .opencv_caffe.FillerParameter weight_filler = 4; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *weight_filler_); } // optional .opencv_caffe.FillerParameter bias_filler = 5; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *bias_filler_); } // optional uint32 num_output = 1; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); } // optional uint32 input_dim = 2; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_input_dim()); } // optional bool bias_term = 3 [default = true]; if (cached_has_bits & 0x00000010u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData EmbedParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, EmbedParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*EmbedParameter::GetClassData() const { return &_class_data_; } void EmbedParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void EmbedParameter::MergeFrom(const EmbedParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.EmbedParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000001fu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); } if (cached_has_bits & 0x00000004u) { num_output_ = from.num_output_; } if (cached_has_bits & 0x00000008u) { input_dim_ = from.input_dim_; } if (cached_has_bits & 0x00000010u) { bias_term_ = from.bias_term_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void EmbedParameter::CopyFrom(const EmbedParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.EmbedParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool EmbedParameter::IsInitialized() const { return true; } void EmbedParameter::InternalSwap(EmbedParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(EmbedParameter, input_dim_) + sizeof(EmbedParameter::input_dim_) - PROTOBUF_FIELD_OFFSET(EmbedParameter, weight_filler_)>( reinterpret_cast(&weight_filler_), reinterpret_cast(&other->weight_filler_)); swap(bias_term_, other->bias_term_); } ::PROTOBUF_NAMESPACE_ID::Metadata EmbedParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[33]); } // =================================================================== class ExpParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_base(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_scale(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_shift(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; ExpParameter::ExpParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ExpParameter) } ExpParameter::ExpParameter(const ExpParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&shift_, &from.shift_, static_cast(reinterpret_cast(&scale_) - reinterpret_cast(&shift_)) + sizeof(scale_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ExpParameter) } inline void ExpParameter::SharedCtor() { shift_ = 0; base_ = -1; scale_ = 1; } ExpParameter::~ExpParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ExpParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ExpParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ExpParameter::ArenaDtor(void* object) { ExpParameter* _this = reinterpret_cast< ExpParameter* >(object); (void)_this; } void ExpParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ExpParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ExpParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ExpParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { shift_ = 0; base_ = -1; scale_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ExpParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float base = 1 [default = -1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_base(&has_bits); base_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float scale = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_scale(&has_bits); scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float shift = 3 [default = 0]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_shift(&has_bits); shift_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ExpParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ExpParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float base = 1 [default = -1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_base(), target); } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); } // optional float shift = 3 [default = 0]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_shift(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ExpParameter) return target; } size_t ExpParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ExpParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional float shift = 3 [default = 0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 4; } // optional float base = 1 [default = -1]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 4; } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExpParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ExpParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExpParameter::GetClassData() const { return &_class_data_; } void ExpParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ExpParameter::MergeFrom(const ExpParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ExpParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { shift_ = from.shift_; } if (cached_has_bits & 0x00000002u) { base_ = from.base_; } if (cached_has_bits & 0x00000004u) { scale_ = from.scale_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ExpParameter::CopyFrom(const ExpParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ExpParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ExpParameter::IsInitialized() const { return true; } void ExpParameter::InternalSwap(ExpParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(shift_, other->shift_); swap(base_, other->base_); swap(scale_, other->scale_); } ::PROTOBUF_NAMESPACE_ID::Metadata ExpParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[34]); } // =================================================================== class FlattenParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_end_axis(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; FlattenParameter::FlattenParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.FlattenParameter) } FlattenParameter::FlattenParameter(const FlattenParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&axis_, &from.axis_, static_cast(reinterpret_cast(&end_axis_) - reinterpret_cast(&axis_)) + sizeof(end_axis_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.FlattenParameter) } inline void FlattenParameter::SharedCtor() { axis_ = 1; end_axis_ = -1; } FlattenParameter::~FlattenParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.FlattenParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void FlattenParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void FlattenParameter::ArenaDtor(void* object) { FlattenParameter* _this = reinterpret_cast< FlattenParameter* >(object); (void)_this; } void FlattenParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void FlattenParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void FlattenParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.FlattenParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { axis_ = 1; end_axis_ = -1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* FlattenParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional int32 axis = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 end_axis = 2 [default = -1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_end_axis(&has_bits); end_axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* FlattenParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.FlattenParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional int32 axis = 1 [default = 1]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); } // optional int32 end_axis = 2 [default = -1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end_axis(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.FlattenParameter) return target; } size_t FlattenParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.FlattenParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional int32 axis = 1 [default = 1]; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } // optional int32 end_axis = 2 [default = -1]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_end_axis()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FlattenParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, FlattenParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FlattenParameter::GetClassData() const { return &_class_data_; } void FlattenParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void FlattenParameter::MergeFrom(const FlattenParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.FlattenParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { axis_ = from.axis_; } if (cached_has_bits & 0x00000002u) { end_axis_ = from.end_axis_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FlattenParameter::CopyFrom(const FlattenParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.FlattenParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool FlattenParameter::IsInitialized() const { return true; } void FlattenParameter::InternalSwap(FlattenParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(axis_, other->axis_); swap(end_axis_, other->end_axis_); } ::PROTOBUF_NAMESPACE_ID::Metadata FlattenParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[35]); } // =================================================================== class HDF5DataParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_source(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_batch_size(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_shuffle(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; HDF5DataParameter::HDF5DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.HDF5DataParameter) } HDF5DataParameter::HDF5DataParameter(const HDF5DataParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_source()) { source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), GetArenaForAllocation()); } ::memcpy(&batch_size_, &from.batch_size_, static_cast(reinterpret_cast(&shuffle_) - reinterpret_cast(&batch_size_)) + sizeof(shuffle_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.HDF5DataParameter) } inline void HDF5DataParameter::SharedCtor() { source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&batch_size_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&shuffle_) - reinterpret_cast(&batch_size_)) + sizeof(shuffle_)); } HDF5DataParameter::~HDF5DataParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.HDF5DataParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void HDF5DataParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void HDF5DataParameter::ArenaDtor(void* object) { HDF5DataParameter* _this = reinterpret_cast< HDF5DataParameter* >(object); (void)_this; } void HDF5DataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void HDF5DataParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void HDF5DataParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.HDF5DataParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { source_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000006u) { ::memset(&batch_size_, 0, static_cast( reinterpret_cast(&shuffle_) - reinterpret_cast(&batch_size_)) + sizeof(shuffle_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* HDF5DataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string source = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_source(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.HDF5DataParameter.source"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 batch_size = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_batch_size(&has_bits); batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool shuffle = 3 [default = false]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_shuffle(&has_bits); shuffle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* HDF5DataParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.HDF5DataParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string source = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_source().data(), static_cast(this->_internal_source().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.HDF5DataParameter.source"); target = stream->WriteStringMaybeAliased( 1, this->_internal_source(), target); } // optional uint32 batch_size = 2; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_batch_size(), target); } // optional bool shuffle = 3 [default = false]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_shuffle(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.HDF5DataParameter) return target; } size_t HDF5DataParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.HDF5DataParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional string source = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_source()); } // optional uint32 batch_size = 2; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); } // optional bool shuffle = 3 [default = false]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HDF5DataParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, HDF5DataParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HDF5DataParameter::GetClassData() const { return &_class_data_; } void HDF5DataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void HDF5DataParameter::MergeFrom(const HDF5DataParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.HDF5DataParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { _internal_set_source(from._internal_source()); } if (cached_has_bits & 0x00000002u) { batch_size_ = from.batch_size_; } if (cached_has_bits & 0x00000004u) { shuffle_ = from.shuffle_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void HDF5DataParameter::CopyFrom(const HDF5DataParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.HDF5DataParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool HDF5DataParameter::IsInitialized() const { return true; } void HDF5DataParameter::InternalSwap(HDF5DataParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &source_, lhs_arena, &other->source_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(HDF5DataParameter, shuffle_) + sizeof(HDF5DataParameter::shuffle_) - PROTOBUF_FIELD_OFFSET(HDF5DataParameter, batch_size_)>( reinterpret_cast(&batch_size_), reinterpret_cast(&other->batch_size_)); } ::PROTOBUF_NAMESPACE_ID::Metadata HDF5DataParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[36]); } // =================================================================== class HDF5OutputParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_file_name(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; HDF5OutputParameter::HDF5OutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.HDF5OutputParameter) } HDF5OutputParameter::HDF5OutputParameter(const HDF5OutputParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_file_name()) { file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_file_name(), GetArenaForAllocation()); } // @@protoc_insertion_point(copy_constructor:opencv_caffe.HDF5OutputParameter) } inline void HDF5OutputParameter::SharedCtor() { file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } HDF5OutputParameter::~HDF5OutputParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.HDF5OutputParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void HDF5OutputParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); file_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void HDF5OutputParameter::ArenaDtor(void* object) { HDF5OutputParameter* _this = reinterpret_cast< HDF5OutputParameter* >(object); (void)_this; } void HDF5OutputParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void HDF5OutputParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void HDF5OutputParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.HDF5OutputParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { file_name_.ClearNonDefaultToEmpty(); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* HDF5OutputParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string file_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_file_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.HDF5OutputParameter.file_name"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* HDF5OutputParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.HDF5OutputParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string file_name = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_file_name().data(), static_cast(this->_internal_file_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.HDF5OutputParameter.file_name"); target = stream->WriteStringMaybeAliased( 1, this->_internal_file_name(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.HDF5OutputParameter) return target; } size_t HDF5OutputParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.HDF5OutputParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional string file_name = 1; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_file_name()); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HDF5OutputParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, HDF5OutputParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HDF5OutputParameter::GetClassData() const { return &_class_data_; } void HDF5OutputParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void HDF5OutputParameter::MergeFrom(const HDF5OutputParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.HDF5OutputParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_has_file_name()) { _internal_set_file_name(from._internal_file_name()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void HDF5OutputParameter::CopyFrom(const HDF5OutputParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.HDF5OutputParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool HDF5OutputParameter::IsInitialized() const { return true; } void HDF5OutputParameter::InternalSwap(HDF5OutputParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &file_name_, lhs_arena, &other->file_name_, rhs_arena ); } ::PROTOBUF_NAMESPACE_ID::Metadata HDF5OutputParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[37]); } // =================================================================== class HingeLossParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_norm(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; HingeLossParameter::HingeLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.HingeLossParameter) } HingeLossParameter::HingeLossParameter(const HingeLossParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); norm_ = from.norm_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.HingeLossParameter) } inline void HingeLossParameter::SharedCtor() { norm_ = 1; } HingeLossParameter::~HingeLossParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.HingeLossParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void HingeLossParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void HingeLossParameter::ArenaDtor(void* object) { HingeLossParameter* _this = reinterpret_cast< HingeLossParameter* >(object); (void)_this; } void HingeLossParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void HingeLossParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void HingeLossParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.HingeLossParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; norm_ = 1; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* HingeLossParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::HingeLossParameter_Norm_IsValid(val))) { _internal_set_norm(static_cast<::opencv_caffe::HingeLossParameter_Norm>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* HingeLossParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.HingeLossParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_norm(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.HingeLossParameter) return target; } size_t HingeLossParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.HingeLossParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1]; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_norm()); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HingeLossParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, HingeLossParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HingeLossParameter::GetClassData() const { return &_class_data_; } void HingeLossParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void HingeLossParameter::MergeFrom(const HingeLossParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.HingeLossParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_has_norm()) { _internal_set_norm(from._internal_norm()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void HingeLossParameter::CopyFrom(const HingeLossParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.HingeLossParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool HingeLossParameter::IsInitialized() const { return true; } void HingeLossParameter::InternalSwap(HingeLossParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(norm_, other->norm_); } ::PROTOBUF_NAMESPACE_ID::Metadata HingeLossParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[38]); } // =================================================================== class ImageDataParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_source(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_batch_size(HasBits* has_bits) { (*has_bits)[0] |= 2048u; } static void set_has_rand_skip(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_shuffle(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_new_height(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static void set_has_new_width(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static void set_has_is_color(HasBits* has_bits) { (*has_bits)[0] |= 512u; } static void set_has_scale(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } static void set_has_mean_file(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_crop_size(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_mirror(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_root_folder(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; ImageDataParameter::ImageDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ImageDataParameter) } ImageDataParameter::ImageDataParameter(const ImageDataParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_source()) { source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), GetArenaForAllocation()); } mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_mean_file()) { mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mean_file(), GetArenaForAllocation()); } root_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_root_folder()) { root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_root_folder(), GetArenaForAllocation()); } ::memcpy(&crop_size_, &from.crop_size_, static_cast(reinterpret_cast(&batch_size_) - reinterpret_cast(&crop_size_)) + sizeof(batch_size_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ImageDataParameter) } inline void ImageDataParameter::SharedCtor() { source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING root_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&crop_size_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&new_width_) - reinterpret_cast(&crop_size_)) + sizeof(new_width_)); is_color_ = true; scale_ = 1; batch_size_ = 1u; } ImageDataParameter::~ImageDataParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ImageDataParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ImageDataParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); mean_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); root_folder_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void ImageDataParameter::ArenaDtor(void* object) { ImageDataParameter* _this = reinterpret_cast< ImageDataParameter* >(object); (void)_this; } void ImageDataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ImageDataParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ImageDataParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ImageDataParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { source_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { mean_file_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000004u) { root_folder_.ClearNonDefaultToEmpty(); } } if (cached_has_bits & 0x000000f8u) { ::memset(&crop_size_, 0, static_cast( reinterpret_cast(&new_height_) - reinterpret_cast(&crop_size_)) + sizeof(new_height_)); } if (cached_has_bits & 0x00000f00u) { new_width_ = 0u; is_color_ = true; scale_ = 1; batch_size_ = 1u; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ImageDataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string source = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_source(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.ImageDataParameter.source"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional float scale = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_scale(&has_bits); scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional string mean_file = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_mean_file(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.ImageDataParameter.mean_file"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 batch_size = 4 [default = 1]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_batch_size(&has_bits); batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 crop_size = 5 [default = 0]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_crop_size(&has_bits); crop_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool mirror = 6 [default = false]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_mirror(&has_bits); mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 rand_skip = 7 [default = 0]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_rand_skip(&has_bits); rand_skip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool shuffle = 8 [default = false]; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { _Internal::set_has_shuffle(&has_bits); shuffle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 new_height = 9 [default = 0]; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { _Internal::set_has_new_height(&has_bits); new_height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 new_width = 10 [default = 0]; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { _Internal::set_has_new_width(&has_bits); new_width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool is_color = 11 [default = true]; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { _Internal::set_has_is_color(&has_bits); is_color_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string root_folder = 12 [default = ""]; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { auto str = _internal_mutable_root_folder(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.ImageDataParameter.root_folder"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ImageDataParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ImageDataParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string source = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_source().data(), static_cast(this->_internal_source().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.ImageDataParameter.source"); target = stream->WriteStringMaybeAliased( 1, this->_internal_source(), target); } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); } // optional string mean_file = 3; if (cached_has_bits & 0x00000002u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_mean_file().data(), static_cast(this->_internal_mean_file().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.ImageDataParameter.mean_file"); target = stream->WriteStringMaybeAliased( 3, this->_internal_mean_file(), target); } // optional uint32 batch_size = 4 [default = 1]; if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_batch_size(), target); } // optional uint32 crop_size = 5 [default = 0]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_crop_size(), target); } // optional bool mirror = 6 [default = false]; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_mirror(), target); } // optional uint32 rand_skip = 7 [default = 0]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_rand_skip(), target); } // optional bool shuffle = 8 [default = false]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_shuffle(), target); } // optional uint32 new_height = 9 [default = 0]; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_new_height(), target); } // optional uint32 new_width = 10 [default = 0]; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_new_width(), target); } // optional bool is_color = 11 [default = true]; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_is_color(), target); } // optional string root_folder = 12 [default = ""]; if (cached_has_bits & 0x00000004u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_root_folder().data(), static_cast(this->_internal_root_folder().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.ImageDataParameter.root_folder"); target = stream->WriteStringMaybeAliased( 12, this->_internal_root_folder(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ImageDataParameter) return target; } size_t ImageDataParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ImageDataParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional string source = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_source()); } // optional string mean_file = 3; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_mean_file()); } // optional string root_folder = 12 [default = ""]; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_root_folder()); } // optional uint32 crop_size = 5 [default = 0]; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_crop_size()); } // optional uint32 rand_skip = 7 [default = 0]; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_rand_skip()); } // optional bool shuffle = 8 [default = false]; if (cached_has_bits & 0x00000020u) { total_size += 1 + 1; } // optional bool mirror = 6 [default = false]; if (cached_has_bits & 0x00000040u) { total_size += 1 + 1; } // optional uint32 new_height = 9 [default = 0]; if (cached_has_bits & 0x00000080u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_new_height()); } } if (cached_has_bits & 0x00000f00u) { // optional uint32 new_width = 10 [default = 0]; if (cached_has_bits & 0x00000100u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_new_width()); } // optional bool is_color = 11 [default = true]; if (cached_has_bits & 0x00000200u) { total_size += 1 + 1; } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000400u) { total_size += 1 + 4; } // optional uint32 batch_size = 4 [default = 1]; if (cached_has_bits & 0x00000800u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ImageDataParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ImageDataParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ImageDataParameter::GetClassData() const { return &_class_data_; } void ImageDataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ImageDataParameter::MergeFrom(const ImageDataParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ImageDataParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_source(from._internal_source()); } if (cached_has_bits & 0x00000002u) { _internal_set_mean_file(from._internal_mean_file()); } if (cached_has_bits & 0x00000004u) { _internal_set_root_folder(from._internal_root_folder()); } if (cached_has_bits & 0x00000008u) { crop_size_ = from.crop_size_; } if (cached_has_bits & 0x00000010u) { rand_skip_ = from.rand_skip_; } if (cached_has_bits & 0x00000020u) { shuffle_ = from.shuffle_; } if (cached_has_bits & 0x00000040u) { mirror_ = from.mirror_; } if (cached_has_bits & 0x00000080u) { new_height_ = from.new_height_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0x00000f00u) { if (cached_has_bits & 0x00000100u) { new_width_ = from.new_width_; } if (cached_has_bits & 0x00000200u) { is_color_ = from.is_color_; } if (cached_has_bits & 0x00000400u) { scale_ = from.scale_; } if (cached_has_bits & 0x00000800u) { batch_size_ = from.batch_size_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ImageDataParameter::CopyFrom(const ImageDataParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ImageDataParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ImageDataParameter::IsInitialized() const { return true; } void ImageDataParameter::InternalSwap(ImageDataParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &source_, lhs_arena, &other->source_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &mean_file_, lhs_arena, &other->mean_file_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &root_folder_, lhs_arena, &other->root_folder_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ImageDataParameter, new_width_) + sizeof(ImageDataParameter::new_width_) - PROTOBUF_FIELD_OFFSET(ImageDataParameter, crop_size_)>( reinterpret_cast(&crop_size_), reinterpret_cast(&other->crop_size_)); swap(is_color_, other->is_color_); swap(scale_, other->scale_); swap(batch_size_, other->batch_size_); } ::PROTOBUF_NAMESPACE_ID::Metadata ImageDataParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[39]); } // =================================================================== class InfogainLossParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_source(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; InfogainLossParameter::InfogainLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.InfogainLossParameter) } InfogainLossParameter::InfogainLossParameter(const InfogainLossParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_source()) { source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), GetArenaForAllocation()); } // @@protoc_insertion_point(copy_constructor:opencv_caffe.InfogainLossParameter) } inline void InfogainLossParameter::SharedCtor() { source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } InfogainLossParameter::~InfogainLossParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.InfogainLossParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void InfogainLossParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void InfogainLossParameter::ArenaDtor(void* object) { InfogainLossParameter* _this = reinterpret_cast< InfogainLossParameter* >(object); (void)_this; } void InfogainLossParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void InfogainLossParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void InfogainLossParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.InfogainLossParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { source_.ClearNonDefaultToEmpty(); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* InfogainLossParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string source = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_source(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.InfogainLossParameter.source"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* InfogainLossParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.InfogainLossParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string source = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_source().data(), static_cast(this->_internal_source().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.InfogainLossParameter.source"); target = stream->WriteStringMaybeAliased( 1, this->_internal_source(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.InfogainLossParameter) return target; } size_t InfogainLossParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.InfogainLossParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional string source = 1; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_source()); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InfogainLossParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, InfogainLossParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InfogainLossParameter::GetClassData() const { return &_class_data_; } void InfogainLossParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void InfogainLossParameter::MergeFrom(const InfogainLossParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.InfogainLossParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_has_source()) { _internal_set_source(from._internal_source()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void InfogainLossParameter::CopyFrom(const InfogainLossParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.InfogainLossParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool InfogainLossParameter::IsInitialized() const { return true; } void InfogainLossParameter::InternalSwap(InfogainLossParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &source_, lhs_arena, &other->source_, rhs_arena ); } ::PROTOBUF_NAMESPACE_ID::Metadata InfogainLossParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[40]); } // =================================================================== class InnerProductParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_num_output(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_bias_term(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static const ::opencv_caffe::FillerParameter& weight_filler(const InnerProductParameter* msg); static void set_has_weight_filler(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static const ::opencv_caffe::FillerParameter& bias_filler(const InnerProductParameter* msg); static void set_has_bias_filler(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_transpose(HasBits* has_bits) { (*has_bits)[0] |= 8u; } }; const ::opencv_caffe::FillerParameter& InnerProductParameter::_Internal::weight_filler(const InnerProductParameter* msg) { return *msg->weight_filler_; } const ::opencv_caffe::FillerParameter& InnerProductParameter::_Internal::bias_filler(const InnerProductParameter* msg) { return *msg->bias_filler_; } InnerProductParameter::InnerProductParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.InnerProductParameter) } InnerProductParameter::InnerProductParameter(const InnerProductParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_weight_filler()) { weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); } else { weight_filler_ = nullptr; } if (from._internal_has_bias_filler()) { bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); } else { bias_filler_ = nullptr; } ::memcpy(&num_output_, &from.num_output_, static_cast(reinterpret_cast(&axis_) - reinterpret_cast(&num_output_)) + sizeof(axis_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.InnerProductParameter) } inline void InnerProductParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&transpose_) - reinterpret_cast(&weight_filler_)) + sizeof(transpose_)); bias_term_ = true; axis_ = 1; } InnerProductParameter::~InnerProductParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.InnerProductParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void InnerProductParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete weight_filler_; if (this != internal_default_instance()) delete bias_filler_; } void InnerProductParameter::ArenaDtor(void* object) { InnerProductParameter* _this = reinterpret_cast< InnerProductParameter* >(object); (void)_this; } void InnerProductParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void InnerProductParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void InnerProductParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.InnerProductParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(weight_filler_ != nullptr); weight_filler_->Clear(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(bias_filler_ != nullptr); bias_filler_->Clear(); } } if (cached_has_bits & 0x0000003cu) { ::memset(&num_output_, 0, static_cast( reinterpret_cast(&transpose_) - reinterpret_cast(&num_output_)) + sizeof(transpose_)); bias_term_ = true; axis_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* InnerProductParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 num_output = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_num_output(&has_bits); num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool bias_term = 2 [default = true]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_bias_term(&has_bits); bias_term_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter weight_filler = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter bias_filler = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 axis = 5 [default = 1]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool transpose = 6 [default = false]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_transpose(&has_bits); transpose_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* InnerProductParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.InnerProductParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 num_output = 1; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_output(), target); } // optional bool bias_term = 2 [default = true]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_bias_term(), target); } // optional .opencv_caffe.FillerParameter weight_filler = 3; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 3, _Internal::weight_filler(this), target, stream); } // optional .opencv_caffe.FillerParameter bias_filler = 4; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 4, _Internal::bias_filler(this), target, stream); } // optional int32 axis = 5 [default = 1]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_axis(), target); } // optional bool transpose = 6 [default = false]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_transpose(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.InnerProductParameter) return target; } size_t InnerProductParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.InnerProductParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000003fu) { // optional .opencv_caffe.FillerParameter weight_filler = 3; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *weight_filler_); } // optional .opencv_caffe.FillerParameter bias_filler = 4; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *bias_filler_); } // optional uint32 num_output = 1; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); } // optional bool transpose = 6 [default = false]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 1; } // optional bool bias_term = 2 [default = true]; if (cached_has_bits & 0x00000010u) { total_size += 1 + 1; } // optional int32 axis = 5 [default = 1]; if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InnerProductParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, InnerProductParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InnerProductParameter::GetClassData() const { return &_class_data_; } void InnerProductParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void InnerProductParameter::MergeFrom(const InnerProductParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.InnerProductParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); } if (cached_has_bits & 0x00000004u) { num_output_ = from.num_output_; } if (cached_has_bits & 0x00000008u) { transpose_ = from.transpose_; } if (cached_has_bits & 0x00000010u) { bias_term_ = from.bias_term_; } if (cached_has_bits & 0x00000020u) { axis_ = from.axis_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void InnerProductParameter::CopyFrom(const InnerProductParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.InnerProductParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool InnerProductParameter::IsInitialized() const { return true; } void InnerProductParameter::InternalSwap(InnerProductParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(InnerProductParameter, transpose_) + sizeof(InnerProductParameter::transpose_) - PROTOBUF_FIELD_OFFSET(InnerProductParameter, weight_filler_)>( reinterpret_cast(&weight_filler_), reinterpret_cast(&other->weight_filler_)); swap(bias_term_, other->bias_term_); swap(axis_, other->axis_); } ::PROTOBUF_NAMESPACE_ID::Metadata InnerProductParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[41]); } // =================================================================== class InputParameter::_Internal { public: }; InputParameter::InputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), shape_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.InputParameter) } InputParameter::InputParameter(const InputParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), shape_(from.shape_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:opencv_caffe.InputParameter) } inline void InputParameter::SharedCtor() { } InputParameter::~InputParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.InputParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void InputParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void InputParameter::ArenaDtor(void* object) { InputParameter* _this = reinterpret_cast< InputParameter* >(object); (void)_this; } void InputParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void InputParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void InputParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.InputParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; shape_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* InputParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .opencv_caffe.BlobShape shape = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_shape(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* InputParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.InputParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .opencv_caffe.BlobShape shape = 1; for (unsigned int i = 0, n = static_cast(this->_internal_shape_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(1, this->_internal_shape(i), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.InputParameter) return target; } size_t InputParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.InputParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated .opencv_caffe.BlobShape shape = 1; total_size += 1UL * this->_internal_shape_size(); for (const auto& msg : this->shape_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InputParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, InputParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InputParameter::GetClassData() const { return &_class_data_; } void InputParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void InputParameter::MergeFrom(const InputParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.InputParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; shape_.MergeFrom(from.shape_); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void InputParameter::CopyFrom(const InputParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.InputParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool InputParameter::IsInitialized() const { return true; } void InputParameter::InternalSwap(InputParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); shape_.InternalSwap(&other->shape_); } ::PROTOBUF_NAMESPACE_ID::Metadata InputParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[42]); } // =================================================================== class LogParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_base(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_scale(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_shift(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; LogParameter::LogParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.LogParameter) } LogParameter::LogParameter(const LogParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&shift_, &from.shift_, static_cast(reinterpret_cast(&scale_) - reinterpret_cast(&shift_)) + sizeof(scale_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.LogParameter) } inline void LogParameter::SharedCtor() { shift_ = 0; base_ = -1; scale_ = 1; } LogParameter::~LogParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.LogParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void LogParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void LogParameter::ArenaDtor(void* object) { LogParameter* _this = reinterpret_cast< LogParameter* >(object); (void)_this; } void LogParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void LogParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void LogParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.LogParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { shift_ = 0; base_ = -1; scale_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* LogParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float base = 1 [default = -1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_base(&has_bits); base_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float scale = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_scale(&has_bits); scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float shift = 3 [default = 0]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_shift(&has_bits); shift_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* LogParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LogParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float base = 1 [default = -1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_base(), target); } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); } // optional float shift = 3 [default = 0]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_shift(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LogParameter) return target; } size_t LogParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LogParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional float shift = 3 [default = 0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 4; } // optional float base = 1 [default = -1]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 4; } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LogParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, LogParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LogParameter::GetClassData() const { return &_class_data_; } void LogParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void LogParameter::MergeFrom(const LogParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LogParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { shift_ = from.shift_; } if (cached_has_bits & 0x00000002u) { base_ = from.base_; } if (cached_has_bits & 0x00000004u) { scale_ = from.scale_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void LogParameter::CopyFrom(const LogParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LogParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool LogParameter::IsInitialized() const { return true; } void LogParameter::InternalSwap(LogParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(shift_, other->shift_); swap(base_, other->base_); swap(scale_, other->scale_); } ::PROTOBUF_NAMESPACE_ID::Metadata LogParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[43]); } // =================================================================== class LRNParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_local_size(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_alpha(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_beta(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_norm_region(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_k(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_engine(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; LRNParameter::LRNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.LRNParameter) } LRNParameter::LRNParameter(const LRNParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&norm_region_, &from.norm_region_, static_cast(reinterpret_cast(&k_) - reinterpret_cast(&norm_region_)) + sizeof(k_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.LRNParameter) } inline void LRNParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&norm_region_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&engine_) - reinterpret_cast(&norm_region_)) + sizeof(engine_)); local_size_ = 5u; alpha_ = 1; beta_ = 0.75f; k_ = 1; } LRNParameter::~LRNParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.LRNParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void LRNParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void LRNParameter::ArenaDtor(void* object) { LRNParameter* _this = reinterpret_cast< LRNParameter* >(object); (void)_this; } void LRNParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void LRNParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void LRNParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.LRNParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000003fu) { ::memset(&norm_region_, 0, static_cast( reinterpret_cast(&engine_) - reinterpret_cast(&norm_region_)) + sizeof(engine_)); local_size_ = 5u; alpha_ = 1; beta_ = 0.75f; k_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* LRNParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 local_size = 1 [default = 5]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_local_size(&has_bits); local_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float alpha = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_alpha(&has_bits); alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float beta = 3 [default = 0.75]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_beta(&has_bits); beta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::LRNParameter_NormRegion_IsValid(val))) { _internal_set_norm_region(static_cast<::opencv_caffe::LRNParameter_NormRegion>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional float k = 5 [default = 1]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { _Internal::set_has_k(&has_bits); k_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::LRNParameter_Engine_IsValid(val))) { _internal_set_engine(static_cast<::opencv_caffe::LRNParameter_Engine>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* LRNParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LRNParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 local_size = 1 [default = 5]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_local_size(), target); } // optional float alpha = 2 [default = 1]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_alpha(), target); } // optional float beta = 3 [default = 0.75]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_beta(), target); } // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 4, this->_internal_norm_region(), target); } // optional float k = 5 [default = 1]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_k(), target); } // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 6, this->_internal_engine(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LRNParameter) return target; } size_t LRNParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LRNParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000003fu) { // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_norm_region()); } // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); } // optional uint32 local_size = 1 [default = 5]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_local_size()); } // optional float alpha = 2 [default = 1]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 4; } // optional float beta = 3 [default = 0.75]; if (cached_has_bits & 0x00000010u) { total_size += 1 + 4; } // optional float k = 5 [default = 1]; if (cached_has_bits & 0x00000020u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LRNParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, LRNParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LRNParameter::GetClassData() const { return &_class_data_; } void LRNParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void LRNParameter::MergeFrom(const LRNParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LRNParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { norm_region_ = from.norm_region_; } if (cached_has_bits & 0x00000002u) { engine_ = from.engine_; } if (cached_has_bits & 0x00000004u) { local_size_ = from.local_size_; } if (cached_has_bits & 0x00000008u) { alpha_ = from.alpha_; } if (cached_has_bits & 0x00000010u) { beta_ = from.beta_; } if (cached_has_bits & 0x00000020u) { k_ = from.k_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void LRNParameter::CopyFrom(const LRNParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LRNParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool LRNParameter::IsInitialized() const { return true; } void LRNParameter::InternalSwap(LRNParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(LRNParameter, engine_) + sizeof(LRNParameter::engine_) - PROTOBUF_FIELD_OFFSET(LRNParameter, norm_region_)>( reinterpret_cast(&norm_region_), reinterpret_cast(&other->norm_region_)); swap(local_size_, other->local_size_); swap(alpha_, other->alpha_); swap(beta_, other->beta_); swap(k_, other->k_); } ::PROTOBUF_NAMESPACE_ID::Metadata LRNParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[44]); } // =================================================================== class MemoryDataParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_batch_size(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_channels(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_height(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_width(HasBits* has_bits) { (*has_bits)[0] |= 8u; } }; MemoryDataParameter::MemoryDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.MemoryDataParameter) } MemoryDataParameter::MemoryDataParameter(const MemoryDataParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&batch_size_, &from.batch_size_, static_cast(reinterpret_cast(&width_) - reinterpret_cast(&batch_size_)) + sizeof(width_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.MemoryDataParameter) } inline void MemoryDataParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&batch_size_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&width_) - reinterpret_cast(&batch_size_)) + sizeof(width_)); } MemoryDataParameter::~MemoryDataParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.MemoryDataParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void MemoryDataParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void MemoryDataParameter::ArenaDtor(void* object) { MemoryDataParameter* _this = reinterpret_cast< MemoryDataParameter* >(object); (void)_this; } void MemoryDataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void MemoryDataParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void MemoryDataParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.MemoryDataParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000fu) { ::memset(&batch_size_, 0, static_cast( reinterpret_cast(&width_) - reinterpret_cast(&batch_size_)) + sizeof(width_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* MemoryDataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 batch_size = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_batch_size(&has_bits); batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 channels = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_channels(&has_bits); channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 height = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_height(&has_bits); height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 width = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_width(&has_bits); width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* MemoryDataParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.MemoryDataParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 batch_size = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_batch_size(), target); } // optional uint32 channels = 2; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_channels(), target); } // optional uint32 height = 3; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_height(), target); } // optional uint32 width = 4; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_width(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.MemoryDataParameter) return target; } size_t MemoryDataParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.MemoryDataParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000fu) { // optional uint32 batch_size = 1; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); } // optional uint32 channels = 2; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_channels()); } // optional uint32 height = 3; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); } // optional uint32 width = 4; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MemoryDataParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, MemoryDataParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MemoryDataParameter::GetClassData() const { return &_class_data_; } void MemoryDataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void MemoryDataParameter::MergeFrom(const MemoryDataParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.MemoryDataParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { batch_size_ = from.batch_size_; } if (cached_has_bits & 0x00000002u) { channels_ = from.channels_; } if (cached_has_bits & 0x00000004u) { height_ = from.height_; } if (cached_has_bits & 0x00000008u) { width_ = from.width_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void MemoryDataParameter::CopyFrom(const MemoryDataParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.MemoryDataParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool MemoryDataParameter::IsInitialized() const { return true; } void MemoryDataParameter::InternalSwap(MemoryDataParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(MemoryDataParameter, width_) + sizeof(MemoryDataParameter::width_) - PROTOBUF_FIELD_OFFSET(MemoryDataParameter, batch_size_)>( reinterpret_cast(&batch_size_), reinterpret_cast(&other->batch_size_)); } ::PROTOBUF_NAMESPACE_ID::Metadata MemoryDataParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[45]); } // =================================================================== class MVNParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_normalize_variance(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_across_channels(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_eps(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; MVNParameter::MVNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.MVNParameter) } MVNParameter::MVNParameter(const MVNParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&across_channels_, &from.across_channels_, static_cast(reinterpret_cast(&eps_) - reinterpret_cast(&across_channels_)) + sizeof(eps_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.MVNParameter) } inline void MVNParameter::SharedCtor() { across_channels_ = false; normalize_variance_ = true; eps_ = 1e-09f; } MVNParameter::~MVNParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.MVNParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void MVNParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void MVNParameter::ArenaDtor(void* object) { MVNParameter* _this = reinterpret_cast< MVNParameter* >(object); (void)_this; } void MVNParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void MVNParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void MVNParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.MVNParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { across_channels_ = false; normalize_variance_ = true; eps_ = 1e-09f; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* MVNParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional bool normalize_variance = 1 [default = true]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_normalize_variance(&has_bits); normalize_variance_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool across_channels = 2 [default = false]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_across_channels(&has_bits); across_channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float eps = 3 [default = 1e-09]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_eps(&has_bits); eps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* MVNParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.MVNParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional bool normalize_variance = 1 [default = true]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_normalize_variance(), target); } // optional bool across_channels = 2 [default = false]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_across_channels(), target); } // optional float eps = 3 [default = 1e-09]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_eps(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.MVNParameter) return target; } size_t MVNParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.MVNParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional bool across_channels = 2 [default = false]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 1; } // optional bool normalize_variance = 1 [default = true]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 1; } // optional float eps = 3 [default = 1e-09]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MVNParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, MVNParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MVNParameter::GetClassData() const { return &_class_data_; } void MVNParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void MVNParameter::MergeFrom(const MVNParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.MVNParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { across_channels_ = from.across_channels_; } if (cached_has_bits & 0x00000002u) { normalize_variance_ = from.normalize_variance_; } if (cached_has_bits & 0x00000004u) { eps_ = from.eps_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void MVNParameter::CopyFrom(const MVNParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.MVNParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool MVNParameter::IsInitialized() const { return true; } void MVNParameter::InternalSwap(MVNParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(across_channels_, other->across_channels_); swap(normalize_variance_, other->normalize_variance_); swap(eps_, other->eps_); } ::PROTOBUF_NAMESPACE_ID::Metadata MVNParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[46]); } // =================================================================== class ParameterParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static const ::opencv_caffe::BlobShape& shape(const ParameterParameter* msg); static void set_has_shape(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; const ::opencv_caffe::BlobShape& ParameterParameter::_Internal::shape(const ParameterParameter* msg) { return *msg->shape_; } ParameterParameter::ParameterParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ParameterParameter) } ParameterParameter::ParameterParameter(const ParameterParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_shape()) { shape_ = new ::opencv_caffe::BlobShape(*from.shape_); } else { shape_ = nullptr; } // @@protoc_insertion_point(copy_constructor:opencv_caffe.ParameterParameter) } inline void ParameterParameter::SharedCtor() { shape_ = nullptr; } ParameterParameter::~ParameterParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ParameterParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ParameterParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete shape_; } void ParameterParameter::ArenaDtor(void* object) { ParameterParameter* _this = reinterpret_cast< ParameterParameter* >(object); (void)_this; } void ParameterParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ParameterParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ParameterParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ParameterParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(shape_ != nullptr); shape_->Clear(); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ParameterParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.BlobShape shape = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ParameterParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ParameterParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.BlobShape shape = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 1, _Internal::shape(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ParameterParameter) return target; } size_t ParameterParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ParameterParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional .opencv_caffe.BlobShape shape = 1; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *shape_); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ParameterParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterParameter::GetClassData() const { return &_class_data_; } void ParameterParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ParameterParameter::MergeFrom(const ParameterParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ParameterParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_has_shape()) { _internal_mutable_shape()->::opencv_caffe::BlobShape::MergeFrom(from._internal_shape()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterParameter::CopyFrom(const ParameterParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ParameterParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ParameterParameter::IsInitialized() const { return true; } void ParameterParameter::InternalSwap(ParameterParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(shape_, other->shape_); } ::PROTOBUF_NAMESPACE_ID::Metadata ParameterParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[47]); } // =================================================================== class PoolingParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_pool(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_pad(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_pad_h(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static void set_has_pad_w(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static void set_has_kernel_size(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_kernel_h(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_kernel_w(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_stride(HasBits* has_bits) { (*has_bits)[0] |= 2048u; } static void set_has_stride_h(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_stride_w(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_engine(HasBits* has_bits) { (*has_bits)[0] |= 512u; } static void set_has_global_pooling(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } static void set_has_ceil_mode(HasBits* has_bits) { (*has_bits)[0] |= 4096u; } }; PoolingParameter::PoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.PoolingParameter) } PoolingParameter::PoolingParameter(const PoolingParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&pool_, &from.pool_, static_cast(reinterpret_cast(&ceil_mode_) - reinterpret_cast(&pool_)) + sizeof(ceil_mode_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.PoolingParameter) } inline void PoolingParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&pool_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&global_pooling_) - reinterpret_cast(&pool_)) + sizeof(global_pooling_)); stride_ = 1u; ceil_mode_ = true; } PoolingParameter::~PoolingParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.PoolingParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void PoolingParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void PoolingParameter::ArenaDtor(void* object) { PoolingParameter* _this = reinterpret_cast< PoolingParameter* >(object); (void)_this; } void PoolingParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void PoolingParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void PoolingParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.PoolingParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { ::memset(&pool_, 0, static_cast( reinterpret_cast(&pad_h_) - reinterpret_cast(&pool_)) + sizeof(pad_h_)); } if (cached_has_bits & 0x00001f00u) { ::memset(&pad_w_, 0, static_cast( reinterpret_cast(&global_pooling_) - reinterpret_cast(&pad_w_)) + sizeof(global_pooling_)); stride_ = 1u; ceil_mode_ = true; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* PoolingParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::PoolingParameter_PoolMethod_IsValid(val))) { _internal_set_pool(static_cast<::opencv_caffe::PoolingParameter_PoolMethod>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional uint32 kernel_size = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_kernel_size(&has_bits); kernel_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 stride = 3 [default = 1]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_stride(&has_bits); stride_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 pad = 4 [default = 0]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_pad(&has_bits); pad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 kernel_h = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_kernel_h(&has_bits); kernel_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 kernel_w = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_kernel_w(&has_bits); kernel_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 stride_h = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_stride_h(&has_bits); stride_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 stride_w = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { _Internal::set_has_stride_w(&has_bits); stride_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 pad_h = 9 [default = 0]; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { _Internal::set_has_pad_h(&has_bits); pad_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 pad_w = 10 [default = 0]; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { _Internal::set_has_pad_w(&has_bits); pad_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::PoolingParameter_Engine_IsValid(val))) { _internal_set_engine(static_cast<::opencv_caffe::PoolingParameter_Engine>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional bool global_pooling = 12 [default = false]; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { _Internal::set_has_global_pooling(&has_bits); global_pooling_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool ceil_mode = 13 [default = true]; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { _Internal::set_has_ceil_mode(&has_bits); ceil_mode_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* PoolingParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PoolingParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_pool(), target); } // optional uint32 kernel_size = 2; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_kernel_size(), target); } // optional uint32 stride = 3 [default = 1]; if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_stride(), target); } // optional uint32 pad = 4 [default = 0]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_pad(), target); } // optional uint32 kernel_h = 5; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_kernel_h(), target); } // optional uint32 kernel_w = 6; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_kernel_w(), target); } // optional uint32 stride_h = 7; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_stride_h(), target); } // optional uint32 stride_w = 8; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_stride_w(), target); } // optional uint32 pad_h = 9 [default = 0]; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_pad_h(), target); } // optional uint32 pad_w = 10 [default = 0]; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_pad_w(), target); } // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 11, this->_internal_engine(), target); } // optional bool global_pooling = 12 [default = false]; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(12, this->_internal_global_pooling(), target); } // optional bool ceil_mode = 13 [default = true]; if (cached_has_bits & 0x00001000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(13, this->_internal_ceil_mode(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PoolingParameter) return target; } size_t PoolingParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PoolingParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_pool()); } // optional uint32 kernel_size = 2; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_size()); } // optional uint32 pad = 4 [default = 0]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad()); } // optional uint32 kernel_h = 5; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_h()); } // optional uint32 kernel_w = 6; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernel_w()); } // optional uint32 stride_h = 7; if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride_h()); } // optional uint32 stride_w = 8; if (cached_has_bits & 0x00000040u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride_w()); } // optional uint32 pad_h = 9 [default = 0]; if (cached_has_bits & 0x00000080u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad_h()); } } if (cached_has_bits & 0x00001f00u) { // optional uint32 pad_w = 10 [default = 0]; if (cached_has_bits & 0x00000100u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad_w()); } // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; if (cached_has_bits & 0x00000200u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); } // optional bool global_pooling = 12 [default = false]; if (cached_has_bits & 0x00000400u) { total_size += 1 + 1; } // optional uint32 stride = 3 [default = 1]; if (cached_has_bits & 0x00000800u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride()); } // optional bool ceil_mode = 13 [default = true]; if (cached_has_bits & 0x00001000u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PoolingParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, PoolingParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PoolingParameter::GetClassData() const { return &_class_data_; } void PoolingParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void PoolingParameter::MergeFrom(const PoolingParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PoolingParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { pool_ = from.pool_; } if (cached_has_bits & 0x00000002u) { kernel_size_ = from.kernel_size_; } if (cached_has_bits & 0x00000004u) { pad_ = from.pad_; } if (cached_has_bits & 0x00000008u) { kernel_h_ = from.kernel_h_; } if (cached_has_bits & 0x00000010u) { kernel_w_ = from.kernel_w_; } if (cached_has_bits & 0x00000020u) { stride_h_ = from.stride_h_; } if (cached_has_bits & 0x00000040u) { stride_w_ = from.stride_w_; } if (cached_has_bits & 0x00000080u) { pad_h_ = from.pad_h_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0x00001f00u) { if (cached_has_bits & 0x00000100u) { pad_w_ = from.pad_w_; } if (cached_has_bits & 0x00000200u) { engine_ = from.engine_; } if (cached_has_bits & 0x00000400u) { global_pooling_ = from.global_pooling_; } if (cached_has_bits & 0x00000800u) { stride_ = from.stride_; } if (cached_has_bits & 0x00001000u) { ceil_mode_ = from.ceil_mode_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void PoolingParameter::CopyFrom(const PoolingParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PoolingParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool PoolingParameter::IsInitialized() const { return true; } void PoolingParameter::InternalSwap(PoolingParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(PoolingParameter, global_pooling_) + sizeof(PoolingParameter::global_pooling_) - PROTOBUF_FIELD_OFFSET(PoolingParameter, pool_)>( reinterpret_cast(&pool_), reinterpret_cast(&other->pool_)); swap(stride_, other->stride_); swap(ceil_mode_, other->ceil_mode_); } ::PROTOBUF_NAMESPACE_ID::Metadata PoolingParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[48]); } // =================================================================== class PowerParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_power(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_scale(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_shift(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; PowerParameter::PowerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.PowerParameter) } PowerParameter::PowerParameter(const PowerParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&shift_, &from.shift_, static_cast(reinterpret_cast(&scale_) - reinterpret_cast(&shift_)) + sizeof(scale_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.PowerParameter) } inline void PowerParameter::SharedCtor() { shift_ = 0; power_ = 1; scale_ = 1; } PowerParameter::~PowerParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.PowerParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void PowerParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void PowerParameter::ArenaDtor(void* object) { PowerParameter* _this = reinterpret_cast< PowerParameter* >(object); (void)_this; } void PowerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void PowerParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void PowerParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.PowerParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { shift_ = 0; power_ = 1; scale_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* PowerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float power = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_power(&has_bits); power_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float scale = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_scale(&has_bits); scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float shift = 3 [default = 0]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_shift(&has_bits); shift_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* PowerParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PowerParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float power = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_power(), target); } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); } // optional float shift = 3 [default = 0]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_shift(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PowerParameter) return target; } size_t PowerParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PowerParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional float shift = 3 [default = 0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 4; } // optional float power = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 4; } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PowerParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, PowerParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PowerParameter::GetClassData() const { return &_class_data_; } void PowerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void PowerParameter::MergeFrom(const PowerParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PowerParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { shift_ = from.shift_; } if (cached_has_bits & 0x00000002u) { power_ = from.power_; } if (cached_has_bits & 0x00000004u) { scale_ = from.scale_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void PowerParameter::CopyFrom(const PowerParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PowerParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool PowerParameter::IsInitialized() const { return true; } void PowerParameter::InternalSwap(PowerParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(shift_, other->shift_); swap(power_, other->power_); swap(scale_, other->scale_); } ::PROTOBUF_NAMESPACE_ID::Metadata PowerParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[49]); } // =================================================================== class PythonParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_module(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_layer(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_param_str(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_share_in_parallel(HasBits* has_bits) { (*has_bits)[0] |= 8u; } }; PythonParameter::PythonParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.PythonParameter) } PythonParameter::PythonParameter(const PythonParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); module_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_module()) { module_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_module(), GetArenaForAllocation()); } layer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING layer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_layer()) { layer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_layer(), GetArenaForAllocation()); } param_str_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING param_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_param_str()) { param_str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_param_str(), GetArenaForAllocation()); } share_in_parallel_ = from.share_in_parallel_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.PythonParameter) } inline void PythonParameter::SharedCtor() { module_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING layer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING layer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING param_str_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING param_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING share_in_parallel_ = false; } PythonParameter::~PythonParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.PythonParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void PythonParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); module_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); layer_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); param_str_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void PythonParameter::ArenaDtor(void* object) { PythonParameter* _this = reinterpret_cast< PythonParameter* >(object); (void)_this; } void PythonParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void PythonParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void PythonParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.PythonParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { module_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { layer_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000004u) { param_str_.ClearNonDefaultToEmpty(); } } share_in_parallel_ = false; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* PythonParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string module = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_module(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.PythonParameter.module"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional string layer = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_layer(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.PythonParameter.layer"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional string param_str = 3 [default = ""]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_param_str(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.PythonParameter.param_str"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional bool share_in_parallel = 4 [default = false]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_share_in_parallel(&has_bits); share_in_parallel_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* PythonParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PythonParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string module = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_module().data(), static_cast(this->_internal_module().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.PythonParameter.module"); target = stream->WriteStringMaybeAliased( 1, this->_internal_module(), target); } // optional string layer = 2; if (cached_has_bits & 0x00000002u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_layer().data(), static_cast(this->_internal_layer().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.PythonParameter.layer"); target = stream->WriteStringMaybeAliased( 2, this->_internal_layer(), target); } // optional string param_str = 3 [default = ""]; if (cached_has_bits & 0x00000004u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_param_str().data(), static_cast(this->_internal_param_str().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.PythonParameter.param_str"); target = stream->WriteStringMaybeAliased( 3, this->_internal_param_str(), target); } // optional bool share_in_parallel = 4 [default = false]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_share_in_parallel(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PythonParameter) return target; } size_t PythonParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PythonParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000fu) { // optional string module = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_module()); } // optional string layer = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_layer()); } // optional string param_str = 3 [default = ""]; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_param_str()); } // optional bool share_in_parallel = 4 [default = false]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PythonParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, PythonParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PythonParameter::GetClassData() const { return &_class_data_; } void PythonParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void PythonParameter::MergeFrom(const PythonParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PythonParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { _internal_set_module(from._internal_module()); } if (cached_has_bits & 0x00000002u) { _internal_set_layer(from._internal_layer()); } if (cached_has_bits & 0x00000004u) { _internal_set_param_str(from._internal_param_str()); } if (cached_has_bits & 0x00000008u) { share_in_parallel_ = from.share_in_parallel_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void PythonParameter::CopyFrom(const PythonParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PythonParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool PythonParameter::IsInitialized() const { return true; } void PythonParameter::InternalSwap(PythonParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &module_, lhs_arena, &other->module_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &layer_, lhs_arena, &other->layer_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ¶m_str_, lhs_arena, &other->param_str_, rhs_arena ); swap(share_in_parallel_, other->share_in_parallel_); } ::PROTOBUF_NAMESPACE_ID::Metadata PythonParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[50]); } // =================================================================== class RecurrentParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_num_output(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static const ::opencv_caffe::FillerParameter& weight_filler(const RecurrentParameter* msg); static void set_has_weight_filler(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static const ::opencv_caffe::FillerParameter& bias_filler(const RecurrentParameter* msg); static void set_has_bias_filler(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_debug_info(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_expose_hidden(HasBits* has_bits) { (*has_bits)[0] |= 16u; } }; const ::opencv_caffe::FillerParameter& RecurrentParameter::_Internal::weight_filler(const RecurrentParameter* msg) { return *msg->weight_filler_; } const ::opencv_caffe::FillerParameter& RecurrentParameter::_Internal::bias_filler(const RecurrentParameter* msg) { return *msg->bias_filler_; } RecurrentParameter::RecurrentParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.RecurrentParameter) } RecurrentParameter::RecurrentParameter(const RecurrentParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_weight_filler()) { weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); } else { weight_filler_ = nullptr; } if (from._internal_has_bias_filler()) { bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); } else { bias_filler_ = nullptr; } ::memcpy(&num_output_, &from.num_output_, static_cast(reinterpret_cast(&expose_hidden_) - reinterpret_cast(&num_output_)) + sizeof(expose_hidden_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.RecurrentParameter) } inline void RecurrentParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&expose_hidden_) - reinterpret_cast(&weight_filler_)) + sizeof(expose_hidden_)); } RecurrentParameter::~RecurrentParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.RecurrentParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void RecurrentParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete weight_filler_; if (this != internal_default_instance()) delete bias_filler_; } void RecurrentParameter::ArenaDtor(void* object) { RecurrentParameter* _this = reinterpret_cast< RecurrentParameter* >(object); (void)_this; } void RecurrentParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void RecurrentParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void RecurrentParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.RecurrentParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(weight_filler_ != nullptr); weight_filler_->Clear(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(bias_filler_ != nullptr); bias_filler_->Clear(); } } if (cached_has_bits & 0x0000001cu) { ::memset(&num_output_, 0, static_cast( reinterpret_cast(&expose_hidden_) - reinterpret_cast(&num_output_)) + sizeof(expose_hidden_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* RecurrentParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 num_output = 1 [default = 0]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_num_output(&has_bits); num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter weight_filler = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter bias_filler = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool debug_info = 4 [default = false]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_debug_info(&has_bits); debug_info_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool expose_hidden = 5 [default = false]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_expose_hidden(&has_bits); expose_hidden_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* RecurrentParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.RecurrentParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 num_output = 1 [default = 0]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num_output(), target); } // optional .opencv_caffe.FillerParameter weight_filler = 2; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 2, _Internal::weight_filler(this), target, stream); } // optional .opencv_caffe.FillerParameter bias_filler = 3; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 3, _Internal::bias_filler(this), target, stream); } // optional bool debug_info = 4 [default = false]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_debug_info(), target); } // optional bool expose_hidden = 5 [default = false]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_expose_hidden(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.RecurrentParameter) return target; } size_t RecurrentParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.RecurrentParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000001fu) { // optional .opencv_caffe.FillerParameter weight_filler = 2; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *weight_filler_); } // optional .opencv_caffe.FillerParameter bias_filler = 3; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *bias_filler_); } // optional uint32 num_output = 1 [default = 0]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); } // optional bool debug_info = 4 [default = false]; if (cached_has_bits & 0x00000008u) { total_size += 1 + 1; } // optional bool expose_hidden = 5 [default = false]; if (cached_has_bits & 0x00000010u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RecurrentParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, RecurrentParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RecurrentParameter::GetClassData() const { return &_class_data_; } void RecurrentParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void RecurrentParameter::MergeFrom(const RecurrentParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.RecurrentParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000001fu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); } if (cached_has_bits & 0x00000004u) { num_output_ = from.num_output_; } if (cached_has_bits & 0x00000008u) { debug_info_ = from.debug_info_; } if (cached_has_bits & 0x00000010u) { expose_hidden_ = from.expose_hidden_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void RecurrentParameter::CopyFrom(const RecurrentParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.RecurrentParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool RecurrentParameter::IsInitialized() const { return true; } void RecurrentParameter::InternalSwap(RecurrentParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(RecurrentParameter, expose_hidden_) + sizeof(RecurrentParameter::expose_hidden_) - PROTOBUF_FIELD_OFFSET(RecurrentParameter, weight_filler_)>( reinterpret_cast(&weight_filler_), reinterpret_cast(&other->weight_filler_)); } ::PROTOBUF_NAMESPACE_ID::Metadata RecurrentParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[51]); } // =================================================================== class ReductionParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_operation(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_coeff(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; ReductionParameter::ReductionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ReductionParameter) } ReductionParameter::ReductionParameter(const ReductionParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&axis_, &from.axis_, static_cast(reinterpret_cast(&coeff_) - reinterpret_cast(&axis_)) + sizeof(coeff_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReductionParameter) } inline void ReductionParameter::SharedCtor() { axis_ = 0; operation_ = 1; coeff_ = 1; } ReductionParameter::~ReductionParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ReductionParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ReductionParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ReductionParameter::ArenaDtor(void* object) { ReductionParameter* _this = reinterpret_cast< ReductionParameter* >(object); (void)_this; } void ReductionParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ReductionParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ReductionParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ReductionParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { axis_ = 0; operation_ = 1; coeff_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ReductionParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::ReductionParameter_ReductionOp_IsValid(val))) { _internal_set_operation(static_cast<::opencv_caffe::ReductionParameter_ReductionOp>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional int32 axis = 2 [default = 0]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float coeff = 3 [default = 1]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_coeff(&has_bits); coeff_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ReductionParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ReductionParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_operation(), target); } // optional int32 axis = 2 [default = 0]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); } // optional float coeff = 3 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_coeff(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ReductionParameter) return target; } size_t ReductionParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ReductionParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional int32 axis = 2 [default = 0]; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_operation()); } // optional float coeff = 3 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReductionParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ReductionParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReductionParameter::GetClassData() const { return &_class_data_; } void ReductionParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ReductionParameter::MergeFrom(const ReductionParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ReductionParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { axis_ = from.axis_; } if (cached_has_bits & 0x00000002u) { operation_ = from.operation_; } if (cached_has_bits & 0x00000004u) { coeff_ = from.coeff_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ReductionParameter::CopyFrom(const ReductionParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ReductionParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ReductionParameter::IsInitialized() const { return true; } void ReductionParameter::InternalSwap(ReductionParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(axis_, other->axis_); swap(operation_, other->operation_); swap(coeff_, other->coeff_); } ::PROTOBUF_NAMESPACE_ID::Metadata ReductionParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[52]); } // =================================================================== class ReLUParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_negative_slope(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_engine(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; ReLUParameter::ReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ReLUParameter) } ReLUParameter::ReLUParameter(const ReLUParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&negative_slope_, &from.negative_slope_, static_cast(reinterpret_cast(&engine_) - reinterpret_cast(&negative_slope_)) + sizeof(engine_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReLUParameter) } inline void ReLUParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&negative_slope_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&engine_) - reinterpret_cast(&negative_slope_)) + sizeof(engine_)); } ReLUParameter::~ReLUParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ReLUParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ReLUParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ReLUParameter::ArenaDtor(void* object) { ReLUParameter* _this = reinterpret_cast< ReLUParameter* >(object); (void)_this; } void ReLUParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ReLUParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ReLUParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ReLUParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { ::memset(&negative_slope_, 0, static_cast( reinterpret_cast(&engine_) - reinterpret_cast(&negative_slope_)) + sizeof(engine_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ReLUParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float negative_slope = 1 [default = 0]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_negative_slope(&has_bits); negative_slope_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::ReLUParameter_Engine_IsValid(val))) { _internal_set_engine(static_cast<::opencv_caffe::ReLUParameter_Engine>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ReLUParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ReLUParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float negative_slope = 1 [default = 0]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_negative_slope(), target); } // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_engine(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ReLUParameter) return target; } size_t ReLUParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ReLUParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional float negative_slope = 1 [default = 0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 4; } // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReLUParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ReLUParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReLUParameter::GetClassData() const { return &_class_data_; } void ReLUParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ReLUParameter::MergeFrom(const ReLUParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ReLUParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { negative_slope_ = from.negative_slope_; } if (cached_has_bits & 0x00000002u) { engine_ = from.engine_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ReLUParameter::CopyFrom(const ReLUParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ReLUParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ReLUParameter::IsInitialized() const { return true; } void ReLUParameter::InternalSwap(ReLUParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ReLUParameter, engine_) + sizeof(ReLUParameter::engine_) - PROTOBUF_FIELD_OFFSET(ReLUParameter, negative_slope_)>( reinterpret_cast(&negative_slope_), reinterpret_cast(&other->negative_slope_)); } ::PROTOBUF_NAMESPACE_ID::Metadata ReLUParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[53]); } // =================================================================== class ReshapeParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static const ::opencv_caffe::BlobShape& shape(const ReshapeParameter* msg); static void set_has_shape(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_num_axes(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; const ::opencv_caffe::BlobShape& ReshapeParameter::_Internal::shape(const ReshapeParameter* msg) { return *msg->shape_; } ReshapeParameter::ReshapeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ReshapeParameter) } ReshapeParameter::ReshapeParameter(const ReshapeParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_shape()) { shape_ = new ::opencv_caffe::BlobShape(*from.shape_); } else { shape_ = nullptr; } ::memcpy(&axis_, &from.axis_, static_cast(reinterpret_cast(&num_axes_) - reinterpret_cast(&axis_)) + sizeof(num_axes_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReshapeParameter) } inline void ReshapeParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&shape_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&axis_) - reinterpret_cast(&shape_)) + sizeof(axis_)); num_axes_ = -1; } ReshapeParameter::~ReshapeParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ReshapeParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ReshapeParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete shape_; } void ReshapeParameter::ArenaDtor(void* object) { ReshapeParameter* _this = reinterpret_cast< ReshapeParameter* >(object); (void)_this; } void ReshapeParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ReshapeParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ReshapeParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ReshapeParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(shape_ != nullptr); shape_->Clear(); } if (cached_has_bits & 0x00000006u) { axis_ = 0; num_axes_ = -1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ReshapeParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.BlobShape shape = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 axis = 2 [default = 0]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 num_axes = 3 [default = -1]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_num_axes(&has_bits); num_axes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ReshapeParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ReshapeParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.BlobShape shape = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 1, _Internal::shape(this), target, stream); } // optional int32 axis = 2 [default = 0]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); } // optional int32 num_axes = 3 [default = -1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_num_axes(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ReshapeParameter) return target; } size_t ReshapeParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ReshapeParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional .opencv_caffe.BlobShape shape = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *shape_); } // optional int32 axis = 2 [default = 0]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } // optional int32 num_axes = 3 [default = -1]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_axes()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReshapeParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ReshapeParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReshapeParameter::GetClassData() const { return &_class_data_; } void ReshapeParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ReshapeParameter::MergeFrom(const ReshapeParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ReshapeParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { _internal_mutable_shape()->::opencv_caffe::BlobShape::MergeFrom(from._internal_shape()); } if (cached_has_bits & 0x00000002u) { axis_ = from.axis_; } if (cached_has_bits & 0x00000004u) { num_axes_ = from.num_axes_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ReshapeParameter::CopyFrom(const ReshapeParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ReshapeParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ReshapeParameter::IsInitialized() const { return true; } void ReshapeParameter::InternalSwap(ReshapeParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ReshapeParameter, axis_) + sizeof(ReshapeParameter::axis_) - PROTOBUF_FIELD_OFFSET(ReshapeParameter, shape_)>( reinterpret_cast(&shape_), reinterpret_cast(&other->shape_)); swap(num_axes_, other->num_axes_); } ::PROTOBUF_NAMESPACE_ID::Metadata ReshapeParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[54]); } // =================================================================== class ScaleParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_num_axes(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static const ::opencv_caffe::FillerParameter& filler(const ScaleParameter* msg); static void set_has_filler(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_bias_term(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static const ::opencv_caffe::FillerParameter& bias_filler(const ScaleParameter* msg); static void set_has_bias_filler(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; const ::opencv_caffe::FillerParameter& ScaleParameter::_Internal::filler(const ScaleParameter* msg) { return *msg->filler_; } const ::opencv_caffe::FillerParameter& ScaleParameter::_Internal::bias_filler(const ScaleParameter* msg) { return *msg->bias_filler_; } ScaleParameter::ScaleParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ScaleParameter) } ScaleParameter::ScaleParameter(const ScaleParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_filler()) { filler_ = new ::opencv_caffe::FillerParameter(*from.filler_); } else { filler_ = nullptr; } if (from._internal_has_bias_filler()) { bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); } else { bias_filler_ = nullptr; } ::memcpy(&bias_term_, &from.bias_term_, static_cast(reinterpret_cast(&num_axes_) - reinterpret_cast(&bias_term_)) + sizeof(num_axes_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ScaleParameter) } inline void ScaleParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&filler_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&bias_term_) - reinterpret_cast(&filler_)) + sizeof(bias_term_)); axis_ = 1; num_axes_ = 1; } ScaleParameter::~ScaleParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ScaleParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ScaleParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete filler_; if (this != internal_default_instance()) delete bias_filler_; } void ScaleParameter::ArenaDtor(void* object) { ScaleParameter* _this = reinterpret_cast< ScaleParameter* >(object); (void)_this; } void ScaleParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ScaleParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ScaleParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ScaleParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(filler_ != nullptr); filler_->Clear(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(bias_filler_ != nullptr); bias_filler_->Clear(); } } if (cached_has_bits & 0x0000001cu) { bias_term_ = false; axis_ = 1; num_axes_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ScaleParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional int32 axis = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 num_axes = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_num_axes(&has_bits); num_axes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter filler = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool bias_term = 4 [default = false]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_bias_term(&has_bits); bias_term_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter bias_filler = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ScaleParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ScaleParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional int32 axis = 1 [default = 1]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); } // optional int32 num_axes = 2 [default = 1]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_num_axes(), target); } // optional .opencv_caffe.FillerParameter filler = 3; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 3, _Internal::filler(this), target, stream); } // optional bool bias_term = 4 [default = false]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_bias_term(), target); } // optional .opencv_caffe.FillerParameter bias_filler = 5; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 5, _Internal::bias_filler(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ScaleParameter) return target; } size_t ScaleParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ScaleParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000001fu) { // optional .opencv_caffe.FillerParameter filler = 3; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *filler_); } // optional .opencv_caffe.FillerParameter bias_filler = 5; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *bias_filler_); } // optional bool bias_term = 4 [default = false]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 1; } // optional int32 axis = 1 [default = 1]; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } // optional int32 num_axes = 2 [default = 1]; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_axes()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ScaleParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ScaleParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ScaleParameter::GetClassData() const { return &_class_data_; } void ScaleParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ScaleParameter::MergeFrom(const ScaleParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ScaleParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000001fu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_filler()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); } if (cached_has_bits & 0x00000004u) { bias_term_ = from.bias_term_; } if (cached_has_bits & 0x00000008u) { axis_ = from.axis_; } if (cached_has_bits & 0x00000010u) { num_axes_ = from.num_axes_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ScaleParameter::CopyFrom(const ScaleParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ScaleParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ScaleParameter::IsInitialized() const { return true; } void ScaleParameter::InternalSwap(ScaleParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ScaleParameter, bias_term_) + sizeof(ScaleParameter::bias_term_) - PROTOBUF_FIELD_OFFSET(ScaleParameter, filler_)>( reinterpret_cast(&filler_), reinterpret_cast(&other->filler_)); swap(axis_, other->axis_); swap(num_axes_, other->num_axes_); } ::PROTOBUF_NAMESPACE_ID::Metadata ScaleParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[55]); } // =================================================================== class SigmoidParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_engine(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; SigmoidParameter::SigmoidParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.SigmoidParameter) } SigmoidParameter::SigmoidParameter(const SigmoidParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); engine_ = from.engine_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.SigmoidParameter) } inline void SigmoidParameter::SharedCtor() { engine_ = 0; } SigmoidParameter::~SigmoidParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.SigmoidParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void SigmoidParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void SigmoidParameter::ArenaDtor(void* object) { SigmoidParameter* _this = reinterpret_cast< SigmoidParameter* >(object); (void)_this; } void SigmoidParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SigmoidParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void SigmoidParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.SigmoidParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; engine_ = 0; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SigmoidParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SigmoidParameter_Engine_IsValid(val))) { _internal_set_engine(static_cast<::opencv_caffe::SigmoidParameter_Engine>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* SigmoidParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SigmoidParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_engine(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SigmoidParameter) return target; } size_t SigmoidParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SigmoidParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SigmoidParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, SigmoidParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SigmoidParameter::GetClassData() const { return &_class_data_; } void SigmoidParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void SigmoidParameter::MergeFrom(const SigmoidParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SigmoidParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_has_engine()) { _internal_set_engine(from._internal_engine()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SigmoidParameter::CopyFrom(const SigmoidParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SigmoidParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool SigmoidParameter::IsInitialized() const { return true; } void SigmoidParameter::InternalSwap(SigmoidParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(engine_, other->engine_); } ::PROTOBUF_NAMESPACE_ID::Metadata SigmoidParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[56]); } // =================================================================== class SliceParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_slice_dim(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; SliceParameter::SliceParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), slice_point_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.SliceParameter) } SliceParameter::SliceParameter(const SliceParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), slice_point_(from.slice_point_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&slice_dim_, &from.slice_dim_, static_cast(reinterpret_cast(&axis_) - reinterpret_cast(&slice_dim_)) + sizeof(axis_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.SliceParameter) } inline void SliceParameter::SharedCtor() { slice_dim_ = 1u; axis_ = 1; } SliceParameter::~SliceParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.SliceParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void SliceParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void SliceParameter::ArenaDtor(void* object) { SliceParameter* _this = reinterpret_cast< SliceParameter* >(object); (void)_this; } void SliceParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SliceParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void SliceParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.SliceParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; slice_point_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { slice_dim_ = 1u; axis_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SliceParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 slice_dim = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_slice_dim(&has_bits); slice_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated uint32 slice_point = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { ptr -= 1; do { ptr += 1; _internal_add_slice_point(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr)); } else if (static_cast(tag) == 18) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_slice_point(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 axis = 3 [default = 1]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* SliceParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SliceParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 slice_dim = 1 [default = 1]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_slice_dim(), target); } // repeated uint32 slice_point = 2; for (int i = 0, n = this->_internal_slice_point_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_slice_point(i), target); } // optional int32 axis = 3 [default = 1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_axis(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SliceParameter) return target; } size_t SliceParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SliceParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated uint32 slice_point = 2; { size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: UInt32Size(this->slice_point_); total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_slice_point_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional uint32 slice_dim = 1 [default = 1]; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_slice_dim()); } // optional int32 axis = 3 [default = 1]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SliceParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, SliceParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SliceParameter::GetClassData() const { return &_class_data_; } void SliceParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void SliceParameter::MergeFrom(const SliceParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SliceParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; slice_point_.MergeFrom(from.slice_point_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { slice_dim_ = from.slice_dim_; } if (cached_has_bits & 0x00000002u) { axis_ = from.axis_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SliceParameter::CopyFrom(const SliceParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SliceParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool SliceParameter::IsInitialized() const { return true; } void SliceParameter::InternalSwap(SliceParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); slice_point_.InternalSwap(&other->slice_point_); swap(slice_dim_, other->slice_dim_); swap(axis_, other->axis_); } ::PROTOBUF_NAMESPACE_ID::Metadata SliceParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[57]); } // =================================================================== class SoftmaxParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_engine(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; SoftmaxParameter::SoftmaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.SoftmaxParameter) } SoftmaxParameter::SoftmaxParameter(const SoftmaxParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&engine_, &from.engine_, static_cast(reinterpret_cast(&axis_) - reinterpret_cast(&engine_)) + sizeof(axis_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.SoftmaxParameter) } inline void SoftmaxParameter::SharedCtor() { engine_ = 0; axis_ = 1; } SoftmaxParameter::~SoftmaxParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.SoftmaxParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void SoftmaxParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void SoftmaxParameter::ArenaDtor(void* object) { SoftmaxParameter* _this = reinterpret_cast< SoftmaxParameter* >(object); (void)_this; } void SoftmaxParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SoftmaxParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void SoftmaxParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.SoftmaxParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { engine_ = 0; axis_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SoftmaxParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SoftmaxParameter_Engine_IsValid(val))) { _internal_set_engine(static_cast<::opencv_caffe::SoftmaxParameter_Engine>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional int32 axis = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* SoftmaxParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SoftmaxParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_engine(), target); } // optional int32 axis = 2 [default = 1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_axis(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SoftmaxParameter) return target; } size_t SoftmaxParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SoftmaxParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); } // optional int32 axis = 2 [default = 1]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SoftmaxParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, SoftmaxParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SoftmaxParameter::GetClassData() const { return &_class_data_; } void SoftmaxParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void SoftmaxParameter::MergeFrom(const SoftmaxParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SoftmaxParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { engine_ = from.engine_; } if (cached_has_bits & 0x00000002u) { axis_ = from.axis_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SoftmaxParameter::CopyFrom(const SoftmaxParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SoftmaxParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool SoftmaxParameter::IsInitialized() const { return true; } void SoftmaxParameter::InternalSwap(SoftmaxParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(engine_, other->engine_); swap(axis_, other->axis_); } ::PROTOBUF_NAMESPACE_ID::Metadata SoftmaxParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[58]); } // =================================================================== class TanHParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_engine(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; TanHParameter::TanHParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.TanHParameter) } TanHParameter::TanHParameter(const TanHParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); engine_ = from.engine_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.TanHParameter) } inline void TanHParameter::SharedCtor() { engine_ = 0; } TanHParameter::~TanHParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.TanHParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void TanHParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void TanHParameter::ArenaDtor(void* object) { TanHParameter* _this = reinterpret_cast< TanHParameter* >(object); (void)_this; } void TanHParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void TanHParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void TanHParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.TanHParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; engine_ = 0; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* TanHParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::TanHParameter_Engine_IsValid(val))) { _internal_set_engine(static_cast<::opencv_caffe::TanHParameter_Engine>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* TanHParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.TanHParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_engine(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.TanHParameter) return target; } size_t TanHParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.TanHParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TanHParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, TanHParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TanHParameter::GetClassData() const { return &_class_data_; } void TanHParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void TanHParameter::MergeFrom(const TanHParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.TanHParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_has_engine()) { _internal_set_engine(from._internal_engine()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void TanHParameter::CopyFrom(const TanHParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.TanHParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool TanHParameter::IsInitialized() const { return true; } void TanHParameter::InternalSwap(TanHParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(engine_, other->engine_); } ::PROTOBUF_NAMESPACE_ID::Metadata TanHParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[59]); } // =================================================================== class TileParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_axis(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_tiles(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; TileParameter::TileParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.TileParameter) } TileParameter::TileParameter(const TileParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&tiles_, &from.tiles_, static_cast(reinterpret_cast(&axis_) - reinterpret_cast(&tiles_)) + sizeof(axis_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.TileParameter) } inline void TileParameter::SharedCtor() { tiles_ = 0; axis_ = 1; } TileParameter::~TileParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.TileParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void TileParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void TileParameter::ArenaDtor(void* object) { TileParameter* _this = reinterpret_cast< TileParameter* >(object); (void)_this; } void TileParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void TileParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void TileParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.TileParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { tiles_ = 0; axis_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* TileParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional int32 axis = 1 [default = 1]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_axis(&has_bits); axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 tiles = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_tiles(&has_bits); tiles_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* TileParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.TileParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional int32 axis = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_axis(), target); } // optional int32 tiles = 2; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_tiles(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.TileParameter) return target; } size_t TileParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.TileParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional int32 tiles = 2; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_tiles()); } // optional int32 axis = 1 [default = 1]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_axis()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TileParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, TileParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TileParameter::GetClassData() const { return &_class_data_; } void TileParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void TileParameter::MergeFrom(const TileParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.TileParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { tiles_ = from.tiles_; } if (cached_has_bits & 0x00000002u) { axis_ = from.axis_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void TileParameter::CopyFrom(const TileParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.TileParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool TileParameter::IsInitialized() const { return true; } void TileParameter::InternalSwap(TileParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(tiles_, other->tiles_); swap(axis_, other->axis_); } ::PROTOBUF_NAMESPACE_ID::Metadata TileParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[60]); } // =================================================================== class ThresholdParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_threshold(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; ThresholdParameter::ThresholdParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ThresholdParameter) } ThresholdParameter::ThresholdParameter(const ThresholdParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); threshold_ = from.threshold_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.ThresholdParameter) } inline void ThresholdParameter::SharedCtor() { threshold_ = 0; } ThresholdParameter::~ThresholdParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ThresholdParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ThresholdParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ThresholdParameter::ArenaDtor(void* object) { ThresholdParameter* _this = reinterpret_cast< ThresholdParameter* >(object); (void)_this; } void ThresholdParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ThresholdParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ThresholdParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ThresholdParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; threshold_ = 0; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ThresholdParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float threshold = 1 [default = 0]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_threshold(&has_bits); threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ThresholdParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ThresholdParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float threshold = 1 [default = 0]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_threshold(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ThresholdParameter) return target; } size_t ThresholdParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ThresholdParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional float threshold = 1 [default = 0]; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + 4; } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ThresholdParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ThresholdParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ThresholdParameter::GetClassData() const { return &_class_data_; } void ThresholdParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ThresholdParameter::MergeFrom(const ThresholdParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ThresholdParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_has_threshold()) { _internal_set_threshold(from._internal_threshold()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ThresholdParameter::CopyFrom(const ThresholdParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ThresholdParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ThresholdParameter::IsInitialized() const { return true; } void ThresholdParameter::InternalSwap(ThresholdParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(threshold_, other->threshold_); } ::PROTOBUF_NAMESPACE_ID::Metadata ThresholdParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[61]); } // =================================================================== class WindowDataParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_source(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_scale(HasBits* has_bits) { (*has_bits)[0] |= 512u; } static void set_has_mean_file(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_batch_size(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_crop_size(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_mirror(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_fg_threshold(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } static void set_has_bg_threshold(HasBits* has_bits) { (*has_bits)[0] |= 2048u; } static void set_has_fg_fraction(HasBits* has_bits) { (*has_bits)[0] |= 4096u; } static void set_has_context_pad(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static void set_has_crop_mode(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_cache_images(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static void set_has_root_folder(HasBits* has_bits) { (*has_bits)[0] |= 8u; } }; const ::PROTOBUF_NAMESPACE_ID::internal::LazyString WindowDataParameter::_i_give_permission_to_break_this_code_default_crop_mode_{{{"warp", 4}}, {nullptr}}; WindowDataParameter::WindowDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.WindowDataParameter) } WindowDataParameter::WindowDataParameter(const WindowDataParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_source()) { source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), GetArenaForAllocation()); } mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_mean_file()) { mean_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mean_file(), GetArenaForAllocation()); } crop_mode_.UnsafeSetDefault(nullptr); if (from._internal_has_crop_mode()) { crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_crop_mode(), GetArenaForAllocation()); } root_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_root_folder()) { root_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_root_folder(), GetArenaForAllocation()); } ::memcpy(&batch_size_, &from.batch_size_, static_cast(reinterpret_cast(&fg_fraction_) - reinterpret_cast(&batch_size_)) + sizeof(fg_fraction_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.WindowDataParameter) } inline void WindowDataParameter::SharedCtor() { source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING mean_file_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING crop_mode_.UnsafeSetDefault(nullptr); root_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING root_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&batch_size_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&context_pad_) - reinterpret_cast(&batch_size_)) + sizeof(context_pad_)); scale_ = 1; fg_threshold_ = 0.5f; bg_threshold_ = 0.5f; fg_fraction_ = 0.25f; } WindowDataParameter::~WindowDataParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.WindowDataParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void WindowDataParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); mean_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); crop_mode_.DestroyNoArena(nullptr); root_folder_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void WindowDataParameter::ArenaDtor(void* object) { WindowDataParameter* _this = reinterpret_cast< WindowDataParameter* >(object); (void)_this; } void WindowDataParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void WindowDataParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void WindowDataParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.WindowDataParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { source_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { mean_file_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000004u) { crop_mode_.ClearToDefault(::opencv_caffe::WindowDataParameter::_i_give_permission_to_break_this_code_default_crop_mode_, GetArenaForAllocation()); } if (cached_has_bits & 0x00000008u) { root_folder_.ClearNonDefaultToEmpty(); } } if (cached_has_bits & 0x000000f0u) { ::memset(&batch_size_, 0, static_cast( reinterpret_cast(&cache_images_) - reinterpret_cast(&batch_size_)) + sizeof(cache_images_)); } if (cached_has_bits & 0x00001f00u) { context_pad_ = 0u; scale_ = 1; fg_threshold_ = 0.5f; bg_threshold_ = 0.5f; fg_fraction_ = 0.25f; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* WindowDataParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string source = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_source(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.WindowDataParameter.source"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional float scale = 2 [default = 1]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_scale(&has_bits); scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional string mean_file = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_mean_file(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.WindowDataParameter.mean_file"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 batch_size = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_batch_size(&has_bits); batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 crop_size = 5 [default = 0]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_crop_size(&has_bits); crop_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool mirror = 6 [default = false]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_mirror(&has_bits); mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float fg_threshold = 7 [default = 0.5]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { _Internal::set_has_fg_threshold(&has_bits); fg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float bg_threshold = 8 [default = 0.5]; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { _Internal::set_has_bg_threshold(&has_bits); bg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float fg_fraction = 9 [default = 0.25]; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 77)) { _Internal::set_has_fg_fraction(&has_bits); fg_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional uint32 context_pad = 10 [default = 0]; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { _Internal::set_has_context_pad(&has_bits); context_pad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string crop_mode = 11 [default = "warp"]; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { auto str = _internal_mutable_crop_mode(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.WindowDataParameter.crop_mode"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional bool cache_images = 12 [default = false]; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { _Internal::set_has_cache_images(&has_bits); cache_images_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string root_folder = 13 [default = ""]; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { auto str = _internal_mutable_root_folder(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.WindowDataParameter.root_folder"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* WindowDataParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.WindowDataParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string source = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_source().data(), static_cast(this->_internal_source().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.WindowDataParameter.source"); target = stream->WriteStringMaybeAliased( 1, this->_internal_source(), target); } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_scale(), target); } // optional string mean_file = 3; if (cached_has_bits & 0x00000002u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_mean_file().data(), static_cast(this->_internal_mean_file().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.WindowDataParameter.mean_file"); target = stream->WriteStringMaybeAliased( 3, this->_internal_mean_file(), target); } // optional uint32 batch_size = 4; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_batch_size(), target); } // optional uint32 crop_size = 5 [default = 0]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_crop_size(), target); } // optional bool mirror = 6 [default = false]; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_mirror(), target); } // optional float fg_threshold = 7 [default = 0.5]; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_fg_threshold(), target); } // optional float bg_threshold = 8 [default = 0.5]; if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_bg_threshold(), target); } // optional float fg_fraction = 9 [default = 0.25]; if (cached_has_bits & 0x00001000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_fg_fraction(), target); } // optional uint32 context_pad = 10 [default = 0]; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_context_pad(), target); } // optional string crop_mode = 11 [default = "warp"]; if (cached_has_bits & 0x00000004u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_crop_mode().data(), static_cast(this->_internal_crop_mode().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.WindowDataParameter.crop_mode"); target = stream->WriteStringMaybeAliased( 11, this->_internal_crop_mode(), target); } // optional bool cache_images = 12 [default = false]; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(12, this->_internal_cache_images(), target); } // optional string root_folder = 13 [default = ""]; if (cached_has_bits & 0x00000008u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_root_folder().data(), static_cast(this->_internal_root_folder().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.WindowDataParameter.root_folder"); target = stream->WriteStringMaybeAliased( 13, this->_internal_root_folder(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.WindowDataParameter) return target; } size_t WindowDataParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.WindowDataParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional string source = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_source()); } // optional string mean_file = 3; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_mean_file()); } // optional string crop_mode = 11 [default = "warp"]; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_crop_mode()); } // optional string root_folder = 13 [default = ""]; if (cached_has_bits & 0x00000008u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_root_folder()); } // optional uint32 batch_size = 4; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_batch_size()); } // optional uint32 crop_size = 5 [default = 0]; if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_crop_size()); } // optional bool mirror = 6 [default = false]; if (cached_has_bits & 0x00000040u) { total_size += 1 + 1; } // optional bool cache_images = 12 [default = false]; if (cached_has_bits & 0x00000080u) { total_size += 1 + 1; } } if (cached_has_bits & 0x00001f00u) { // optional uint32 context_pad = 10 [default = 0]; if (cached_has_bits & 0x00000100u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_context_pad()); } // optional float scale = 2 [default = 1]; if (cached_has_bits & 0x00000200u) { total_size += 1 + 4; } // optional float fg_threshold = 7 [default = 0.5]; if (cached_has_bits & 0x00000400u) { total_size += 1 + 4; } // optional float bg_threshold = 8 [default = 0.5]; if (cached_has_bits & 0x00000800u) { total_size += 1 + 4; } // optional float fg_fraction = 9 [default = 0.25]; if (cached_has_bits & 0x00001000u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WindowDataParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, WindowDataParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WindowDataParameter::GetClassData() const { return &_class_data_; } void WindowDataParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void WindowDataParameter::MergeFrom(const WindowDataParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.WindowDataParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_source(from._internal_source()); } if (cached_has_bits & 0x00000002u) { _internal_set_mean_file(from._internal_mean_file()); } if (cached_has_bits & 0x00000004u) { _internal_set_crop_mode(from._internal_crop_mode()); } if (cached_has_bits & 0x00000008u) { _internal_set_root_folder(from._internal_root_folder()); } if (cached_has_bits & 0x00000010u) { batch_size_ = from.batch_size_; } if (cached_has_bits & 0x00000020u) { crop_size_ = from.crop_size_; } if (cached_has_bits & 0x00000040u) { mirror_ = from.mirror_; } if (cached_has_bits & 0x00000080u) { cache_images_ = from.cache_images_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0x00001f00u) { if (cached_has_bits & 0x00000100u) { context_pad_ = from.context_pad_; } if (cached_has_bits & 0x00000200u) { scale_ = from.scale_; } if (cached_has_bits & 0x00000400u) { fg_threshold_ = from.fg_threshold_; } if (cached_has_bits & 0x00000800u) { bg_threshold_ = from.bg_threshold_; } if (cached_has_bits & 0x00001000u) { fg_fraction_ = from.fg_fraction_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void WindowDataParameter::CopyFrom(const WindowDataParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.WindowDataParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool WindowDataParameter::IsInitialized() const { return true; } void WindowDataParameter::InternalSwap(WindowDataParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &source_, lhs_arena, &other->source_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &mean_file_, lhs_arena, &other->mean_file_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( nullptr, &crop_mode_, lhs_arena, &other->crop_mode_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &root_folder_, lhs_arena, &other->root_folder_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(WindowDataParameter, context_pad_) + sizeof(WindowDataParameter::context_pad_) - PROTOBUF_FIELD_OFFSET(WindowDataParameter, batch_size_)>( reinterpret_cast(&batch_size_), reinterpret_cast(&other->batch_size_)); swap(scale_, other->scale_); swap(fg_threshold_, other->fg_threshold_); swap(bg_threshold_, other->bg_threshold_); swap(fg_fraction_, other->fg_fraction_); } ::PROTOBUF_NAMESPACE_ID::Metadata WindowDataParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[62]); } // =================================================================== class SPPParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_pyramid_height(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_pool(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_engine(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; SPPParameter::SPPParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.SPPParameter) } SPPParameter::SPPParameter(const SPPParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&pyramid_height_, &from.pyramid_height_, static_cast(reinterpret_cast(&engine_) - reinterpret_cast(&pyramid_height_)) + sizeof(engine_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.SPPParameter) } inline void SPPParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&pyramid_height_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&engine_) - reinterpret_cast(&pyramid_height_)) + sizeof(engine_)); } SPPParameter::~SPPParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.SPPParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void SPPParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void SPPParameter::ArenaDtor(void* object) { SPPParameter* _this = reinterpret_cast< SPPParameter* >(object); (void)_this; } void SPPParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SPPParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void SPPParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.SPPParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { ::memset(&pyramid_height_, 0, static_cast( reinterpret_cast(&engine_) - reinterpret_cast(&pyramid_height_)) + sizeof(engine_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SPPParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 pyramid_height = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_pyramid_height(&has_bits); pyramid_height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SPPParameter_PoolMethod_IsValid(val))) { _internal_set_pool(static_cast<::opencv_caffe::SPPParameter_PoolMethod>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::SPPParameter_Engine_IsValid(val))) { _internal_set_engine(static_cast<::opencv_caffe::SPPParameter_Engine>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* SPPParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SPPParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 pyramid_height = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_pyramid_height(), target); } // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_pool(), target); } // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 6, this->_internal_engine(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SPPParameter) return target; } size_t SPPParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SPPParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional uint32 pyramid_height = 1; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pyramid_height()); } // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_pool()); } // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_engine()); } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SPPParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, SPPParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SPPParameter::GetClassData() const { return &_class_data_; } void SPPParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void SPPParameter::MergeFrom(const SPPParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SPPParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { pyramid_height_ = from.pyramid_height_; } if (cached_has_bits & 0x00000002u) { pool_ = from.pool_; } if (cached_has_bits & 0x00000004u) { engine_ = from.engine_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SPPParameter::CopyFrom(const SPPParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SPPParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool SPPParameter::IsInitialized() const { return true; } void SPPParameter::InternalSwap(SPPParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SPPParameter, engine_) + sizeof(SPPParameter::engine_) - PROTOBUF_FIELD_OFFSET(SPPParameter, pyramid_height_)>( reinterpret_cast(&pyramid_height_), reinterpret_cast(&other->pyramid_height_)); } ::PROTOBUF_NAMESPACE_ID::Metadata SPPParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[63]); } // =================================================================== class V1LayerParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_name(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_type(HasBits* has_bits) { (*has_bits)[1] |= 1u; } static const ::opencv_caffe::AccuracyParameter& accuracy_param(const V1LayerParameter* msg); static void set_has_accuracy_param(HasBits* has_bits) { (*has_bits)[0] |= 1048576u; } static const ::opencv_caffe::ArgMaxParameter& argmax_param(const V1LayerParameter* msg); static void set_has_argmax_param(HasBits* has_bits) { (*has_bits)[0] |= 65536u; } static const ::opencv_caffe::ConcatParameter& concat_param(const V1LayerParameter* msg); static void set_has_concat_param(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param(const V1LayerParameter* msg); static void set_has_contrastive_loss_param(HasBits* has_bits) { (*has_bits)[0] |= 536870912u; } static const ::opencv_caffe::ConvolutionParameter& convolution_param(const V1LayerParameter* msg); static void set_has_convolution_param(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static const ::opencv_caffe::DataParameter& data_param(const V1LayerParameter* msg); static void set_has_data_param(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static const ::opencv_caffe::DropoutParameter& dropout_param(const V1LayerParameter* msg); static void set_has_dropout_param(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static const ::opencv_caffe::DummyDataParameter& dummy_data_param(const V1LayerParameter* msg); static void set_has_dummy_data_param(HasBits* has_bits) { (*has_bits)[0] |= 524288u; } static const ::opencv_caffe::EltwiseParameter& eltwise_param(const V1LayerParameter* msg); static void set_has_eltwise_param(HasBits* has_bits) { (*has_bits)[0] |= 131072u; } static const ::opencv_caffe::ExpParameter& exp_param(const V1LayerParameter* msg); static void set_has_exp_param(HasBits* has_bits) { (*has_bits)[0] |= 1073741824u; } static const ::opencv_caffe::HDF5DataParameter& hdf5_data_param(const V1LayerParameter* msg); static void set_has_hdf5_data_param(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param(const V1LayerParameter* msg); static void set_has_hdf5_output_param(HasBits* has_bits) { (*has_bits)[0] |= 128u; } static const ::opencv_caffe::HingeLossParameter& hinge_loss_param(const V1LayerParameter* msg); static void set_has_hinge_loss_param(HasBits* has_bits) { (*has_bits)[0] |= 2097152u; } static const ::opencv_caffe::ImageDataParameter& image_data_param(const V1LayerParameter* msg); static void set_has_image_data_param(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static const ::opencv_caffe::InfogainLossParameter& infogain_loss_param(const V1LayerParameter* msg); static void set_has_infogain_loss_param(HasBits* has_bits) { (*has_bits)[0] |= 512u; } static const ::opencv_caffe::InnerProductParameter& inner_product_param(const V1LayerParameter* msg); static void set_has_inner_product_param(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } static const ::opencv_caffe::LRNParameter& lrn_param(const V1LayerParameter* msg); static void set_has_lrn_param(HasBits* has_bits) { (*has_bits)[0] |= 2048u; } static const ::opencv_caffe::MemoryDataParameter& memory_data_param(const V1LayerParameter* msg); static void set_has_memory_data_param(HasBits* has_bits) { (*has_bits)[0] |= 32768u; } static const ::opencv_caffe::MVNParameter& mvn_param(const V1LayerParameter* msg); static void set_has_mvn_param(HasBits* has_bits) { (*has_bits)[0] |= 16777216u; } static const ::opencv_caffe::PoolingParameter& pooling_param(const V1LayerParameter* msg); static void set_has_pooling_param(HasBits* has_bits) { (*has_bits)[0] |= 4096u; } static const ::opencv_caffe::PowerParameter& power_param(const V1LayerParameter* msg); static void set_has_power_param(HasBits* has_bits) { (*has_bits)[0] |= 16384u; } static const ::opencv_caffe::ReLUParameter& relu_param(const V1LayerParameter* msg); static void set_has_relu_param(HasBits* has_bits) { (*has_bits)[0] |= 4194304u; } static const ::opencv_caffe::SigmoidParameter& sigmoid_param(const V1LayerParameter* msg); static void set_has_sigmoid_param(HasBits* has_bits) { (*has_bits)[0] |= 134217728u; } static const ::opencv_caffe::SoftmaxParameter& softmax_param(const V1LayerParameter* msg); static void set_has_softmax_param(HasBits* has_bits) { (*has_bits)[0] |= 268435456u; } static const ::opencv_caffe::SliceParameter& slice_param(const V1LayerParameter* msg); static void set_has_slice_param(HasBits* has_bits) { (*has_bits)[0] |= 8388608u; } static const ::opencv_caffe::TanHParameter& tanh_param(const V1LayerParameter* msg); static void set_has_tanh_param(HasBits* has_bits) { (*has_bits)[0] |= 67108864u; } static const ::opencv_caffe::ThresholdParameter& threshold_param(const V1LayerParameter* msg); static void set_has_threshold_param(HasBits* has_bits) { (*has_bits)[0] |= 262144u; } static const ::opencv_caffe::WindowDataParameter& window_data_param(const V1LayerParameter* msg); static void set_has_window_data_param(HasBits* has_bits) { (*has_bits)[0] |= 8192u; } static const ::opencv_caffe::TransformationParameter& transform_param(const V1LayerParameter* msg); static void set_has_transform_param(HasBits* has_bits) { (*has_bits)[0] |= 33554432u; } static const ::opencv_caffe::LossParameter& loss_param(const V1LayerParameter* msg); static void set_has_loss_param(HasBits* has_bits) { (*has_bits)[0] |= 2147483648u; } static const ::opencv_caffe::V0LayerParameter& layer(const V1LayerParameter* msg); static void set_has_layer(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; const ::opencv_caffe::AccuracyParameter& V1LayerParameter::_Internal::accuracy_param(const V1LayerParameter* msg) { return *msg->accuracy_param_; } const ::opencv_caffe::ArgMaxParameter& V1LayerParameter::_Internal::argmax_param(const V1LayerParameter* msg) { return *msg->argmax_param_; } const ::opencv_caffe::ConcatParameter& V1LayerParameter::_Internal::concat_param(const V1LayerParameter* msg) { return *msg->concat_param_; } const ::opencv_caffe::ContrastiveLossParameter& V1LayerParameter::_Internal::contrastive_loss_param(const V1LayerParameter* msg) { return *msg->contrastive_loss_param_; } const ::opencv_caffe::ConvolutionParameter& V1LayerParameter::_Internal::convolution_param(const V1LayerParameter* msg) { return *msg->convolution_param_; } const ::opencv_caffe::DataParameter& V1LayerParameter::_Internal::data_param(const V1LayerParameter* msg) { return *msg->data_param_; } const ::opencv_caffe::DropoutParameter& V1LayerParameter::_Internal::dropout_param(const V1LayerParameter* msg) { return *msg->dropout_param_; } const ::opencv_caffe::DummyDataParameter& V1LayerParameter::_Internal::dummy_data_param(const V1LayerParameter* msg) { return *msg->dummy_data_param_; } const ::opencv_caffe::EltwiseParameter& V1LayerParameter::_Internal::eltwise_param(const V1LayerParameter* msg) { return *msg->eltwise_param_; } const ::opencv_caffe::ExpParameter& V1LayerParameter::_Internal::exp_param(const V1LayerParameter* msg) { return *msg->exp_param_; } const ::opencv_caffe::HDF5DataParameter& V1LayerParameter::_Internal::hdf5_data_param(const V1LayerParameter* msg) { return *msg->hdf5_data_param_; } const ::opencv_caffe::HDF5OutputParameter& V1LayerParameter::_Internal::hdf5_output_param(const V1LayerParameter* msg) { return *msg->hdf5_output_param_; } const ::opencv_caffe::HingeLossParameter& V1LayerParameter::_Internal::hinge_loss_param(const V1LayerParameter* msg) { return *msg->hinge_loss_param_; } const ::opencv_caffe::ImageDataParameter& V1LayerParameter::_Internal::image_data_param(const V1LayerParameter* msg) { return *msg->image_data_param_; } const ::opencv_caffe::InfogainLossParameter& V1LayerParameter::_Internal::infogain_loss_param(const V1LayerParameter* msg) { return *msg->infogain_loss_param_; } const ::opencv_caffe::InnerProductParameter& V1LayerParameter::_Internal::inner_product_param(const V1LayerParameter* msg) { return *msg->inner_product_param_; } const ::opencv_caffe::LRNParameter& V1LayerParameter::_Internal::lrn_param(const V1LayerParameter* msg) { return *msg->lrn_param_; } const ::opencv_caffe::MemoryDataParameter& V1LayerParameter::_Internal::memory_data_param(const V1LayerParameter* msg) { return *msg->memory_data_param_; } const ::opencv_caffe::MVNParameter& V1LayerParameter::_Internal::mvn_param(const V1LayerParameter* msg) { return *msg->mvn_param_; } const ::opencv_caffe::PoolingParameter& V1LayerParameter::_Internal::pooling_param(const V1LayerParameter* msg) { return *msg->pooling_param_; } const ::opencv_caffe::PowerParameter& V1LayerParameter::_Internal::power_param(const V1LayerParameter* msg) { return *msg->power_param_; } const ::opencv_caffe::ReLUParameter& V1LayerParameter::_Internal::relu_param(const V1LayerParameter* msg) { return *msg->relu_param_; } const ::opencv_caffe::SigmoidParameter& V1LayerParameter::_Internal::sigmoid_param(const V1LayerParameter* msg) { return *msg->sigmoid_param_; } const ::opencv_caffe::SoftmaxParameter& V1LayerParameter::_Internal::softmax_param(const V1LayerParameter* msg) { return *msg->softmax_param_; } const ::opencv_caffe::SliceParameter& V1LayerParameter::_Internal::slice_param(const V1LayerParameter* msg) { return *msg->slice_param_; } const ::opencv_caffe::TanHParameter& V1LayerParameter::_Internal::tanh_param(const V1LayerParameter* msg) { return *msg->tanh_param_; } const ::opencv_caffe::ThresholdParameter& V1LayerParameter::_Internal::threshold_param(const V1LayerParameter* msg) { return *msg->threshold_param_; } const ::opencv_caffe::WindowDataParameter& V1LayerParameter::_Internal::window_data_param(const V1LayerParameter* msg) { return *msg->window_data_param_; } const ::opencv_caffe::TransformationParameter& V1LayerParameter::_Internal::transform_param(const V1LayerParameter* msg) { return *msg->transform_param_; } const ::opencv_caffe::LossParameter& V1LayerParameter::_Internal::loss_param(const V1LayerParameter* msg) { return *msg->loss_param_; } const ::opencv_caffe::V0LayerParameter& V1LayerParameter::_Internal::layer(const V1LayerParameter* msg) { return *msg->layer_; } V1LayerParameter::V1LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), bottom_(arena), top_(arena), blobs_(arena), blobs_lr_(arena), weight_decay_(arena), include_(arena), exclude_(arena), loss_weight_(arena), param_(arena), blob_share_mode_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.V1LayerParameter) } V1LayerParameter::V1LayerParameter(const V1LayerParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), bottom_(from.bottom_), top_(from.top_), blobs_(from.blobs_), blobs_lr_(from.blobs_lr_), weight_decay_(from.weight_decay_), include_(from.include_), exclude_(from.exclude_), loss_weight_(from.loss_weight_), param_(from.param_), blob_share_mode_(from.blob_share_mode_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_name()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), GetArenaForAllocation()); } if (from._internal_has_layer()) { layer_ = new ::opencv_caffe::V0LayerParameter(*from.layer_); } else { layer_ = nullptr; } if (from._internal_has_concat_param()) { concat_param_ = new ::opencv_caffe::ConcatParameter(*from.concat_param_); } else { concat_param_ = nullptr; } if (from._internal_has_convolution_param()) { convolution_param_ = new ::opencv_caffe::ConvolutionParameter(*from.convolution_param_); } else { convolution_param_ = nullptr; } if (from._internal_has_data_param()) { data_param_ = new ::opencv_caffe::DataParameter(*from.data_param_); } else { data_param_ = nullptr; } if (from._internal_has_dropout_param()) { dropout_param_ = new ::opencv_caffe::DropoutParameter(*from.dropout_param_); } else { dropout_param_ = nullptr; } if (from._internal_has_hdf5_data_param()) { hdf5_data_param_ = new ::opencv_caffe::HDF5DataParameter(*from.hdf5_data_param_); } else { hdf5_data_param_ = nullptr; } if (from._internal_has_hdf5_output_param()) { hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter(*from.hdf5_output_param_); } else { hdf5_output_param_ = nullptr; } if (from._internal_has_image_data_param()) { image_data_param_ = new ::opencv_caffe::ImageDataParameter(*from.image_data_param_); } else { image_data_param_ = nullptr; } if (from._internal_has_infogain_loss_param()) { infogain_loss_param_ = new ::opencv_caffe::InfogainLossParameter(*from.infogain_loss_param_); } else { infogain_loss_param_ = nullptr; } if (from._internal_has_inner_product_param()) { inner_product_param_ = new ::opencv_caffe::InnerProductParameter(*from.inner_product_param_); } else { inner_product_param_ = nullptr; } if (from._internal_has_lrn_param()) { lrn_param_ = new ::opencv_caffe::LRNParameter(*from.lrn_param_); } else { lrn_param_ = nullptr; } if (from._internal_has_pooling_param()) { pooling_param_ = new ::opencv_caffe::PoolingParameter(*from.pooling_param_); } else { pooling_param_ = nullptr; } if (from._internal_has_window_data_param()) { window_data_param_ = new ::opencv_caffe::WindowDataParameter(*from.window_data_param_); } else { window_data_param_ = nullptr; } if (from._internal_has_power_param()) { power_param_ = new ::opencv_caffe::PowerParameter(*from.power_param_); } else { power_param_ = nullptr; } if (from._internal_has_memory_data_param()) { memory_data_param_ = new ::opencv_caffe::MemoryDataParameter(*from.memory_data_param_); } else { memory_data_param_ = nullptr; } if (from._internal_has_argmax_param()) { argmax_param_ = new ::opencv_caffe::ArgMaxParameter(*from.argmax_param_); } else { argmax_param_ = nullptr; } if (from._internal_has_eltwise_param()) { eltwise_param_ = new ::opencv_caffe::EltwiseParameter(*from.eltwise_param_); } else { eltwise_param_ = nullptr; } if (from._internal_has_threshold_param()) { threshold_param_ = new ::opencv_caffe::ThresholdParameter(*from.threshold_param_); } else { threshold_param_ = nullptr; } if (from._internal_has_dummy_data_param()) { dummy_data_param_ = new ::opencv_caffe::DummyDataParameter(*from.dummy_data_param_); } else { dummy_data_param_ = nullptr; } if (from._internal_has_accuracy_param()) { accuracy_param_ = new ::opencv_caffe::AccuracyParameter(*from.accuracy_param_); } else { accuracy_param_ = nullptr; } if (from._internal_has_hinge_loss_param()) { hinge_loss_param_ = new ::opencv_caffe::HingeLossParameter(*from.hinge_loss_param_); } else { hinge_loss_param_ = nullptr; } if (from._internal_has_relu_param()) { relu_param_ = new ::opencv_caffe::ReLUParameter(*from.relu_param_); } else { relu_param_ = nullptr; } if (from._internal_has_slice_param()) { slice_param_ = new ::opencv_caffe::SliceParameter(*from.slice_param_); } else { slice_param_ = nullptr; } if (from._internal_has_mvn_param()) { mvn_param_ = new ::opencv_caffe::MVNParameter(*from.mvn_param_); } else { mvn_param_ = nullptr; } if (from._internal_has_transform_param()) { transform_param_ = new ::opencv_caffe::TransformationParameter(*from.transform_param_); } else { transform_param_ = nullptr; } if (from._internal_has_tanh_param()) { tanh_param_ = new ::opencv_caffe::TanHParameter(*from.tanh_param_); } else { tanh_param_ = nullptr; } if (from._internal_has_sigmoid_param()) { sigmoid_param_ = new ::opencv_caffe::SigmoidParameter(*from.sigmoid_param_); } else { sigmoid_param_ = nullptr; } if (from._internal_has_softmax_param()) { softmax_param_ = new ::opencv_caffe::SoftmaxParameter(*from.softmax_param_); } else { softmax_param_ = nullptr; } if (from._internal_has_contrastive_loss_param()) { contrastive_loss_param_ = new ::opencv_caffe::ContrastiveLossParameter(*from.contrastive_loss_param_); } else { contrastive_loss_param_ = nullptr; } if (from._internal_has_exp_param()) { exp_param_ = new ::opencv_caffe::ExpParameter(*from.exp_param_); } else { exp_param_ = nullptr; } if (from._internal_has_loss_param()) { loss_param_ = new ::opencv_caffe::LossParameter(*from.loss_param_); } else { loss_param_ = nullptr; } type_ = from.type_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.V1LayerParameter) } inline void V1LayerParameter::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&layer_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&type_) - reinterpret_cast(&layer_)) + sizeof(type_)); } V1LayerParameter::~V1LayerParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.V1LayerParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void V1LayerParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete layer_; if (this != internal_default_instance()) delete concat_param_; if (this != internal_default_instance()) delete convolution_param_; if (this != internal_default_instance()) delete data_param_; if (this != internal_default_instance()) delete dropout_param_; if (this != internal_default_instance()) delete hdf5_data_param_; if (this != internal_default_instance()) delete hdf5_output_param_; if (this != internal_default_instance()) delete image_data_param_; if (this != internal_default_instance()) delete infogain_loss_param_; if (this != internal_default_instance()) delete inner_product_param_; if (this != internal_default_instance()) delete lrn_param_; if (this != internal_default_instance()) delete pooling_param_; if (this != internal_default_instance()) delete window_data_param_; if (this != internal_default_instance()) delete power_param_; if (this != internal_default_instance()) delete memory_data_param_; if (this != internal_default_instance()) delete argmax_param_; if (this != internal_default_instance()) delete eltwise_param_; if (this != internal_default_instance()) delete threshold_param_; if (this != internal_default_instance()) delete dummy_data_param_; if (this != internal_default_instance()) delete accuracy_param_; if (this != internal_default_instance()) delete hinge_loss_param_; if (this != internal_default_instance()) delete relu_param_; if (this != internal_default_instance()) delete slice_param_; if (this != internal_default_instance()) delete mvn_param_; if (this != internal_default_instance()) delete transform_param_; if (this != internal_default_instance()) delete tanh_param_; if (this != internal_default_instance()) delete sigmoid_param_; if (this != internal_default_instance()) delete softmax_param_; if (this != internal_default_instance()) delete contrastive_loss_param_; if (this != internal_default_instance()) delete exp_param_; if (this != internal_default_instance()) delete loss_param_; } void V1LayerParameter::ArenaDtor(void* object) { V1LayerParameter* _this = reinterpret_cast< V1LayerParameter* >(object); (void)_this; } void V1LayerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void V1LayerParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void V1LayerParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.V1LayerParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; bottom_.Clear(); top_.Clear(); blobs_.Clear(); blobs_lr_.Clear(); weight_decay_.Clear(); include_.Clear(); exclude_.Clear(); loss_weight_.Clear(); param_.Clear(); blob_share_mode_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { name_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { GOOGLE_DCHECK(layer_ != nullptr); layer_->Clear(); } if (cached_has_bits & 0x00000004u) { GOOGLE_DCHECK(concat_param_ != nullptr); concat_param_->Clear(); } if (cached_has_bits & 0x00000008u) { GOOGLE_DCHECK(convolution_param_ != nullptr); convolution_param_->Clear(); } if (cached_has_bits & 0x00000010u) { GOOGLE_DCHECK(data_param_ != nullptr); data_param_->Clear(); } if (cached_has_bits & 0x00000020u) { GOOGLE_DCHECK(dropout_param_ != nullptr); dropout_param_->Clear(); } if (cached_has_bits & 0x00000040u) { GOOGLE_DCHECK(hdf5_data_param_ != nullptr); hdf5_data_param_->Clear(); } if (cached_has_bits & 0x00000080u) { GOOGLE_DCHECK(hdf5_output_param_ != nullptr); hdf5_output_param_->Clear(); } } if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { GOOGLE_DCHECK(image_data_param_ != nullptr); image_data_param_->Clear(); } if (cached_has_bits & 0x00000200u) { GOOGLE_DCHECK(infogain_loss_param_ != nullptr); infogain_loss_param_->Clear(); } if (cached_has_bits & 0x00000400u) { GOOGLE_DCHECK(inner_product_param_ != nullptr); inner_product_param_->Clear(); } if (cached_has_bits & 0x00000800u) { GOOGLE_DCHECK(lrn_param_ != nullptr); lrn_param_->Clear(); } if (cached_has_bits & 0x00001000u) { GOOGLE_DCHECK(pooling_param_ != nullptr); pooling_param_->Clear(); } if (cached_has_bits & 0x00002000u) { GOOGLE_DCHECK(window_data_param_ != nullptr); window_data_param_->Clear(); } if (cached_has_bits & 0x00004000u) { GOOGLE_DCHECK(power_param_ != nullptr); power_param_->Clear(); } if (cached_has_bits & 0x00008000u) { GOOGLE_DCHECK(memory_data_param_ != nullptr); memory_data_param_->Clear(); } } if (cached_has_bits & 0x00ff0000u) { if (cached_has_bits & 0x00010000u) { GOOGLE_DCHECK(argmax_param_ != nullptr); argmax_param_->Clear(); } if (cached_has_bits & 0x00020000u) { GOOGLE_DCHECK(eltwise_param_ != nullptr); eltwise_param_->Clear(); } if (cached_has_bits & 0x00040000u) { GOOGLE_DCHECK(threshold_param_ != nullptr); threshold_param_->Clear(); } if (cached_has_bits & 0x00080000u) { GOOGLE_DCHECK(dummy_data_param_ != nullptr); dummy_data_param_->Clear(); } if (cached_has_bits & 0x00100000u) { GOOGLE_DCHECK(accuracy_param_ != nullptr); accuracy_param_->Clear(); } if (cached_has_bits & 0x00200000u) { GOOGLE_DCHECK(hinge_loss_param_ != nullptr); hinge_loss_param_->Clear(); } if (cached_has_bits & 0x00400000u) { GOOGLE_DCHECK(relu_param_ != nullptr); relu_param_->Clear(); } if (cached_has_bits & 0x00800000u) { GOOGLE_DCHECK(slice_param_ != nullptr); slice_param_->Clear(); } } if (cached_has_bits & 0xff000000u) { if (cached_has_bits & 0x01000000u) { GOOGLE_DCHECK(mvn_param_ != nullptr); mvn_param_->Clear(); } if (cached_has_bits & 0x02000000u) { GOOGLE_DCHECK(transform_param_ != nullptr); transform_param_->Clear(); } if (cached_has_bits & 0x04000000u) { GOOGLE_DCHECK(tanh_param_ != nullptr); tanh_param_->Clear(); } if (cached_has_bits & 0x08000000u) { GOOGLE_DCHECK(sigmoid_param_ != nullptr); sigmoid_param_->Clear(); } if (cached_has_bits & 0x10000000u) { GOOGLE_DCHECK(softmax_param_ != nullptr); softmax_param_->Clear(); } if (cached_has_bits & 0x20000000u) { GOOGLE_DCHECK(contrastive_loss_param_ != nullptr); contrastive_loss_param_->Clear(); } if (cached_has_bits & 0x40000000u) { GOOGLE_DCHECK(exp_param_ != nullptr); exp_param_->Clear(); } if (cached_has_bits & 0x80000000u) { GOOGLE_DCHECK(loss_param_ != nullptr); loss_param_->Clear(); } } type_ = 0; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* V1LayerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.V0LayerParameter layer = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_layer(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated string bottom = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_bottom(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V1LayerParameter.bottom"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; // repeated string top = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_top(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V1LayerParameter.top"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; // optional string name = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V1LayerParameter.name"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.V1LayerParameter.LayerType type = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::V1LayerParameter_LayerType_IsValid(val))) { _internal_set_type(static_cast<::opencv_caffe::V1LayerParameter_LayerType>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // repeated .opencv_caffe.BlobProto blobs = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_blobs(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); } else goto handle_unusual; continue; // repeated float blobs_lr = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { ptr -= 1; do { ptr += 1; _internal_add_blobs_lr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<61>(ptr)); } else if (static_cast(tag) == 58) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_blobs_lr(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated float weight_decay = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { ptr -= 1; do { ptr += 1; _internal_add_weight_decay(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<69>(ptr)); } else if (static_cast(tag) == 66) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_weight_decay(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ConcatParameter concat_param = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_concat_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ConvolutionParameter convolution_param = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_convolution_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.DataParameter data_param = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.DropoutParameter dropout_param = 12; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { ptr = ctx->ParseMessage(_internal_mutable_dropout_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_hdf5_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14; case 14: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { ptr = ctx->ParseMessage(_internal_mutable_hdf5_output_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ImageDataParameter image_data_param = 15; case 15: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { ptr = ctx->ParseMessage(_internal_mutable_image_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_infogain_loss_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.InnerProductParameter inner_product_param = 17; case 17: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_inner_product_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.LRNParameter lrn_param = 18; case 18: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { ptr = ctx->ParseMessage(_internal_mutable_lrn_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PoolingParameter pooling_param = 19; case 19: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_pooling_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.WindowDataParameter window_data_param = 20; case 20: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_window_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.PowerParameter power_param = 21; case 21: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_power_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22; case 22: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_memory_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ArgMaxParameter argmax_param = 23; case 23: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { ptr = ctx->ParseMessage(_internal_mutable_argmax_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.EltwiseParameter eltwise_param = 24; case 24: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_eltwise_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ThresholdParameter threshold_param = 25; case 25: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_threshold_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26; case 26: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { ptr = ctx->ParseMessage(_internal_mutable_dummy_data_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.AccuracyParameter accuracy_param = 27; case 27: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { ptr = ctx->ParseMessage(_internal_mutable_accuracy_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29; case 29: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_hinge_loss_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ReLUParameter relu_param = 30; case 30: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { ptr = ctx->ParseMessage(_internal_mutable_relu_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SliceParameter slice_param = 31; case 31: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { ptr = ctx->ParseMessage(_internal_mutable_slice_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated .opencv_caffe.NetStateRule include = 32; case 32: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { ptr -= 2; do { ptr += 2; ptr = ctx->ParseMessage(_internal_add_include(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<258>(ptr)); } else goto handle_unusual; continue; // repeated .opencv_caffe.NetStateRule exclude = 33; case 33: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 2; do { ptr += 2; ptr = ctx->ParseMessage(_internal_add_exclude(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<266>(ptr)); } else goto handle_unusual; continue; // optional .opencv_caffe.MVNParameter mvn_param = 34; case 34: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_mvn_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated float loss_weight = 35; case 35: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { ptr -= 2; do { ptr += 2; _internal_add_loss_weight(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<285>(ptr)); } else if (static_cast(tag) == 26) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_loss_weight(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.TransformationParameter transform_param = 36; case 36: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_transform_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.TanHParameter tanh_param = 37; case 37: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_tanh_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38; case 38: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_sigmoid_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.SoftmaxParameter softmax_param = 39; case 39: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_softmax_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40; case 40: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_contrastive_loss_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.ExpParameter exp_param = 41; case 41: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_exp_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.LossParameter loss_param = 42; case 42: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_loss_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated string param = 1001; case 1001: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr -= 2; do { ptr += 2; auto str = _internal_add_param(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V1LayerParameter.param"); #endif // !NDEBUG CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8010>(ptr)); } else goto handle_unusual; continue; // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; case 1002: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { ptr -= 2; do { ptr += 2; uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid(val))) { _internal_add_blob_share_mode(static_cast<::opencv_caffe::V1LayerParameter_DimCheckMode>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1002, val, mutable_unknown_fields()); } if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8016>(ptr)); } else if (static_cast(tag) == 82) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_blob_share_mode(), ptr, ctx, ::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid, &_internal_metadata_, 1002); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* V1LayerParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.V1LayerParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.V0LayerParameter layer = 1; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 1, _Internal::layer(this), target, stream); } // repeated string bottom = 2; for (int i = 0, n = this->_internal_bottom_size(); i < n; i++) { const auto& s = this->_internal_bottom(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.V1LayerParameter.bottom"); target = stream->WriteString(2, s, target); } // repeated string top = 3; for (int i = 0, n = this->_internal_top_size(); i < n; i++) { const auto& s = this->_internal_top(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.V1LayerParameter.top"); target = stream->WriteString(3, s, target); } // optional string name = 4; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.V1LayerParameter.name"); target = stream->WriteStringMaybeAliased( 4, this->_internal_name(), target); } cached_has_bits = _has_bits_[1]; // optional .opencv_caffe.V1LayerParameter.LayerType type = 5; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 5, this->_internal_type(), target); } // repeated .opencv_caffe.BlobProto blobs = 6; for (unsigned int i = 0, n = static_cast(this->_internal_blobs_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(6, this->_internal_blobs(i), target, stream); } // repeated float blobs_lr = 7; for (int i = 0, n = this->_internal_blobs_lr_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_blobs_lr(i), target); } // repeated float weight_decay = 8; for (int i = 0, n = this->_internal_weight_decay_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_weight_decay(i), target); } cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.ConcatParameter concat_param = 9; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 9, _Internal::concat_param(this), target, stream); } // optional .opencv_caffe.ConvolutionParameter convolution_param = 10; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 10, _Internal::convolution_param(this), target, stream); } // optional .opencv_caffe.DataParameter data_param = 11; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 11, _Internal::data_param(this), target, stream); } // optional .opencv_caffe.DropoutParameter dropout_param = 12; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 12, _Internal::dropout_param(this), target, stream); } // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 13, _Internal::hdf5_data_param(this), target, stream); } // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 14, _Internal::hdf5_output_param(this), target, stream); } // optional .opencv_caffe.ImageDataParameter image_data_param = 15; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 15, _Internal::image_data_param(this), target, stream); } // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 16, _Internal::infogain_loss_param(this), target, stream); } // optional .opencv_caffe.InnerProductParameter inner_product_param = 17; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 17, _Internal::inner_product_param(this), target, stream); } // optional .opencv_caffe.LRNParameter lrn_param = 18; if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 18, _Internal::lrn_param(this), target, stream); } // optional .opencv_caffe.PoolingParameter pooling_param = 19; if (cached_has_bits & 0x00001000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 19, _Internal::pooling_param(this), target, stream); } // optional .opencv_caffe.WindowDataParameter window_data_param = 20; if (cached_has_bits & 0x00002000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 20, _Internal::window_data_param(this), target, stream); } // optional .opencv_caffe.PowerParameter power_param = 21; if (cached_has_bits & 0x00004000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 21, _Internal::power_param(this), target, stream); } // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22; if (cached_has_bits & 0x00008000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 22, _Internal::memory_data_param(this), target, stream); } // optional .opencv_caffe.ArgMaxParameter argmax_param = 23; if (cached_has_bits & 0x00010000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 23, _Internal::argmax_param(this), target, stream); } // optional .opencv_caffe.EltwiseParameter eltwise_param = 24; if (cached_has_bits & 0x00020000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 24, _Internal::eltwise_param(this), target, stream); } // optional .opencv_caffe.ThresholdParameter threshold_param = 25; if (cached_has_bits & 0x00040000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 25, _Internal::threshold_param(this), target, stream); } // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26; if (cached_has_bits & 0x00080000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 26, _Internal::dummy_data_param(this), target, stream); } // optional .opencv_caffe.AccuracyParameter accuracy_param = 27; if (cached_has_bits & 0x00100000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 27, _Internal::accuracy_param(this), target, stream); } // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29; if (cached_has_bits & 0x00200000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 29, _Internal::hinge_loss_param(this), target, stream); } // optional .opencv_caffe.ReLUParameter relu_param = 30; if (cached_has_bits & 0x00400000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 30, _Internal::relu_param(this), target, stream); } // optional .opencv_caffe.SliceParameter slice_param = 31; if (cached_has_bits & 0x00800000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 31, _Internal::slice_param(this), target, stream); } // repeated .opencv_caffe.NetStateRule include = 32; for (unsigned int i = 0, n = static_cast(this->_internal_include_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(32, this->_internal_include(i), target, stream); } // repeated .opencv_caffe.NetStateRule exclude = 33; for (unsigned int i = 0, n = static_cast(this->_internal_exclude_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(33, this->_internal_exclude(i), target, stream); } // optional .opencv_caffe.MVNParameter mvn_param = 34; if (cached_has_bits & 0x01000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 34, _Internal::mvn_param(this), target, stream); } // repeated float loss_weight = 35; for (int i = 0, n = this->_internal_loss_weight_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(35, this->_internal_loss_weight(i), target); } // optional .opencv_caffe.TransformationParameter transform_param = 36; if (cached_has_bits & 0x02000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 36, _Internal::transform_param(this), target, stream); } // optional .opencv_caffe.TanHParameter tanh_param = 37; if (cached_has_bits & 0x04000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 37, _Internal::tanh_param(this), target, stream); } // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38; if (cached_has_bits & 0x08000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 38, _Internal::sigmoid_param(this), target, stream); } // optional .opencv_caffe.SoftmaxParameter softmax_param = 39; if (cached_has_bits & 0x10000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 39, _Internal::softmax_param(this), target, stream); } // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40; if (cached_has_bits & 0x20000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 40, _Internal::contrastive_loss_param(this), target, stream); } // optional .opencv_caffe.ExpParameter exp_param = 41; if (cached_has_bits & 0x40000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 41, _Internal::exp_param(this), target, stream); } // optional .opencv_caffe.LossParameter loss_param = 42; if (cached_has_bits & 0x80000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 42, _Internal::loss_param(this), target, stream); } // repeated string param = 1001; for (int i = 0, n = this->_internal_param_size(); i < n; i++) { const auto& s = this->_internal_param(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.V1LayerParameter.param"); target = stream->WriteString(1001, s, target); } // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; for (int i = 0, n = this->_internal_blob_share_mode_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1002, this->_internal_blob_share_mode(i), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.V1LayerParameter) return target; } size_t V1LayerParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.V1LayerParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string bottom = 2; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(bottom_.size()); for (int i = 0, n = bottom_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( bottom_.Get(i)); } // repeated string top = 3; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(top_.size()); for (int i = 0, n = top_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( top_.Get(i)); } // repeated .opencv_caffe.BlobProto blobs = 6; total_size += 1UL * this->_internal_blobs_size(); for (const auto& msg : this->blobs_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated float blobs_lr = 7; { unsigned int count = static_cast(this->_internal_blobs_lr_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_blobs_lr_size()); total_size += data_size; } // repeated float weight_decay = 8; { unsigned int count = static_cast(this->_internal_weight_decay_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_weight_decay_size()); total_size += data_size; } // repeated .opencv_caffe.NetStateRule include = 32; total_size += 2UL * this->_internal_include_size(); for (const auto& msg : this->include_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated .opencv_caffe.NetStateRule exclude = 33; total_size += 2UL * this->_internal_exclude_size(); for (const auto& msg : this->exclude_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated float loss_weight = 35; { unsigned int count = static_cast(this->_internal_loss_weight_size()); size_t data_size = 4UL * count; total_size += 2 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_loss_weight_size()); total_size += data_size; } // repeated string param = 1001; total_size += 2 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(param_.size()); for (int i = 0, n = param_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( param_.Get(i)); } // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; { size_t data_size = 0; unsigned int count = static_cast(this->_internal_blob_share_mode_size());for (unsigned int i = 0; i < count; i++) { data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize( this->_internal_blob_share_mode(static_cast(i))); } total_size += (2UL * count) + data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional string name = 4; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // optional .opencv_caffe.V0LayerParameter layer = 1; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *layer_); } // optional .opencv_caffe.ConcatParameter concat_param = 9; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *concat_param_); } // optional .opencv_caffe.ConvolutionParameter convolution_param = 10; if (cached_has_bits & 0x00000008u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *convolution_param_); } // optional .opencv_caffe.DataParameter data_param = 11; if (cached_has_bits & 0x00000010u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_param_); } // optional .opencv_caffe.DropoutParameter dropout_param = 12; if (cached_has_bits & 0x00000020u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *dropout_param_); } // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13; if (cached_has_bits & 0x00000040u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *hdf5_data_param_); } // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14; if (cached_has_bits & 0x00000080u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *hdf5_output_param_); } } if (cached_has_bits & 0x0000ff00u) { // optional .opencv_caffe.ImageDataParameter image_data_param = 15; if (cached_has_bits & 0x00000100u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *image_data_param_); } // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16; if (cached_has_bits & 0x00000200u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *infogain_loss_param_); } // optional .opencv_caffe.InnerProductParameter inner_product_param = 17; if (cached_has_bits & 0x00000400u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *inner_product_param_); } // optional .opencv_caffe.LRNParameter lrn_param = 18; if (cached_has_bits & 0x00000800u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *lrn_param_); } // optional .opencv_caffe.PoolingParameter pooling_param = 19; if (cached_has_bits & 0x00001000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *pooling_param_); } // optional .opencv_caffe.WindowDataParameter window_data_param = 20; if (cached_has_bits & 0x00002000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *window_data_param_); } // optional .opencv_caffe.PowerParameter power_param = 21; if (cached_has_bits & 0x00004000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *power_param_); } // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22; if (cached_has_bits & 0x00008000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *memory_data_param_); } } if (cached_has_bits & 0x00ff0000u) { // optional .opencv_caffe.ArgMaxParameter argmax_param = 23; if (cached_has_bits & 0x00010000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *argmax_param_); } // optional .opencv_caffe.EltwiseParameter eltwise_param = 24; if (cached_has_bits & 0x00020000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *eltwise_param_); } // optional .opencv_caffe.ThresholdParameter threshold_param = 25; if (cached_has_bits & 0x00040000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *threshold_param_); } // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26; if (cached_has_bits & 0x00080000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *dummy_data_param_); } // optional .opencv_caffe.AccuracyParameter accuracy_param = 27; if (cached_has_bits & 0x00100000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *accuracy_param_); } // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29; if (cached_has_bits & 0x00200000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *hinge_loss_param_); } // optional .opencv_caffe.ReLUParameter relu_param = 30; if (cached_has_bits & 0x00400000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *relu_param_); } // optional .opencv_caffe.SliceParameter slice_param = 31; if (cached_has_bits & 0x00800000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *slice_param_); } } if (cached_has_bits & 0xff000000u) { // optional .opencv_caffe.MVNParameter mvn_param = 34; if (cached_has_bits & 0x01000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *mvn_param_); } // optional .opencv_caffe.TransformationParameter transform_param = 36; if (cached_has_bits & 0x02000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *transform_param_); } // optional .opencv_caffe.TanHParameter tanh_param = 37; if (cached_has_bits & 0x04000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *tanh_param_); } // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38; if (cached_has_bits & 0x08000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *sigmoid_param_); } // optional .opencv_caffe.SoftmaxParameter softmax_param = 39; if (cached_has_bits & 0x10000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *softmax_param_); } // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40; if (cached_has_bits & 0x20000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *contrastive_loss_param_); } // optional .opencv_caffe.ExpParameter exp_param = 41; if (cached_has_bits & 0x40000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *exp_param_); } // optional .opencv_caffe.LossParameter loss_param = 42; if (cached_has_bits & 0x80000000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *loss_param_); } } // optional .opencv_caffe.V1LayerParameter.LayerType type = 5; cached_has_bits = _has_bits_[1]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData V1LayerParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, V1LayerParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*V1LayerParameter::GetClassData() const { return &_class_data_; } void V1LayerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void V1LayerParameter::MergeFrom(const V1LayerParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.V1LayerParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; bottom_.MergeFrom(from.bottom_); top_.MergeFrom(from.top_); blobs_.MergeFrom(from.blobs_); blobs_lr_.MergeFrom(from.blobs_lr_); weight_decay_.MergeFrom(from.weight_decay_); include_.MergeFrom(from.include_); exclude_.MergeFrom(from.exclude_); loss_weight_.MergeFrom(from.loss_weight_); param_.MergeFrom(from.param_); blob_share_mode_.MergeFrom(from.blob_share_mode_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_name(from._internal_name()); } if (cached_has_bits & 0x00000002u) { _internal_mutable_layer()->::opencv_caffe::V0LayerParameter::MergeFrom(from._internal_layer()); } if (cached_has_bits & 0x00000004u) { _internal_mutable_concat_param()->::opencv_caffe::ConcatParameter::MergeFrom(from._internal_concat_param()); } if (cached_has_bits & 0x00000008u) { _internal_mutable_convolution_param()->::opencv_caffe::ConvolutionParameter::MergeFrom(from._internal_convolution_param()); } if (cached_has_bits & 0x00000010u) { _internal_mutable_data_param()->::opencv_caffe::DataParameter::MergeFrom(from._internal_data_param()); } if (cached_has_bits & 0x00000020u) { _internal_mutable_dropout_param()->::opencv_caffe::DropoutParameter::MergeFrom(from._internal_dropout_param()); } if (cached_has_bits & 0x00000040u) { _internal_mutable_hdf5_data_param()->::opencv_caffe::HDF5DataParameter::MergeFrom(from._internal_hdf5_data_param()); } if (cached_has_bits & 0x00000080u) { _internal_mutable_hdf5_output_param()->::opencv_caffe::HDF5OutputParameter::MergeFrom(from._internal_hdf5_output_param()); } } if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { _internal_mutable_image_data_param()->::opencv_caffe::ImageDataParameter::MergeFrom(from._internal_image_data_param()); } if (cached_has_bits & 0x00000200u) { _internal_mutable_infogain_loss_param()->::opencv_caffe::InfogainLossParameter::MergeFrom(from._internal_infogain_loss_param()); } if (cached_has_bits & 0x00000400u) { _internal_mutable_inner_product_param()->::opencv_caffe::InnerProductParameter::MergeFrom(from._internal_inner_product_param()); } if (cached_has_bits & 0x00000800u) { _internal_mutable_lrn_param()->::opencv_caffe::LRNParameter::MergeFrom(from._internal_lrn_param()); } if (cached_has_bits & 0x00001000u) { _internal_mutable_pooling_param()->::opencv_caffe::PoolingParameter::MergeFrom(from._internal_pooling_param()); } if (cached_has_bits & 0x00002000u) { _internal_mutable_window_data_param()->::opencv_caffe::WindowDataParameter::MergeFrom(from._internal_window_data_param()); } if (cached_has_bits & 0x00004000u) { _internal_mutable_power_param()->::opencv_caffe::PowerParameter::MergeFrom(from._internal_power_param()); } if (cached_has_bits & 0x00008000u) { _internal_mutable_memory_data_param()->::opencv_caffe::MemoryDataParameter::MergeFrom(from._internal_memory_data_param()); } } if (cached_has_bits & 0x00ff0000u) { if (cached_has_bits & 0x00010000u) { _internal_mutable_argmax_param()->::opencv_caffe::ArgMaxParameter::MergeFrom(from._internal_argmax_param()); } if (cached_has_bits & 0x00020000u) { _internal_mutable_eltwise_param()->::opencv_caffe::EltwiseParameter::MergeFrom(from._internal_eltwise_param()); } if (cached_has_bits & 0x00040000u) { _internal_mutable_threshold_param()->::opencv_caffe::ThresholdParameter::MergeFrom(from._internal_threshold_param()); } if (cached_has_bits & 0x00080000u) { _internal_mutable_dummy_data_param()->::opencv_caffe::DummyDataParameter::MergeFrom(from._internal_dummy_data_param()); } if (cached_has_bits & 0x00100000u) { _internal_mutable_accuracy_param()->::opencv_caffe::AccuracyParameter::MergeFrom(from._internal_accuracy_param()); } if (cached_has_bits & 0x00200000u) { _internal_mutable_hinge_loss_param()->::opencv_caffe::HingeLossParameter::MergeFrom(from._internal_hinge_loss_param()); } if (cached_has_bits & 0x00400000u) { _internal_mutable_relu_param()->::opencv_caffe::ReLUParameter::MergeFrom(from._internal_relu_param()); } if (cached_has_bits & 0x00800000u) { _internal_mutable_slice_param()->::opencv_caffe::SliceParameter::MergeFrom(from._internal_slice_param()); } } if (cached_has_bits & 0xff000000u) { if (cached_has_bits & 0x01000000u) { _internal_mutable_mvn_param()->::opencv_caffe::MVNParameter::MergeFrom(from._internal_mvn_param()); } if (cached_has_bits & 0x02000000u) { _internal_mutable_transform_param()->::opencv_caffe::TransformationParameter::MergeFrom(from._internal_transform_param()); } if (cached_has_bits & 0x04000000u) { _internal_mutable_tanh_param()->::opencv_caffe::TanHParameter::MergeFrom(from._internal_tanh_param()); } if (cached_has_bits & 0x08000000u) { _internal_mutable_sigmoid_param()->::opencv_caffe::SigmoidParameter::MergeFrom(from._internal_sigmoid_param()); } if (cached_has_bits & 0x10000000u) { _internal_mutable_softmax_param()->::opencv_caffe::SoftmaxParameter::MergeFrom(from._internal_softmax_param()); } if (cached_has_bits & 0x20000000u) { _internal_mutable_contrastive_loss_param()->::opencv_caffe::ContrastiveLossParameter::MergeFrom(from._internal_contrastive_loss_param()); } if (cached_has_bits & 0x40000000u) { _internal_mutable_exp_param()->::opencv_caffe::ExpParameter::MergeFrom(from._internal_exp_param()); } if (cached_has_bits & 0x80000000u) { _internal_mutable_loss_param()->::opencv_caffe::LossParameter::MergeFrom(from._internal_loss_param()); } } if (from._internal_has_type()) { _internal_set_type(from._internal_type()); } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void V1LayerParameter::CopyFrom(const V1LayerParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.V1LayerParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool V1LayerParameter::IsInitialized() const { return true; } void V1LayerParameter::InternalSwap(V1LayerParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(_has_bits_[1], other->_has_bits_[1]); bottom_.InternalSwap(&other->bottom_); top_.InternalSwap(&other->top_); blobs_.InternalSwap(&other->blobs_); blobs_lr_.InternalSwap(&other->blobs_lr_); weight_decay_.InternalSwap(&other->weight_decay_); include_.InternalSwap(&other->include_); exclude_.InternalSwap(&other->exclude_); loss_weight_.InternalSwap(&other->loss_weight_); param_.InternalSwap(&other->param_); blob_share_mode_.InternalSwap(&other->blob_share_mode_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &name_, lhs_arena, &other->name_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(V1LayerParameter, type_) + sizeof(V1LayerParameter::type_) - PROTOBUF_FIELD_OFFSET(V1LayerParameter, layer_)>( reinterpret_cast(&layer_), reinterpret_cast(&other->layer_)); } ::PROTOBUF_NAMESPACE_ID::Metadata V1LayerParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[64]); } // =================================================================== class V0LayerParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_name(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_type(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_num_output(HasBits* has_bits) { (*has_bits)[0] |= 256u; } static void set_has_biasterm(HasBits* has_bits) { (*has_bits)[0] |= 8388608u; } static const ::opencv_caffe::FillerParameter& weight_filler(const V0LayerParameter* msg); static void set_has_weight_filler(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static const ::opencv_caffe::FillerParameter& bias_filler(const V0LayerParameter* msg); static void set_has_bias_filler(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_pad(HasBits* has_bits) { (*has_bits)[0] |= 512u; } static void set_has_kernelsize(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } static void set_has_group(HasBits* has_bits) { (*has_bits)[0] |= 16777216u; } static void set_has_stride(HasBits* has_bits) { (*has_bits)[0] |= 33554432u; } static void set_has_pool(HasBits* has_bits) { (*has_bits)[0] |= 2048u; } static void set_has_dropout_ratio(HasBits* has_bits) { (*has_bits)[0] |= 67108864u; } static void set_has_local_size(HasBits* has_bits) { (*has_bits)[0] |= 134217728u; } static void set_has_alpha(HasBits* has_bits) { (*has_bits)[0] |= 268435456u; } static void set_has_beta(HasBits* has_bits) { (*has_bits)[0] |= 536870912u; } static void set_has_k(HasBits* has_bits) { (*has_bits)[0] |= 2147483648u; } static void set_has_source(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_scale(HasBits* has_bits) { (*has_bits)[0] |= 1073741824u; } static void set_has_meanfile(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_batchsize(HasBits* has_bits) { (*has_bits)[0] |= 4096u; } static void set_has_cropsize(HasBits* has_bits) { (*has_bits)[0] |= 8192u; } static void set_has_mirror(HasBits* has_bits) { (*has_bits)[0] |= 32768u; } static void set_has_rand_skip(HasBits* has_bits) { (*has_bits)[0] |= 131072u; } static void set_has_det_fg_threshold(HasBits* has_bits) { (*has_bits)[1] |= 1u; } static void set_has_det_bg_threshold(HasBits* has_bits) { (*has_bits)[1] |= 2u; } static void set_has_det_fg_fraction(HasBits* has_bits) { (*has_bits)[1] |= 4u; } static void set_has_det_context_pad(HasBits* has_bits) { (*has_bits)[0] |= 262144u; } static void set_has_det_crop_mode(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_new_num(HasBits* has_bits) { (*has_bits)[0] |= 524288u; } static void set_has_new_channels(HasBits* has_bits) { (*has_bits)[0] |= 1048576u; } static void set_has_new_height(HasBits* has_bits) { (*has_bits)[0] |= 2097152u; } static void set_has_new_width(HasBits* has_bits) { (*has_bits)[0] |= 16384u; } static void set_has_shuffle_images(HasBits* has_bits) { (*has_bits)[0] |= 65536u; } static void set_has_concat_dim(HasBits* has_bits) { (*has_bits)[0] |= 4194304u; } static const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param(const V0LayerParameter* msg); static void set_has_hdf5_output_param(HasBits* has_bits) { (*has_bits)[0] |= 128u; } }; const ::opencv_caffe::FillerParameter& V0LayerParameter::_Internal::weight_filler(const V0LayerParameter* msg) { return *msg->weight_filler_; } const ::opencv_caffe::FillerParameter& V0LayerParameter::_Internal::bias_filler(const V0LayerParameter* msg) { return *msg->bias_filler_; } const ::opencv_caffe::HDF5OutputParameter& V0LayerParameter::_Internal::hdf5_output_param(const V0LayerParameter* msg) { return *msg->hdf5_output_param_; } const ::PROTOBUF_NAMESPACE_ID::internal::LazyString V0LayerParameter::_i_give_permission_to_break_this_code_default_det_crop_mode_{{{"warp", 4}}, {nullptr}}; V0LayerParameter::V0LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), blobs_(arena), blobs_lr_(arena), weight_decay_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.V0LayerParameter) } V0LayerParameter::V0LayerParameter(const V0LayerParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), blobs_(from.blobs_), blobs_lr_(from.blobs_lr_), weight_decay_(from.weight_decay_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_name()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), GetArenaForAllocation()); } type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_type()) { type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_type(), GetArenaForAllocation()); } source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_source()) { source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_source(), GetArenaForAllocation()); } meanfile_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING meanfile_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (from._internal_has_meanfile()) { meanfile_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_meanfile(), GetArenaForAllocation()); } det_crop_mode_.UnsafeSetDefault(nullptr); if (from._internal_has_det_crop_mode()) { det_crop_mode_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_det_crop_mode(), GetArenaForAllocation()); } if (from._internal_has_weight_filler()) { weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_); } else { weight_filler_ = nullptr; } if (from._internal_has_bias_filler()) { bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_); } else { bias_filler_ = nullptr; } if (from._internal_has_hdf5_output_param()) { hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter(*from.hdf5_output_param_); } else { hdf5_output_param_ = nullptr; } ::memcpy(&num_output_, &from.num_output_, static_cast(reinterpret_cast(&det_fg_fraction_) - reinterpret_cast(&num_output_)) + sizeof(det_fg_fraction_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.V0LayerParameter) } inline void V0LayerParameter::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING meanfile_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING meanfile_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING det_crop_mode_.UnsafeSetDefault(nullptr); ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&weight_filler_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&new_height_) - reinterpret_cast(&weight_filler_)) + sizeof(new_height_)); concat_dim_ = 1u; biasterm_ = true; group_ = 1u; stride_ = 1u; dropout_ratio_ = 0.5f; local_size_ = 5u; alpha_ = 1; beta_ = 0.75f; scale_ = 1; k_ = 1; det_fg_threshold_ = 0.5f; det_bg_threshold_ = 0.5f; det_fg_fraction_ = 0.25f; } V0LayerParameter::~V0LayerParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.V0LayerParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void V0LayerParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); meanfile_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); det_crop_mode_.DestroyNoArena(nullptr); if (this != internal_default_instance()) delete weight_filler_; if (this != internal_default_instance()) delete bias_filler_; if (this != internal_default_instance()) delete hdf5_output_param_; } void V0LayerParameter::ArenaDtor(void* object) { V0LayerParameter* _this = reinterpret_cast< V0LayerParameter* >(object); (void)_this; } void V0LayerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void V0LayerParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void V0LayerParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.V0LayerParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; blobs_.Clear(); blobs_lr_.Clear(); weight_decay_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { name_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { type_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000004u) { source_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000008u) { meanfile_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000010u) { det_crop_mode_.ClearToDefault(::opencv_caffe::V0LayerParameter::_i_give_permission_to_break_this_code_default_det_crop_mode_, GetArenaForAllocation()); } if (cached_has_bits & 0x00000020u) { GOOGLE_DCHECK(weight_filler_ != nullptr); weight_filler_->Clear(); } if (cached_has_bits & 0x00000040u) { GOOGLE_DCHECK(bias_filler_ != nullptr); bias_filler_->Clear(); } if (cached_has_bits & 0x00000080u) { GOOGLE_DCHECK(hdf5_output_param_ != nullptr); hdf5_output_param_->Clear(); } } if (cached_has_bits & 0x0000ff00u) { ::memset(&num_output_, 0, static_cast( reinterpret_cast(&mirror_) - reinterpret_cast(&num_output_)) + sizeof(mirror_)); } if (cached_has_bits & 0x00ff0000u) { ::memset(&shuffle_images_, 0, static_cast( reinterpret_cast(&new_height_) - reinterpret_cast(&shuffle_images_)) + sizeof(new_height_)); concat_dim_ = 1u; biasterm_ = true; } if (cached_has_bits & 0xff000000u) { group_ = 1u; stride_ = 1u; dropout_ratio_ = 0.5f; local_size_ = 5u; alpha_ = 1; beta_ = 0.75f; scale_ = 1; k_ = 1; } cached_has_bits = _has_bits_[1]; if (cached_has_bits & 0x00000007u) { det_fg_threshold_ = 0.5f; det_bg_threshold_ = 0.5f; det_fg_fraction_ = 0.25f; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* V0LayerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional string name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.name"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional string type = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_type(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.type"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 num_output = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_num_output(&_has_bits_); num_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool biasterm = 4 [default = true]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_biasterm(&_has_bits_); biasterm_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter weight_filler = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_weight_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.FillerParameter bias_filler = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_bias_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 pad = 7 [default = 0]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_pad(&_has_bits_); pad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 kernelsize = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { _Internal::set_has_kernelsize(&_has_bits_); kernelsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 group = 9 [default = 1]; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { _Internal::set_has_group(&_has_bits_); group_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 stride = 10 [default = 1]; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { _Internal::set_has_stride(&_has_bits_); stride_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); if (PROTOBUF_PREDICT_TRUE(::opencv_caffe::V0LayerParameter_PoolMethod_IsValid(val))) { _internal_set_pool(static_cast<::opencv_caffe::V0LayerParameter_PoolMethod>(val)); } else { ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); } } else goto handle_unusual; continue; // optional float dropout_ratio = 12 [default = 0.5]; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 101)) { _Internal::set_has_dropout_ratio(&_has_bits_); dropout_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional uint32 local_size = 13 [default = 5]; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { _Internal::set_has_local_size(&_has_bits_); local_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float alpha = 14 [default = 1]; case 14: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 117)) { _Internal::set_has_alpha(&_has_bits_); alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float beta = 15 [default = 0.75]; case 15: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 125)) { _Internal::set_has_beta(&_has_bits_); beta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional string source = 16; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { auto str = _internal_mutable_source(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.source"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional float scale = 17 [default = 1]; case 17: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 141)) { _Internal::set_has_scale(&_has_bits_); scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional string meanfile = 18; case 18: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { auto str = _internal_mutable_meanfile(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.meanfile"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 batchsize = 19; case 19: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { _Internal::set_has_batchsize(&_has_bits_); batchsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 cropsize = 20 [default = 0]; case 20: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { _Internal::set_has_cropsize(&_has_bits_); cropsize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool mirror = 21 [default = false]; case 21: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { _Internal::set_has_mirror(&_has_bits_); mirror_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float k = 22 [default = 1]; case 22: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 181)) { _Internal::set_has_k(&_has_bits_); k_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // repeated .opencv_caffe.BlobProto blobs = 50; case 50: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { ptr -= 2; do { ptr += 2; ptr = ctx->ParseMessage(_internal_add_blobs(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<402>(ptr)); } else goto handle_unusual; continue; // repeated float blobs_lr = 51; case 51: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 157)) { ptr -= 2; do { ptr += 2; _internal_add_blobs_lr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<413>(ptr)); } else if (static_cast(tag) == 154) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_blobs_lr(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated float weight_decay = 52; case 52: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 165)) { ptr -= 2; do { ptr += 2; _internal_add_weight_decay(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<421>(ptr)); } else if (static_cast(tag) == 162) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_weight_decay(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 rand_skip = 53 [default = 0]; case 53: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { _Internal::set_has_rand_skip(&_has_bits_); rand_skip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float det_fg_threshold = 54 [default = 0.5]; case 54: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 181)) { _Internal::set_has_det_fg_threshold(&_has_bits_); det_fg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float det_bg_threshold = 55 [default = 0.5]; case 55: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 189)) { _Internal::set_has_det_bg_threshold(&_has_bits_); det_bg_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float det_fg_fraction = 56 [default = 0.25]; case 56: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 197)) { _Internal::set_has_det_fg_fraction(&_has_bits_); det_fg_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional uint32 det_context_pad = 58 [default = 0]; case 58: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 208)) { _Internal::set_has_det_context_pad(&_has_bits_); det_context_pad_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional string det_crop_mode = 59 [default = "warp"]; case 59: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { auto str = _internal_mutable_det_crop_mode(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); #ifndef NDEBUG ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "opencv_caffe.V0LayerParameter.det_crop_mode"); #endif // !NDEBUG CHK_(ptr); } else goto handle_unusual; continue; // optional int32 new_num = 60 [default = 0]; case 60: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 224)) { _Internal::set_has_new_num(&_has_bits_); new_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 new_channels = 61 [default = 0]; case 61: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 232)) { _Internal::set_has_new_channels(&_has_bits_); new_channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 new_height = 62 [default = 0]; case 62: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { _Internal::set_has_new_height(&_has_bits_); new_height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional int32 new_width = 63 [default = 0]; case 63: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { _Internal::set_has_new_width(&_has_bits_); new_width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool shuffle_images = 64 [default = false]; case 64: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 0)) { _Internal::set_has_shuffle_images(&_has_bits_); shuffle_images_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 concat_dim = 65 [default = 1]; case 65: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_concat_dim(&_has_bits_); concat_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001; case 1001: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_hdf5_output_param(), ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* V0LayerParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.V0LayerParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional string name = 1; if (cached_has_bits & 0x00000001u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.V0LayerParameter.name"); target = stream->WriteStringMaybeAliased( 1, this->_internal_name(), target); } // optional string type = 2; if (cached_has_bits & 0x00000002u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_type().data(), static_cast(this->_internal_type().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.V0LayerParameter.type"); target = stream->WriteStringMaybeAliased( 2, this->_internal_type(), target); } // optional uint32 num_output = 3; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_num_output(), target); } // optional bool biasterm = 4 [default = true]; if (cached_has_bits & 0x00800000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_biasterm(), target); } // optional .opencv_caffe.FillerParameter weight_filler = 5; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 5, _Internal::weight_filler(this), target, stream); } // optional .opencv_caffe.FillerParameter bias_filler = 6; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 6, _Internal::bias_filler(this), target, stream); } // optional uint32 pad = 7 [default = 0]; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_pad(), target); } // optional uint32 kernelsize = 8; if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_kernelsize(), target); } // optional uint32 group = 9 [default = 1]; if (cached_has_bits & 0x01000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_group(), target); } // optional uint32 stride = 10 [default = 1]; if (cached_has_bits & 0x02000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_stride(), target); } // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 11, this->_internal_pool(), target); } // optional float dropout_ratio = 12 [default = 0.5]; if (cached_has_bits & 0x04000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(12, this->_internal_dropout_ratio(), target); } // optional uint32 local_size = 13 [default = 5]; if (cached_has_bits & 0x08000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(13, this->_internal_local_size(), target); } // optional float alpha = 14 [default = 1]; if (cached_has_bits & 0x10000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(14, this->_internal_alpha(), target); } // optional float beta = 15 [default = 0.75]; if (cached_has_bits & 0x20000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(15, this->_internal_beta(), target); } // optional string source = 16; if (cached_has_bits & 0x00000004u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_source().data(), static_cast(this->_internal_source().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.V0LayerParameter.source"); target = stream->WriteStringMaybeAliased( 16, this->_internal_source(), target); } // optional float scale = 17 [default = 1]; if (cached_has_bits & 0x40000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(17, this->_internal_scale(), target); } // optional string meanfile = 18; if (cached_has_bits & 0x00000008u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_meanfile().data(), static_cast(this->_internal_meanfile().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.V0LayerParameter.meanfile"); target = stream->WriteStringMaybeAliased( 18, this->_internal_meanfile(), target); } // optional uint32 batchsize = 19; if (cached_has_bits & 0x00001000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(19, this->_internal_batchsize(), target); } // optional uint32 cropsize = 20 [default = 0]; if (cached_has_bits & 0x00002000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(20, this->_internal_cropsize(), target); } // optional bool mirror = 21 [default = false]; if (cached_has_bits & 0x00008000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(21, this->_internal_mirror(), target); } // optional float k = 22 [default = 1]; if (cached_has_bits & 0x80000000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(22, this->_internal_k(), target); } // repeated .opencv_caffe.BlobProto blobs = 50; for (unsigned int i = 0, n = static_cast(this->_internal_blobs_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(50, this->_internal_blobs(i), target, stream); } // repeated float blobs_lr = 51; for (int i = 0, n = this->_internal_blobs_lr_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(51, this->_internal_blobs_lr(i), target); } // repeated float weight_decay = 52; for (int i = 0, n = this->_internal_weight_decay_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(52, this->_internal_weight_decay(i), target); } // optional uint32 rand_skip = 53 [default = 0]; if (cached_has_bits & 0x00020000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(53, this->_internal_rand_skip(), target); } cached_has_bits = _has_bits_[1]; // optional float det_fg_threshold = 54 [default = 0.5]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(54, this->_internal_det_fg_threshold(), target); } // optional float det_bg_threshold = 55 [default = 0.5]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(55, this->_internal_det_bg_threshold(), target); } // optional float det_fg_fraction = 56 [default = 0.25]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(56, this->_internal_det_fg_fraction(), target); } cached_has_bits = _has_bits_[0]; // optional uint32 det_context_pad = 58 [default = 0]; if (cached_has_bits & 0x00040000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(58, this->_internal_det_context_pad(), target); } // optional string det_crop_mode = 59 [default = "warp"]; if (cached_has_bits & 0x00000010u) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( this->_internal_det_crop_mode().data(), static_cast(this->_internal_det_crop_mode().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, "opencv_caffe.V0LayerParameter.det_crop_mode"); target = stream->WriteStringMaybeAliased( 59, this->_internal_det_crop_mode(), target); } // optional int32 new_num = 60 [default = 0]; if (cached_has_bits & 0x00080000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(60, this->_internal_new_num(), target); } // optional int32 new_channels = 61 [default = 0]; if (cached_has_bits & 0x00100000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(61, this->_internal_new_channels(), target); } // optional int32 new_height = 62 [default = 0]; if (cached_has_bits & 0x00200000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(62, this->_internal_new_height(), target); } // optional int32 new_width = 63 [default = 0]; if (cached_has_bits & 0x00004000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(63, this->_internal_new_width(), target); } // optional bool shuffle_images = 64 [default = false]; if (cached_has_bits & 0x00010000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(64, this->_internal_shuffle_images(), target); } // optional uint32 concat_dim = 65 [default = 1]; if (cached_has_bits & 0x00400000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(65, this->_internal_concat_dim(), target); } // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 1001, _Internal::hdf5_output_param(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.V0LayerParameter) return target; } size_t V0LayerParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.V0LayerParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated .opencv_caffe.BlobProto blobs = 50; total_size += 2UL * this->_internal_blobs_size(); for (const auto& msg : this->blobs_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } // repeated float blobs_lr = 51; { unsigned int count = static_cast(this->_internal_blobs_lr_size()); size_t data_size = 4UL * count; total_size += 2 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_blobs_lr_size()); total_size += data_size; } // repeated float weight_decay = 52; { unsigned int count = static_cast(this->_internal_weight_decay_size()); size_t data_size = 4UL * count; total_size += 2 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_weight_decay_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional string name = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // optional string type = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_type()); } // optional string source = 16; if (cached_has_bits & 0x00000004u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_source()); } // optional string meanfile = 18; if (cached_has_bits & 0x00000008u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_meanfile()); } // optional string det_crop_mode = 59 [default = "warp"]; if (cached_has_bits & 0x00000010u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_det_crop_mode()); } // optional .opencv_caffe.FillerParameter weight_filler = 5; if (cached_has_bits & 0x00000020u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *weight_filler_); } // optional .opencv_caffe.FillerParameter bias_filler = 6; if (cached_has_bits & 0x00000040u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *bias_filler_); } // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001; if (cached_has_bits & 0x00000080u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *hdf5_output_param_); } } if (cached_has_bits & 0x0000ff00u) { // optional uint32 num_output = 3; if (cached_has_bits & 0x00000100u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_num_output()); } // optional uint32 pad = 7 [default = 0]; if (cached_has_bits & 0x00000200u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pad()); } // optional uint32 kernelsize = 8; if (cached_has_bits & 0x00000400u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_kernelsize()); } // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; if (cached_has_bits & 0x00000800u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_pool()); } // optional uint32 batchsize = 19; if (cached_has_bits & 0x00001000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( this->_internal_batchsize()); } // optional uint32 cropsize = 20 [default = 0]; if (cached_has_bits & 0x00002000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( this->_internal_cropsize()); } // optional int32 new_width = 63 [default = 0]; if (cached_has_bits & 0x00004000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( this->_internal_new_width()); } // optional bool mirror = 21 [default = false]; if (cached_has_bits & 0x00008000u) { total_size += 2 + 1; } } if (cached_has_bits & 0x00ff0000u) { // optional bool shuffle_images = 64 [default = false]; if (cached_has_bits & 0x00010000u) { total_size += 2 + 1; } // optional uint32 rand_skip = 53 [default = 0]; if (cached_has_bits & 0x00020000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( this->_internal_rand_skip()); } // optional uint32 det_context_pad = 58 [default = 0]; if (cached_has_bits & 0x00040000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( this->_internal_det_context_pad()); } // optional int32 new_num = 60 [default = 0]; if (cached_has_bits & 0x00080000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( this->_internal_new_num()); } // optional int32 new_channels = 61 [default = 0]; if (cached_has_bits & 0x00100000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( this->_internal_new_channels()); } // optional int32 new_height = 62 [default = 0]; if (cached_has_bits & 0x00200000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( this->_internal_new_height()); } // optional uint32 concat_dim = 65 [default = 1]; if (cached_has_bits & 0x00400000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( this->_internal_concat_dim()); } // optional bool biasterm = 4 [default = true]; if (cached_has_bits & 0x00800000u) { total_size += 1 + 1; } } if (cached_has_bits & 0xff000000u) { // optional uint32 group = 9 [default = 1]; if (cached_has_bits & 0x01000000u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_group()); } // optional uint32 stride = 10 [default = 1]; if (cached_has_bits & 0x02000000u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_stride()); } // optional float dropout_ratio = 12 [default = 0.5]; if (cached_has_bits & 0x04000000u) { total_size += 1 + 4; } // optional uint32 local_size = 13 [default = 5]; if (cached_has_bits & 0x08000000u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_local_size()); } // optional float alpha = 14 [default = 1]; if (cached_has_bits & 0x10000000u) { total_size += 1 + 4; } // optional float beta = 15 [default = 0.75]; if (cached_has_bits & 0x20000000u) { total_size += 1 + 4; } // optional float scale = 17 [default = 1]; if (cached_has_bits & 0x40000000u) { total_size += 2 + 4; } // optional float k = 22 [default = 1]; if (cached_has_bits & 0x80000000u) { total_size += 2 + 4; } } cached_has_bits = _has_bits_[1]; if (cached_has_bits & 0x00000007u) { // optional float det_fg_threshold = 54 [default = 0.5]; if (cached_has_bits & 0x00000001u) { total_size += 2 + 4; } // optional float det_bg_threshold = 55 [default = 0.5]; if (cached_has_bits & 0x00000002u) { total_size += 2 + 4; } // optional float det_fg_fraction = 56 [default = 0.25]; if (cached_has_bits & 0x00000004u) { total_size += 2 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData V0LayerParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, V0LayerParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*V0LayerParameter::GetClassData() const { return &_class_data_; } void V0LayerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void V0LayerParameter::MergeFrom(const V0LayerParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.V0LayerParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; blobs_.MergeFrom(from.blobs_); blobs_lr_.MergeFrom(from.blobs_lr_); weight_decay_.MergeFrom(from.weight_decay_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_name(from._internal_name()); } if (cached_has_bits & 0x00000002u) { _internal_set_type(from._internal_type()); } if (cached_has_bits & 0x00000004u) { _internal_set_source(from._internal_source()); } if (cached_has_bits & 0x00000008u) { _internal_set_meanfile(from._internal_meanfile()); } if (cached_has_bits & 0x00000010u) { _internal_set_det_crop_mode(from._internal_det_crop_mode()); } if (cached_has_bits & 0x00000020u) { _internal_mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_weight_filler()); } if (cached_has_bits & 0x00000040u) { _internal_mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_bias_filler()); } if (cached_has_bits & 0x00000080u) { _internal_mutable_hdf5_output_param()->::opencv_caffe::HDF5OutputParameter::MergeFrom(from._internal_hdf5_output_param()); } } if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { num_output_ = from.num_output_; } if (cached_has_bits & 0x00000200u) { pad_ = from.pad_; } if (cached_has_bits & 0x00000400u) { kernelsize_ = from.kernelsize_; } if (cached_has_bits & 0x00000800u) { pool_ = from.pool_; } if (cached_has_bits & 0x00001000u) { batchsize_ = from.batchsize_; } if (cached_has_bits & 0x00002000u) { cropsize_ = from.cropsize_; } if (cached_has_bits & 0x00004000u) { new_width_ = from.new_width_; } if (cached_has_bits & 0x00008000u) { mirror_ = from.mirror_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0x00ff0000u) { if (cached_has_bits & 0x00010000u) { shuffle_images_ = from.shuffle_images_; } if (cached_has_bits & 0x00020000u) { rand_skip_ = from.rand_skip_; } if (cached_has_bits & 0x00040000u) { det_context_pad_ = from.det_context_pad_; } if (cached_has_bits & 0x00080000u) { new_num_ = from.new_num_; } if (cached_has_bits & 0x00100000u) { new_channels_ = from.new_channels_; } if (cached_has_bits & 0x00200000u) { new_height_ = from.new_height_; } if (cached_has_bits & 0x00400000u) { concat_dim_ = from.concat_dim_; } if (cached_has_bits & 0x00800000u) { biasterm_ = from.biasterm_; } _has_bits_[0] |= cached_has_bits; } if (cached_has_bits & 0xff000000u) { if (cached_has_bits & 0x01000000u) { group_ = from.group_; } if (cached_has_bits & 0x02000000u) { stride_ = from.stride_; } if (cached_has_bits & 0x04000000u) { dropout_ratio_ = from.dropout_ratio_; } if (cached_has_bits & 0x08000000u) { local_size_ = from.local_size_; } if (cached_has_bits & 0x10000000u) { alpha_ = from.alpha_; } if (cached_has_bits & 0x20000000u) { beta_ = from.beta_; } if (cached_has_bits & 0x40000000u) { scale_ = from.scale_; } if (cached_has_bits & 0x80000000u) { k_ = from.k_; } _has_bits_[0] |= cached_has_bits; } cached_has_bits = from._has_bits_[1]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { det_fg_threshold_ = from.det_fg_threshold_; } if (cached_has_bits & 0x00000002u) { det_bg_threshold_ = from.det_bg_threshold_; } if (cached_has_bits & 0x00000004u) { det_fg_fraction_ = from.det_fg_fraction_; } _has_bits_[1] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void V0LayerParameter::CopyFrom(const V0LayerParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.V0LayerParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool V0LayerParameter::IsInitialized() const { return true; } void V0LayerParameter::InternalSwap(V0LayerParameter* other) { using std::swap; auto* lhs_arena = GetArenaForAllocation(); auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); swap(_has_bits_[1], other->_has_bits_[1]); blobs_.InternalSwap(&other->blobs_); blobs_lr_.InternalSwap(&other->blobs_lr_); weight_decay_.InternalSwap(&other->weight_decay_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &name_, lhs_arena, &other->name_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &type_, lhs_arena, &other->type_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &source_, lhs_arena, &other->source_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &meanfile_, lhs_arena, &other->meanfile_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( nullptr, &det_crop_mode_, lhs_arena, &other->det_crop_mode_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(V0LayerParameter, new_height_) + sizeof(V0LayerParameter::new_height_) - PROTOBUF_FIELD_OFFSET(V0LayerParameter, weight_filler_)>( reinterpret_cast(&weight_filler_), reinterpret_cast(&other->weight_filler_)); swap(concat_dim_, other->concat_dim_); swap(biasterm_, other->biasterm_); swap(group_, other->group_); swap(stride_, other->stride_); swap(dropout_ratio_, other->dropout_ratio_); swap(local_size_, other->local_size_); swap(alpha_, other->alpha_); swap(beta_, other->beta_); swap(scale_, other->scale_); swap(k_, other->k_); swap(det_fg_threshold_, other->det_fg_threshold_); swap(det_bg_threshold_, other->det_bg_threshold_); swap(det_fg_fraction_, other->det_fg_fraction_); } ::PROTOBUF_NAMESPACE_ID::Metadata V0LayerParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[65]); } // =================================================================== class PReLUParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static const ::opencv_caffe::FillerParameter& filler(const PReLUParameter* msg); static void set_has_filler(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_channel_shared(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; const ::opencv_caffe::FillerParameter& PReLUParameter::_Internal::filler(const PReLUParameter* msg) { return *msg->filler_; } PReLUParameter::PReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.PReLUParameter) } PReLUParameter::PReLUParameter(const PReLUParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_filler()) { filler_ = new ::opencv_caffe::FillerParameter(*from.filler_); } else { filler_ = nullptr; } channel_shared_ = from.channel_shared_; // @@protoc_insertion_point(copy_constructor:opencv_caffe.PReLUParameter) } inline void PReLUParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&filler_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&channel_shared_) - reinterpret_cast(&filler_)) + sizeof(channel_shared_)); } PReLUParameter::~PReLUParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.PReLUParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void PReLUParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete filler_; } void PReLUParameter::ArenaDtor(void* object) { PReLUParameter* _this = reinterpret_cast< PReLUParameter* >(object); (void)_this; } void PReLUParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void PReLUParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void PReLUParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.PReLUParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(filler_ != nullptr); filler_->Clear(); } channel_shared_ = false; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* PReLUParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional .opencv_caffe.FillerParameter filler = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_filler(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool channel_shared = 2 [default = false]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_channel_shared(&has_bits); channel_shared_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* PReLUParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PReLUParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional .opencv_caffe.FillerParameter filler = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 1, _Internal::filler(this), target, stream); } // optional bool channel_shared = 2 [default = false]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_channel_shared(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PReLUParameter) return target; } size_t PReLUParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PReLUParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional .opencv_caffe.FillerParameter filler = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *filler_); } // optional bool channel_shared = 2 [default = false]; if (cached_has_bits & 0x00000002u) { total_size += 1 + 1; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PReLUParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, PReLUParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PReLUParameter::GetClassData() const { return &_class_data_; } void PReLUParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void PReLUParameter::MergeFrom(const PReLUParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PReLUParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { _internal_mutable_filler()->::opencv_caffe::FillerParameter::MergeFrom(from._internal_filler()); } if (cached_has_bits & 0x00000002u) { channel_shared_ = from.channel_shared_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void PReLUParameter::CopyFrom(const PReLUParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PReLUParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool PReLUParameter::IsInitialized() const { return true; } void PReLUParameter::InternalSwap(PReLUParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(PReLUParameter, channel_shared_) + sizeof(PReLUParameter::channel_shared_) - PROTOBUF_FIELD_OFFSET(PReLUParameter, filler_)>( reinterpret_cast(&filler_), reinterpret_cast(&other->filler_)); } ::PROTOBUF_NAMESPACE_ID::Metadata PReLUParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[66]); } // =================================================================== class NormalizedBBox::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_xmin(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_ymin(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_xmax(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_ymax(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_label(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_difficult(HasBits* has_bits) { (*has_bits)[0] |= 32u; } static void set_has_score(HasBits* has_bits) { (*has_bits)[0] |= 64u; } static void set_has_size(HasBits* has_bits) { (*has_bits)[0] |= 128u; } }; NormalizedBBox::NormalizedBBox(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.NormalizedBBox) } NormalizedBBox::NormalizedBBox(const NormalizedBBox& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&xmin_, &from.xmin_, static_cast(reinterpret_cast(&size_) - reinterpret_cast(&xmin_)) + sizeof(size_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.NormalizedBBox) } inline void NormalizedBBox::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&xmin_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&size_) - reinterpret_cast(&xmin_)) + sizeof(size_)); } NormalizedBBox::~NormalizedBBox() { // @@protoc_insertion_point(destructor:opencv_caffe.NormalizedBBox) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void NormalizedBBox::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void NormalizedBBox::ArenaDtor(void* object) { NormalizedBBox* _this = reinterpret_cast< NormalizedBBox* >(object); (void)_this; } void NormalizedBBox::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NormalizedBBox::SetCachedSize(int size) const { _cached_size_.Set(size); } void NormalizedBBox::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.NormalizedBBox) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { ::memset(&xmin_, 0, static_cast( reinterpret_cast(&size_) - reinterpret_cast(&xmin_)) + sizeof(size_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NormalizedBBox::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional float xmin = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_xmin(&has_bits); xmin_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float ymin = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { _Internal::set_has_ymin(&has_bits); ymin_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float xmax = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_xmax(&has_bits); xmax_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float ymax = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { _Internal::set_has_ymax(&has_bits); ymax_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional int32 label = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_label(&has_bits); label_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional bool difficult = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_difficult(&has_bits); difficult_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float score = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { _Internal::set_has_score(&has_bits); score_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // optional float size = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { _Internal::set_has_size(&has_bits); size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* NormalizedBBox::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NormalizedBBox) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional float xmin = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_xmin(), target); } // optional float ymin = 2; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_ymin(), target); } // optional float xmax = 3; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_xmax(), target); } // optional float ymax = 4; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_ymax(), target); } // optional int32 label = 5; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_label(), target); } // optional bool difficult = 6; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_difficult(), target); } // optional float score = 7; if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_score(), target); } // optional float size = 8; if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_size(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NormalizedBBox) return target; } size_t NormalizedBBox::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NormalizedBBox) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional float xmin = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + 4; } // optional float ymin = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + 4; } // optional float xmax = 3; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } // optional float ymax = 4; if (cached_has_bits & 0x00000008u) { total_size += 1 + 4; } // optional int32 label = 5; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_label()); } // optional bool difficult = 6; if (cached_has_bits & 0x00000020u) { total_size += 1 + 1; } // optional float score = 7; if (cached_has_bits & 0x00000040u) { total_size += 1 + 4; } // optional float size = 8; if (cached_has_bits & 0x00000080u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NormalizedBBox::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, NormalizedBBox::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NormalizedBBox::GetClassData() const { return &_class_data_; } void NormalizedBBox::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void NormalizedBBox::MergeFrom(const NormalizedBBox& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NormalizedBBox) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { xmin_ = from.xmin_; } if (cached_has_bits & 0x00000002u) { ymin_ = from.ymin_; } if (cached_has_bits & 0x00000004u) { xmax_ = from.xmax_; } if (cached_has_bits & 0x00000008u) { ymax_ = from.ymax_; } if (cached_has_bits & 0x00000010u) { label_ = from.label_; } if (cached_has_bits & 0x00000020u) { difficult_ = from.difficult_; } if (cached_has_bits & 0x00000040u) { score_ = from.score_; } if (cached_has_bits & 0x00000080u) { size_ = from.size_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void NormalizedBBox::CopyFrom(const NormalizedBBox& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NormalizedBBox) if (&from == this) return; Clear(); MergeFrom(from); } bool NormalizedBBox::IsInitialized() const { return true; } void NormalizedBBox::InternalSwap(NormalizedBBox* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(NormalizedBBox, size_) + sizeof(NormalizedBBox::size_) - PROTOBUF_FIELD_OFFSET(NormalizedBBox, xmin_)>( reinterpret_cast(&xmin_), reinterpret_cast(&other->xmin_)); } ::PROTOBUF_NAMESPACE_ID::Metadata NormalizedBBox::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[67]); } // =================================================================== class ROIPoolingParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_pooled_h(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_pooled_w(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_spatial_scale(HasBits* has_bits) { (*has_bits)[0] |= 4u; } }; ROIPoolingParameter::ROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ROIPoolingParameter) } ROIPoolingParameter::ROIPoolingParameter(const ROIPoolingParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&pooled_h_, &from.pooled_h_, static_cast(reinterpret_cast(&spatial_scale_) - reinterpret_cast(&pooled_h_)) + sizeof(spatial_scale_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ROIPoolingParameter) } inline void ROIPoolingParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&pooled_h_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&pooled_w_) - reinterpret_cast(&pooled_h_)) + sizeof(pooled_w_)); spatial_scale_ = 1; } ROIPoolingParameter::~ROIPoolingParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ROIPoolingParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ROIPoolingParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ROIPoolingParameter::ArenaDtor(void* object) { ROIPoolingParameter* _this = reinterpret_cast< ROIPoolingParameter* >(object); (void)_this; } void ROIPoolingParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ROIPoolingParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ROIPoolingParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ROIPoolingParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { ::memset(&pooled_h_, 0, static_cast( reinterpret_cast(&pooled_w_) - reinterpret_cast(&pooled_h_)) + sizeof(pooled_w_)); spatial_scale_ = 1; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ROIPoolingParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 pooled_h = 1 [default = 0]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_pooled_h(&has_bits); pooled_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 pooled_w = 2 [default = 0]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_pooled_w(&has_bits); pooled_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float spatial_scale = 3 [default = 1]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 29)) { _Internal::set_has_spatial_scale(&has_bits); spatial_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ROIPoolingParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ROIPoolingParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 pooled_h = 1 [default = 0]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_pooled_h(), target); } // optional uint32 pooled_w = 2 [default = 0]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_pooled_w(), target); } // optional float spatial_scale = 3 [default = 1]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_spatial_scale(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ROIPoolingParameter) return target; } size_t ROIPoolingParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ROIPoolingParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { // optional uint32 pooled_h = 1 [default = 0]; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pooled_h()); } // optional uint32 pooled_w = 2 [default = 0]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pooled_w()); } // optional float spatial_scale = 3 [default = 1]; if (cached_has_bits & 0x00000004u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ROIPoolingParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ROIPoolingParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ROIPoolingParameter::GetClassData() const { return &_class_data_; } void ROIPoolingParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ROIPoolingParameter::MergeFrom(const ROIPoolingParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ROIPoolingParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { pooled_h_ = from.pooled_h_; } if (cached_has_bits & 0x00000002u) { pooled_w_ = from.pooled_w_; } if (cached_has_bits & 0x00000004u) { spatial_scale_ = from.spatial_scale_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ROIPoolingParameter::CopyFrom(const ROIPoolingParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ROIPoolingParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ROIPoolingParameter::IsInitialized() const { return true; } void ROIPoolingParameter::InternalSwap(ROIPoolingParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ROIPoolingParameter, pooled_w_) + sizeof(ROIPoolingParameter::pooled_w_) - PROTOBUF_FIELD_OFFSET(ROIPoolingParameter, pooled_h_)>( reinterpret_cast(&pooled_h_), reinterpret_cast(&other->pooled_h_)); swap(spatial_scale_, other->spatial_scale_); } ::PROTOBUF_NAMESPACE_ID::Metadata ROIPoolingParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[68]); } // =================================================================== class ProposalParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_feat_stride(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_base_size(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_min_size(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static void set_has_pre_nms_topn(HasBits* has_bits) { (*has_bits)[0] |= 8u; } static void set_has_post_nms_topn(HasBits* has_bits) { (*has_bits)[0] |= 16u; } static void set_has_nms_thresh(HasBits* has_bits) { (*has_bits)[0] |= 32u; } }; ProposalParameter::ProposalParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), ratio_(arena), scale_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.ProposalParameter) } ProposalParameter::ProposalParameter(const ProposalParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_), ratio_(from.ratio_), scale_(from.scale_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&feat_stride_, &from.feat_stride_, static_cast(reinterpret_cast(&nms_thresh_) - reinterpret_cast(&feat_stride_)) + sizeof(nms_thresh_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.ProposalParameter) } inline void ProposalParameter::SharedCtor() { feat_stride_ = 16u; base_size_ = 16u; min_size_ = 16u; pre_nms_topn_ = 6000u; post_nms_topn_ = 300u; nms_thresh_ = 0.7f; } ProposalParameter::~ProposalParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.ProposalParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void ProposalParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ProposalParameter::ArenaDtor(void* object) { ProposalParameter* _this = reinterpret_cast< ProposalParameter* >(object); (void)_this; } void ProposalParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ProposalParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void ProposalParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.ProposalParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ratio_.Clear(); scale_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000003fu) { feat_stride_ = 16u; base_size_ = 16u; min_size_ = 16u; pre_nms_topn_ = 6000u; post_nms_topn_ = 300u; nms_thresh_ = 0.7f; } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ProposalParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // optional uint32 feat_stride = 1 [default = 16]; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _Internal::set_has_feat_stride(&has_bits); feat_stride_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 base_size = 2 [default = 16]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_base_size(&has_bits); base_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 min_size = 3 [default = 16]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_min_size(&has_bits); min_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // repeated float ratio = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { ptr -= 1; do { ptr += 1; _internal_add_ratio(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<37>(ptr)); } else if (static_cast(tag) == 34) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_ratio(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated float scale = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 45)) { ptr -= 1; do { ptr += 1; _internal_add_scale(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<45>(ptr)); } else if (static_cast(tag) == 42) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_scale(), ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 pre_nms_topn = 6 [default = 6000]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_pre_nms_topn(&has_bits); pre_nms_topn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional uint32 post_nms_topn = 7 [default = 300]; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _Internal::set_has_post_nms_topn(&has_bits); post_nms_topn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // optional float nms_thresh = 8 [default = 0.7]; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { _Internal::set_has_nms_thresh(&has_bits); nms_thresh_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* ProposalParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ProposalParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // optional uint32 feat_stride = 1 [default = 16]; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_feat_stride(), target); } // optional uint32 base_size = 2 [default = 16]; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_base_size(), target); } // optional uint32 min_size = 3 [default = 16]; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_min_size(), target); } // repeated float ratio = 4; for (int i = 0, n = this->_internal_ratio_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_ratio(i), target); } // repeated float scale = 5; for (int i = 0, n = this->_internal_scale_size(); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_scale(i), target); } // optional uint32 pre_nms_topn = 6 [default = 6000]; if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_pre_nms_topn(), target); } // optional uint32 post_nms_topn = 7 [default = 300]; if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_post_nms_topn(), target); } // optional float nms_thresh = 8 [default = 0.7]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_nms_thresh(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ProposalParameter) return target; } size_t ProposalParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ProposalParameter) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated float ratio = 4; { unsigned int count = static_cast(this->_internal_ratio_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_ratio_size()); total_size += data_size; } // repeated float scale = 5; { unsigned int count = static_cast(this->_internal_scale_size()); size_t data_size = 4UL * count; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_scale_size()); total_size += data_size; } cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x0000003fu) { // optional uint32 feat_stride = 1 [default = 16]; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_feat_stride()); } // optional uint32 base_size = 2 [default = 16]; if (cached_has_bits & 0x00000002u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_base_size()); } // optional uint32 min_size = 3 [default = 16]; if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_min_size()); } // optional uint32 pre_nms_topn = 6 [default = 6000]; if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_pre_nms_topn()); } // optional uint32 post_nms_topn = 7 [default = 300]; if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_post_nms_topn()); } // optional float nms_thresh = 8 [default = 0.7]; if (cached_has_bits & 0x00000020u) { total_size += 1 + 4; } } return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ProposalParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, ProposalParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ProposalParameter::GetClassData() const { return &_class_data_; } void ProposalParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void ProposalParameter::MergeFrom(const ProposalParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ProposalParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; ratio_.MergeFrom(from.ratio_); scale_.MergeFrom(from.scale_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { feat_stride_ = from.feat_stride_; } if (cached_has_bits & 0x00000002u) { base_size_ = from.base_size_; } if (cached_has_bits & 0x00000004u) { min_size_ = from.min_size_; } if (cached_has_bits & 0x00000008u) { pre_nms_topn_ = from.pre_nms_topn_; } if (cached_has_bits & 0x00000010u) { post_nms_topn_ = from.post_nms_topn_; } if (cached_has_bits & 0x00000020u) { nms_thresh_ = from.nms_thresh_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ProposalParameter::CopyFrom(const ProposalParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ProposalParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool ProposalParameter::IsInitialized() const { return true; } void ProposalParameter::InternalSwap(ProposalParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ratio_.InternalSwap(&other->ratio_); scale_.InternalSwap(&other->scale_); swap(feat_stride_, other->feat_stride_); swap(base_size_, other->base_size_); swap(min_size_, other->min_size_); swap(pre_nms_topn_, other->pre_nms_topn_); swap(post_nms_topn_, other->post_nms_topn_); swap(nms_thresh_, other->nms_thresh_); } ::PROTOBUF_NAMESPACE_ID::Metadata ProposalParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[69]); } // =================================================================== class PSROIPoolingParameter::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_spatial_scale(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_output_dim(HasBits* has_bits) { (*has_bits)[0] |= 2u; } static void set_has_group_size(HasBits* has_bits) { (*has_bits)[0] |= 4u; } static bool MissingRequiredFields(const HasBits& has_bits) { return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0; } }; PSROIPoolingParameter::PSROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); } // @@protoc_insertion_point(arena_constructor:opencv_caffe.PSROIPoolingParameter) } PSROIPoolingParameter::PSROIPoolingParameter(const PSROIPoolingParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&spatial_scale_, &from.spatial_scale_, static_cast(reinterpret_cast(&group_size_) - reinterpret_cast(&spatial_scale_)) + sizeof(group_size_)); // @@protoc_insertion_point(copy_constructor:opencv_caffe.PSROIPoolingParameter) } inline void PSROIPoolingParameter::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&spatial_scale_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&group_size_) - reinterpret_cast(&spatial_scale_)) + sizeof(group_size_)); } PSROIPoolingParameter::~PSROIPoolingParameter() { // @@protoc_insertion_point(destructor:opencv_caffe.PSROIPoolingParameter) if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } inline void PSROIPoolingParameter::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void PSROIPoolingParameter::ArenaDtor(void* object) { PSROIPoolingParameter* _this = reinterpret_cast< PSROIPoolingParameter* >(object); (void)_this; } void PSROIPoolingParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void PSROIPoolingParameter::SetCachedSize(int size) const { _cached_size_.Set(size); } void PSROIPoolingParameter::Clear() { // @@protoc_insertion_point(message_clear_start:opencv_caffe.PSROIPoolingParameter) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000007u) { ::memset(&spatial_scale_, 0, static_cast( reinterpret_cast(&group_size_) - reinterpret_cast(&spatial_scale_)) + sizeof(group_size_)); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* PSROIPoolingParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // required float spatial_scale = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { _Internal::set_has_spatial_scale(&has_bits); spatial_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } else goto handle_unusual; continue; // required int32 output_dim = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_output_dim(&has_bits); output_dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; // required int32 group_size = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_group_size(&has_bits); group_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: goto handle_unusual; } // switch handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto message_done; } ptr = UnknownFieldParse( tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); } // while message_done: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto message_done; #undef CHK_ } uint8_t* PSROIPoolingParameter::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PSROIPoolingParameter) uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = _has_bits_[0]; // required float spatial_scale = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_spatial_scale(), target); } // required int32 output_dim = 2; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_output_dim(), target); } // required int32 group_size = 3; if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_group_size(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PSROIPoolingParameter) return target; } size_t PSROIPoolingParameter::RequiredFieldsByteSizeFallback() const { // @@protoc_insertion_point(required_fields_byte_size_fallback_start:opencv_caffe.PSROIPoolingParameter) size_t total_size = 0; if (_internal_has_spatial_scale()) { // required float spatial_scale = 1; total_size += 1 + 4; } if (_internal_has_output_dim()) { // required int32 output_dim = 2; total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_output_dim()); } if (_internal_has_group_size()) { // required int32 group_size = 3; total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_group_size()); } return total_size; } size_t PSROIPoolingParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PSROIPoolingParameter) size_t total_size = 0; if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) { // All required fields are present. // required float spatial_scale = 1; total_size += 1 + 4; // required int32 output_dim = 2; total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_output_dim()); // required int32 group_size = 3; total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_group_size()); } else { total_size += RequiredFieldsByteSizeFallback(); } uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PSROIPoolingParameter::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, PSROIPoolingParameter::MergeImpl }; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PSROIPoolingParameter::GetClassData() const { return &_class_data_; } void PSROIPoolingParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from) { static_cast(to)->MergeFrom( static_cast(from)); } void PSROIPoolingParameter::MergeFrom(const PSROIPoolingParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PSROIPoolingParameter) GOOGLE_DCHECK_NE(&from, this); uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { spatial_scale_ = from.spatial_scale_; } if (cached_has_bits & 0x00000002u) { output_dim_ = from.output_dim_; } if (cached_has_bits & 0x00000004u) { group_size_ = from.group_size_; } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void PSROIPoolingParameter::CopyFrom(const PSROIPoolingParameter& from) { // @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PSROIPoolingParameter) if (&from == this) return; Clear(); MergeFrom(from); } bool PSROIPoolingParameter::IsInitialized() const { if (_Internal::MissingRequiredFields(_has_bits_)) return false; return true; } void PSROIPoolingParameter::InternalSwap(PSROIPoolingParameter* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(PSROIPoolingParameter, group_size_) + sizeof(PSROIPoolingParameter::group_size_) - PROTOBUF_FIELD_OFFSET(PSROIPoolingParameter, spatial_scale_)>( reinterpret_cast(&spatial_scale_), reinterpret_cast(&other->spatial_scale_)); } ::PROTOBUF_NAMESPACE_ID::Metadata PSROIPoolingParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_opencv_2dcaffe_2eproto_getter, &descriptor_table_opencv_2dcaffe_2eproto_once, file_level_metadata_opencv_2dcaffe_2eproto[70]); } // @@protoc_insertion_point(namespace_scope) } // namespace opencv_caffe PROTOBUF_NAMESPACE_OPEN template<> PROTOBUF_NOINLINE ::opencv_caffe::BlobShape* Arena::CreateMaybeMessage< ::opencv_caffe::BlobShape >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::BlobShape >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::BlobProto* Arena::CreateMaybeMessage< ::opencv_caffe::BlobProto >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::BlobProto >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::BlobProtoVector* Arena::CreateMaybeMessage< ::opencv_caffe::BlobProtoVector >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::BlobProtoVector >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::PermuteParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PermuteParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::PermuteParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::NormalizeBBoxParameter* Arena::CreateMaybeMessage< ::opencv_caffe::NormalizeBBoxParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::NormalizeBBoxParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::PriorBoxParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PriorBoxParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::PriorBoxParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::DetectionOutputParameter* Arena::CreateMaybeMessage< ::opencv_caffe::DetectionOutputParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::DetectionOutputParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::Datum* Arena::CreateMaybeMessage< ::opencv_caffe::Datum >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::Datum >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::FillerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::FillerParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::FillerParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::NetParameter* Arena::CreateMaybeMessage< ::opencv_caffe::NetParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::NetParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::SolverParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SolverParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::SolverParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::SolverState* Arena::CreateMaybeMessage< ::opencv_caffe::SolverState >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::SolverState >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::NetState* Arena::CreateMaybeMessage< ::opencv_caffe::NetState >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::NetState >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::NetStateRule* Arena::CreateMaybeMessage< ::opencv_caffe::NetStateRule >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::NetStateRule >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ParamSpec* Arena::CreateMaybeMessage< ::opencv_caffe::ParamSpec >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ParamSpec >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::LayerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::LayerParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::LayerParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::TransformationParameter* Arena::CreateMaybeMessage< ::opencv_caffe::TransformationParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::TransformationParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::LossParameter* Arena::CreateMaybeMessage< ::opencv_caffe::LossParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::LossParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::AccuracyParameter* Arena::CreateMaybeMessage< ::opencv_caffe::AccuracyParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::AccuracyParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ArgMaxParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ArgMaxParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ArgMaxParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ConcatParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ConcatParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ConcatParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::BatchNormParameter* Arena::CreateMaybeMessage< ::opencv_caffe::BatchNormParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::BatchNormParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::BiasParameter* Arena::CreateMaybeMessage< ::opencv_caffe::BiasParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::BiasParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ContrastiveLossParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ContrastiveLossParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ContrastiveLossParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ConvolutionParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ConvolutionParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ConvolutionParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::CropParameter* Arena::CreateMaybeMessage< ::opencv_caffe::CropParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::CropParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::DataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::DataParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::DataParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::NonMaximumSuppressionParameter* Arena::CreateMaybeMessage< ::opencv_caffe::NonMaximumSuppressionParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::NonMaximumSuppressionParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::SaveOutputParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SaveOutputParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::SaveOutputParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::DropoutParameter* Arena::CreateMaybeMessage< ::opencv_caffe::DropoutParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::DropoutParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::DummyDataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::DummyDataParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::DummyDataParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::EltwiseParameter* Arena::CreateMaybeMessage< ::opencv_caffe::EltwiseParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::EltwiseParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ELUParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ELUParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ELUParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::EmbedParameter* Arena::CreateMaybeMessage< ::opencv_caffe::EmbedParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::EmbedParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ExpParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ExpParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ExpParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::FlattenParameter* Arena::CreateMaybeMessage< ::opencv_caffe::FlattenParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::FlattenParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::HDF5DataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::HDF5DataParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::HDF5DataParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::HDF5OutputParameter* Arena::CreateMaybeMessage< ::opencv_caffe::HDF5OutputParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::HDF5OutputParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::HingeLossParameter* Arena::CreateMaybeMessage< ::opencv_caffe::HingeLossParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::HingeLossParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ImageDataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ImageDataParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ImageDataParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::InfogainLossParameter* Arena::CreateMaybeMessage< ::opencv_caffe::InfogainLossParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::InfogainLossParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::InnerProductParameter* Arena::CreateMaybeMessage< ::opencv_caffe::InnerProductParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::InnerProductParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::InputParameter* Arena::CreateMaybeMessage< ::opencv_caffe::InputParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::InputParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::LogParameter* Arena::CreateMaybeMessage< ::opencv_caffe::LogParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::LogParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::LRNParameter* Arena::CreateMaybeMessage< ::opencv_caffe::LRNParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::LRNParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::MemoryDataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::MemoryDataParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::MemoryDataParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::MVNParameter* Arena::CreateMaybeMessage< ::opencv_caffe::MVNParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::MVNParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ParameterParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ParameterParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ParameterParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::PoolingParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PoolingParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::PoolingParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::PowerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PowerParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::PowerParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::PythonParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PythonParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::PythonParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::RecurrentParameter* Arena::CreateMaybeMessage< ::opencv_caffe::RecurrentParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::RecurrentParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ReductionParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ReductionParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ReductionParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ReLUParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ReLUParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ReLUParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ReshapeParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ReshapeParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ReshapeParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ScaleParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ScaleParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ScaleParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::SigmoidParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SigmoidParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::SigmoidParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::SliceParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SliceParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::SliceParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::SoftmaxParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SoftmaxParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::SoftmaxParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::TanHParameter* Arena::CreateMaybeMessage< ::opencv_caffe::TanHParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::TanHParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::TileParameter* Arena::CreateMaybeMessage< ::opencv_caffe::TileParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::TileParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ThresholdParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ThresholdParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ThresholdParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::WindowDataParameter* Arena::CreateMaybeMessage< ::opencv_caffe::WindowDataParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::WindowDataParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::SPPParameter* Arena::CreateMaybeMessage< ::opencv_caffe::SPPParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::SPPParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::V1LayerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::V1LayerParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::V1LayerParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::V0LayerParameter* Arena::CreateMaybeMessage< ::opencv_caffe::V0LayerParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::V0LayerParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::PReLUParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PReLUParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::PReLUParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::NormalizedBBox* Arena::CreateMaybeMessage< ::opencv_caffe::NormalizedBBox >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::NormalizedBBox >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ROIPoolingParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ROIPoolingParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ROIPoolingParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::ProposalParameter* Arena::CreateMaybeMessage< ::opencv_caffe::ProposalParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::ProposalParameter >(arena); } template<> PROTOBUF_NOINLINE ::opencv_caffe::PSROIPoolingParameter* Arena::CreateMaybeMessage< ::opencv_caffe::PSROIPoolingParameter >(Arena* arena) { return Arena::CreateMessageInternal< ::opencv_caffe::PSROIPoolingParameter >(arena); } PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include