Remove unused private members, replace std::bind by lambdas, apply clang-tidy and clang-format

Fix position_test with default parameters

src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.cc

@@ -57,7 +57,10 @@ BeidouB1iPcpsAcquisition::BeidouB1iPcpsAcquisition(
 
     LOG(INFO) << "role " << role;
 
-    if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max;
+    if (FLAGS_doppler_max != 0)
+        {
+            acq_parameters_.doppler_max = FLAGS_doppler_max;
+        }
     doppler_max_ = acq_parameters_.doppler_max;
     doppler_step_ = acq_parameters_.doppler_step;
     fs_in_ = acq_parameters_.fs_in;

src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.h

@@ -170,17 +170,12 @@ private:
     std::string item_type_;
     unsigned int vector_length_;
     unsigned int code_length_;
-    bool bit_transition_flag_;
-    bool use_CFAR_algorithm_flag_;
     unsigned int channel_;
     std::weak_ptr<ChannelFsm> channel_fsm_;
     float threshold_;
     unsigned int doppler_max_;
     unsigned int doppler_step_;
-    unsigned int max_dwells_;
     int64_t fs_in_;
-    bool dump_;
-    bool blocking_;
     std::string dump_filename_;
     std::vector<std::complex<float>> code_;
     Gnss_Synchro* gnss_synchro_;

src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.cc

@@ -55,7 +55,10 @@ BeidouB3iPcpsAcquisition::BeidouB3iPcpsAcquisition(
 
     LOG(INFO) << "role " << role;
 
-    if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max;
+    if (FLAGS_doppler_max != 0)
+        {
+            acq_parameters_.doppler_max = FLAGS_doppler_max;
+        }
     doppler_max_ = acq_parameters_.doppler_max;
     doppler_step_ = acq_parameters_.doppler_step;
     item_type_ = acq_parameters_.item_type;

src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.h

@@ -169,17 +169,12 @@ private:
     std::string item_type_;
     unsigned int vector_length_;
     unsigned int code_length_;
-    bool bit_transition_flag_;
-    bool use_CFAR_algorithm_flag_;
     unsigned int channel_;
     std::weak_ptr<ChannelFsm> channel_fsm_;
     float threshold_;
     unsigned int doppler_max_;
     unsigned int doppler_step_;
-    unsigned int max_dwells_;
     int64_t fs_in_;
-    bool dump_;
-    bool blocking_;
     std::string dump_filename_;
     std::vector<std::complex<float>> code_;
     Gnss_Synchro* gnss_synchro_;

src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc

@@ -54,7 +54,10 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition(
 
     DLOG(INFO) << "role " << role;
 
-    if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max;
+    if (FLAGS_doppler_max != 0)
+        {
+            acq_parameters_.doppler_max = FLAGS_doppler_max;
+        }
     doppler_max_ = acq_parameters_.doppler_max;
     doppler_step_ = acq_parameters_.doppler_step;
     item_type_ = acq_parameters_.item_type;

src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.h

@@ -173,8 +173,6 @@ private:
     std::string item_type_;
     unsigned int vector_length_;
     unsigned int code_length_;
-    bool bit_transition_flag_;
-    bool use_CFAR_algorithm_flag_;
     bool acquire_pilot_;
     unsigned int channel_;
     std::weak_ptr<ChannelFsm> channel_fsm_;
@@ -183,10 +181,7 @@ private:
     unsigned int doppler_step_;
     int doppler_center_;
     unsigned int sampled_ms_;
-    unsigned int max_dwells_;
     int64_t fs_in_;
-    bool dump_;
-    bool blocking_;
     std::string dump_filename_;
     std::vector<std::complex<float>> code_;
     Gnss_Synchro* gnss_synchro_;

src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc

@@ -53,7 +53,10 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* con
 
     DLOG(INFO) << "Role " << role;
 
-    if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max;
+    if (FLAGS_doppler_max != 0)
+        {
+            acq_parameters_.doppler_max = FLAGS_doppler_max;
+        }
     doppler_max_ = acq_parameters_.doppler_max;
     doppler_step_ = acq_parameters_.doppler_step;
     item_type_ = acq_parameters_.item_type;

src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.h

@@ -162,11 +162,7 @@ private:
     std::string item_type_;
     std::string dump_filename_;
     std::string role_;
-    bool bit_transition_flag_;
-    bool dump_;
     bool acq_pilot_;
-    bool use_CFAR_;
-    bool blocking_;
     bool acq_iq_;
     unsigned int vector_length_;
     unsigned int code_length_;
@@ -176,7 +172,6 @@ private:
     unsigned int doppler_step_;
     int doppler_center_;
     unsigned int sampled_ms_;
-    unsigned int max_dwells_;
     unsigned int in_streams_;
     unsigned int out_streams_;
     int64_t fs_in_;

src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc

@@ -56,7 +56,10 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition(
 
     DLOG(INFO) << "role " << role;
 
-    if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max;
+    if (FLAGS_doppler_max != 0)
+        {
+            acq_parameters_.doppler_max = FLAGS_doppler_max;
+        }
     doppler_max_ = acq_parameters_.doppler_max;
     doppler_step_ = acq_parameters_.doppler_step;
     item_type_ = acq_parameters_.item_type;

src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.h

@@ -165,18 +165,13 @@ private:
     std::string item_type_;
     unsigned int vector_length_;
     unsigned int code_length_;
-    bool bit_transition_flag_;
-    bool use_CFAR_algorithm_flag_;
     unsigned int channel_;
     std::weak_ptr<ChannelFsm> channel_fsm_;
     float threshold_;
     unsigned int doppler_max_;
     unsigned int doppler_step_;
     unsigned int sampled_ms_;
-    unsigned int max_dwells_;
     int64_t fs_in_;
-    bool dump_;
-    bool blocking_;
     std::string dump_filename_;
     std::vector<std::complex<float>> code_;
     Gnss_Synchro* gnss_synchro_;

src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc

@@ -55,7 +55,10 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition(
 
     DLOG(INFO) << "role " << role;
 
-    if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max;
+    if (FLAGS_doppler_max != 0)
+        {
+            acq_parameters_.doppler_max = FLAGS_doppler_max;
+        }
     doppler_max_ = acq_parameters_.doppler_max;
     doppler_step_ = acq_parameters_.doppler_step;
     item_type_ = acq_parameters_.item_type;

src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.h

@@ -164,18 +164,13 @@ private:
     std::string item_type_;
     unsigned int vector_length_;
     unsigned int code_length_;
-    bool bit_transition_flag_;
-    bool use_CFAR_algorithm_flag_;
     unsigned int channel_;
     std::weak_ptr<ChannelFsm> channel_fsm_;
     float threshold_;
     unsigned int doppler_max_;
     unsigned int doppler_step_;
     unsigned int sampled_ms_;
-    unsigned int max_dwells_;
     int64_t fs_in_;
-    bool dump_;
-    bool blocking_;
     std::string dump_filename_;
     std::vector<std::complex<float>> code_;
     Gnss_Synchro* gnss_synchro_;

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc

@@ -59,7 +59,10 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition(
 
     DLOG(INFO) << "role " << role;
 
-    if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max;
+    if (FLAGS_doppler_max != 0)
+        {
+            acq_parameters_.doppler_max = FLAGS_doppler_max;
+        }
 
     doppler_max_ = acq_parameters_.doppler_max;
     doppler_step_ = acq_parameters_.doppler_step;

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.h

@@ -177,8 +177,6 @@ private:
     std::string item_type_;
     unsigned int vector_length_;
     unsigned int code_length_;
-    bool bit_transition_flag_;
-    bool use_CFAR_algorithm_flag_;
     unsigned int channel_;
     std::weak_ptr<ChannelFsm> channel_fsm_;
     float threshold_;
@@ -186,10 +184,6 @@ private:
     unsigned int doppler_step_;
     int doppler_center_;
     unsigned int sampled_ms_;
-    unsigned int max_dwells_;
-    int64_t fs_in_;
-    bool dump_;
-    bool blocking_;
     std::string dump_filename_;
     std::vector<std::complex<float>> code_;
     Gnss_Synchro* gnss_synchro_;

src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc

@@ -56,7 +56,10 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition(
 
     DLOG(INFO) << "Role " << role;
 
-    if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max;
+    if (FLAGS_doppler_max != 0)
+        {
+            acq_parameters_.doppler_max = FLAGS_doppler_max;
+        }
     doppler_max_ = acq_parameters_.doppler_max;
     doppler_step_ = acq_parameters_.doppler_step;
     item_type_ = acq_parameters_.item_type;

src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.h

@@ -174,18 +174,13 @@ private:
     std::string item_type_;
     unsigned int vector_length_;
     unsigned int code_length_;
-    bool bit_transition_flag_;
-    bool use_CFAR_algorithm_flag_;
     unsigned int channel_;
     std::weak_ptr<ChannelFsm> channel_fsm_;
     float threshold_;
     unsigned int doppler_max_;
     unsigned int doppler_step_;
     int doppler_center_;
-    unsigned int max_dwells_;
     int64_t fs_in_;
-    bool dump_;
-    bool blocking_;
     std::string dump_filename_;
     std::vector<std::complex<float>> code_;
     Gnss_Synchro* gnss_synchro_;

src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc

@@ -56,7 +56,10 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition(
 
     DLOG(INFO) << "role " << role;
 
-    if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max;
+    if (FLAGS_doppler_max != 0)
+        {
+            acq_parameters_.doppler_max = FLAGS_doppler_max;
+        }
 
     doppler_max_ = acq_parameters_.doppler_max;
     doppler_step_ = acq_parameters_.doppler_step;

src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.h

@@ -174,18 +174,13 @@ private:
     std::string item_type_;
     unsigned int vector_length_;
     unsigned int code_length_;
-    bool bit_transition_flag_;
-    bool use_CFAR_algorithm_flag_;
     unsigned int channel_;
     std::weak_ptr<ChannelFsm> channel_fsm_;
     float threshold_;
     unsigned int doppler_max_;
     unsigned int doppler_step_;
     int doppler_center_;
-    unsigned int max_dwells_;
     int64_t fs_in_;
-    bool dump_;
-    bool blocking_;
     std::string dump_filename_;
     std::vector<std::complex<float>> code_;
     Gnss_Synchro* gnss_synchro_;

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc

@@ -878,7 +878,9 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count)
                     bool was_step_two = d_step_two;
                     d_step_two = false;
                     if (was_step_two)
+                        {
                             calculate_threshold();
+                        }
                     send_negative_acquisition();
                 }
         }
@@ -913,12 +915,15 @@ bool pcps_acquisition::start()
     return true;
 }
 
-void pcps_acquisition::calculate_threshold(void)
+
+void pcps_acquisition::calculate_threshold()
 {
     float pfa = (d_step_two ? acq_parameters.pfa2 : acq_parameters.pfa);
 
     if (pfa <= 0.0)
+        {
             return;
+        }
 
     int effective_fft_size = (acq_parameters.bit_transition_flag ? (d_fft_size / 2) : d_fft_size);
     int num_doppler_bins = (d_step_two ? d_num_doppler_bins_step2 : d_num_doppler_bins);
@@ -928,6 +933,7 @@ void pcps_acquisition::calculate_threshold(void)
     d_threshold = 2.0 * boost::math::gamma_p_inv(2 * acq_parameters.max_dwells, std::pow(1.0 - pfa, 1.0 / static_cast<double>(num_bins)));
 }
 
+
 int pcps_acquisition::general_work(int noutput_items __attribute__((unused)),
     gr_vector_int& ninput_items,
     gr_vector_const_void_star& input_items,

src/algorithms/acquisition/libs/acq_conf.cc

@@ -46,8 +46,8 @@ Acq_Conf::Acq_Conf()
     doppler_min = -5000;
     num_doppler_bins_step2 = 4U;
     doppler_step2 = 125.0;
-    pfa = 0.0;
+    pfa = 0.001;
-    pfa2 = 0.0;
+    pfa2 = 0.001;
     fs_in = 4000000;
     samples_per_ms = 0.0;
     samples_per_code = 0.0;
@@ -114,7 +114,9 @@ void Acq_Conf::SetFromConfiguration(ConfigurationInterface *configuration,
     pfa = configuration->property(role + ".pfa", pfa);
     pfa2 = configuration->property(role + ".pfa_second_step", pfa2);
     if (pfa2 <= 0.0)
+        {
             pfa2 = pfa;
+        }
     make_2_steps = configuration->property(role + ".make_two_steps", make_2_steps);
     blocking_on_standby = configuration->property(role + ".blocking_on_standby", blocking_on_standby);
 

src/algorithms/libs/item_type_helpers.cc

@@ -47,6 +47,7 @@ bool item_type_valid(const std::string &item_type)
     return true;
 }
 
+
 size_t item_type_size(const std::string &item_type)
 {
     if (item_type == "byte" or item_type == "ibyte")
@@ -79,90 +80,105 @@ size_t item_type_size(const std::string &item_type)
         }
 }
 
+
 bool item_type_is_complex(const std::string &item_type)
 {
     return (item_type == "ibyte") or (item_type == "cbyte") or (item_type == "ishort") or (item_type == "cshort") or (item_type == "gr_complex");
 }
 
+
 void copy_converter(void *dest, const void *src, unsigned int num_items, size_t item_size)
 {
     std::memcpy(dest, src, num_items * item_size);
 }
 
+
 void convert_8i_16i(void *dest, const void *src, unsigned int num_items)
 {
     volk_8i_convert_16i(reinterpret_cast<int16_t *>(dest),
         reinterpret_cast<const int8_t *>(src), num_items);
 }
 
+
 void convert_8i_32f(void *dest, const void *src, unsigned int num_items)
 {
     volk_8i_s32f_convert_32f(reinterpret_cast<float *>(dest),
-        reinterpret_cast<const int8_t *>(src), 1.0f, num_items);
+        reinterpret_cast<const int8_t *>(src), 1.0F, num_items);
 }
 
+
 void convert_8ic_16ic(void *dest, const void *src, unsigned int num_items)
 {
     volk_8i_convert_16i(reinterpret_cast<int16_t *>(dest),
         reinterpret_cast<const int8_t *>(src), 2 * num_items);
 }
 
+
 void convert_8ic_32fc(void *dest, const void *src, unsigned int num_items)
 {
     volk_8i_s32f_convert_32f(reinterpret_cast<float *>(dest),
-        reinterpret_cast<const int8_t *>(src), 1.0f, 2 * num_items);
+        reinterpret_cast<const int8_t *>(src), 1.0F, 2 * num_items);
 }
 
+
 void convert_16i_8i(void *dest, const void *src, unsigned int num_items)
 {
     volk_16i_convert_8i(reinterpret_cast<int8_t *>(dest),
         reinterpret_cast<const int16_t *>(src), num_items);
 }
 
+
 void convert_16i_32f(void *dest, const void *src, unsigned int num_items)
 {
     volk_16i_s32f_convert_32f(reinterpret_cast<float *>(dest),
-        reinterpret_cast<const int16_t *>(src), 1.0f, num_items);
+        reinterpret_cast<const int16_t *>(src), 1.0F, num_items);
 }
 
+
 void convert_16ic_8ic(void *dest, const void *src, unsigned int num_items)
 {
     volk_16i_convert_8i(reinterpret_cast<int8_t *>(dest),
         reinterpret_cast<const int16_t *>(src), 2 * num_items);
 }
 
+
 void convert_16ic_32fc(void *dest, const void *src, unsigned int num_items)
 {
     volk_16i_s32f_convert_32f(reinterpret_cast<float *>(dest),
-        reinterpret_cast<const int16_t *>(src), 1.0f, 2 * num_items);
+        reinterpret_cast<const int16_t *>(src), 1.0F, 2 * num_items);
 }
 
+
 void convert_32f_8i(void *dest, const void *src, unsigned int num_items)
 {
     volk_32f_s32f_convert_8i(reinterpret_cast<int8_t *>(dest),
-        reinterpret_cast<const float *>(src), 1.0f, num_items);
+        reinterpret_cast<const float *>(src), 1.0F, num_items);
 }
 
+
 void convert_32f_16i(void *dest, const void *src, unsigned int num_items)
 {
     volk_32f_s32f_convert_16i(reinterpret_cast<int16_t *>(dest),
-        reinterpret_cast<const float *>(src), 1.0f, num_items);
+        reinterpret_cast<const float *>(src), 1.0F, num_items);
 }
 
+
 void convert_32fc_8ic(void *dest, const void *src, unsigned int num_items)
 {
     volk_32f_s32f_convert_8i(reinterpret_cast<int8_t *>(dest),
-        reinterpret_cast<const float *>(src), 1.0f, 2 * num_items);
+        reinterpret_cast<const float *>(src), 1.0F, 2 * num_items);
 }
 
+
 void convert_32fc_16ic(void *dest, const void *src, unsigned int num_items)
 {
     volk_32f_s32f_convert_16i(reinterpret_cast<int16_t *>(dest),
-        reinterpret_cast<const float *>(src), 1.0f, 2 * num_items);
+        reinterpret_cast<const float *>(src), 1.0F, 2 * num_items);
 }
 
-item_type_converter_t make_vector_converter(std::string input_type,
+
-    std::string output_type)
+item_type_converter_t make_vector_converter(const std::string &input_type,
+    const std::string &output_type)
 {
     if (not item_type_valid(input_type) or not item_type_valid(output_type))
         {
@@ -172,21 +188,18 @@ item_type_converter_t make_vector_converter(std::string input_type,
     if (input_type == output_type)
         {
             size_t input_size = item_type_size(input_type);
-            return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2,
+            return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); };
-                std::placeholders::_3, input_size);
         }
 
     if (input_type == "byte")
         {
             if (output_type == "short")
                 {
-                    return std::bind(convert_8i_16i, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8i_16i(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
             else if (output_type == "float")
                 {
-                    return std::bind(convert_8i_32f, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8i_32f(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
         }
     else if (input_type == "cbyte")
@@ -194,18 +207,15 @@ item_type_converter_t make_vector_converter(std::string input_type,
             if (output_type == "ibyte")
                 {
                     size_t input_size = item_type_size(input_type);
-                    return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); };
-                        std::placeholders::_3, input_size);
                 }
             if (output_type == "cshort" or output_type == "ishort")
                 {
-                    return std::bind(convert_8ic_16ic, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8ic_16ic(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
             else if (output_type == "gr_complex")
                 {
-                    return std::bind(convert_8ic_32fc, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8ic_32fc(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
         }
     else if (input_type == "ibyte")
@@ -213,95 +223,80 @@ item_type_converter_t make_vector_converter(std::string input_type,
             if (output_type == "cbyte")
                 {
                     size_t input_size = item_type_size(input_type);
-                    return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); };
-                        std::placeholders::_3, input_size);
                 }
             else if (output_type == "cshort" or output_type == "ishort")
                 {
-                    return std::bind(convert_8i_16i, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8i_16i(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
             else if (output_type == "gr_complex")
                 {
-                    return std::bind(convert_8i_32f, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8i_32f(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
         }
     else if (input_type == "short")
         {
             if (output_type == "byte")
                 {
-                    return std::bind(convert_16i_8i, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16i_8i(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
             else if (output_type == "float")
                 {
-                    return std::bind(convert_16i_32f, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16i_32f(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
         }
     else if (input_type == "cshort")
         {
             if (output_type == "cbyte" or output_type == "ibyte")
                 {
-                    return std::bind(convert_16ic_8ic, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16ic_8ic(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
             if (output_type == "ishort")
                 {
                     size_t input_size = item_type_size(input_type);
-                    return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); };
-                        std::placeholders::_3, input_size);
                 }
             else if (output_type == "gr_complex")
                 {
-                    return std::bind(convert_16ic_32fc, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16ic_32fc(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
         }
     else if (input_type == "ishort")
         {
             if (output_type == "cbyte" or output_type == "ibyte")
                 {
-                    return std::bind(convert_16i_8i, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16i_8i(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
             if (output_type == "cshort")
                 {
                     size_t input_size = item_type_size(input_type);
-                    return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); };
-                        std::placeholders::_3, input_size);
                 }
             else if (output_type == "gr_complex")
                 {
-                    return std::bind(convert_16i_32f, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16i_32f(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
         }
     else if (input_type == "float")
         {
             if (output_type == "byte")
                 {
-                    return std::bind(convert_32f_8i, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_32f_8i(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
             else if (output_type == "short")
                 {
-                    return std::bind(convert_32f_16i, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_32f_16i(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
         }
     else if (input_type == "gr_complex")
         {
             if (output_type == "cbyte" or output_type == "ibyte")
                 {
-                    return std::bind(convert_32fc_8ic, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_32fc_8ic(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
             else if (output_type == "cshort" or output_type == "ishort")
                 {
-                    return std::bind(convert_32fc_16ic, std::placeholders::_1,
+                    return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_32fc_16ic(arg1, arg2, arg3); };
-                        std::placeholders::_2, std::placeholders::_3);
                 }
         }
 

src/algorithms/libs/item_type_helpers.h

@@ -58,7 +58,6 @@ size_t item_type_size(const std::string &item_type);
  */
 bool item_type_is_complex(const std::string &item_type);
 
-
 /*!
  * \brief Create a function to convert an array of input_type to an array of output_type
  *
@@ -82,9 +81,8 @@ bool item_type_is_complex(const std::string &item_type);
  * \returns A function object with the following prototype:
  *  void convert_fun( void *dest, void *src, int num_items );
  *
- *  
  */
-item_type_converter_t make_vector_converter(std::string input_type,
+item_type_converter_t make_vector_converter(const std::string &input_type,
-    std::string output_type);
+    const std::string &output_type);
 
 #endif

src/tests/system-tests/position_test.cc

@@ -193,7 +193,6 @@ int PositionSystemTest::configure_receiver()
             const int number_of_channels = 11;
             const int in_acquisition = 1;
 
-            const float threshold = 2.5;
             const float doppler_max = 5000.0;
             const float doppler_step = 250.0;
             const int max_dwells = 10;
@@ -278,7 +277,9 @@ int PositionSystemTest::configure_receiver()
             config->set_property("Acquisition_1C.implementation", "GPS_L1_CA_PCPS_Acquisition");
             config->set_property("Acquisition_1C.item_type", "gr_complex");
             config->set_property("Acquisition_1C.coherent_integration_time_ms", std::to_string(coherent_integration_time_ms));
-            config->set_property("Acquisition_1C.threshold", std::to_string(threshold));
+            //config->set_property("Acquisition_1C.use_CFAR_algorithm", "false");
+            //config->set_property("Acquisition_1C.pfa", std::to_string(0.001));
+            //config->set_property("Acquisition_1C.pfa2", std::to_string(0.001));
             config->set_property("Acquisition_1C.doppler_max", std::to_string(doppler_max));
             config->set_property("Acquisition_1C.doppler_step", std::to_string(doppler_step));
             config->set_property("Acquisition_1C.bit_transition_flag", "false");

src/tests/unit-tests/signal-processing-blocks/libs/item_type_helpers.cc

@@ -49,15 +49,11 @@ class ItemTypeHelpersTest : public ::testing::Test
         std::uniform_int_distribution<int16_t> udist_int16(-100, 100);
         std::uniform_real_distribution<float> udist_float(-100, 100);
 
-            std::generate( byte_array_in.begin(), byte_array_in.end(), [&udist_int8, &e](){
+        std::generate(byte_array_in.begin(), byte_array_in.end(), [&udist_int8, &e]() { return udist_int8(e); });
-                    return udist_int8(e); } );
 
-            std::generate( short_array_in.begin(), short_array_in.end(), [&udist_int16, &e](){
+        std::generate(short_array_in.begin(), short_array_in.end(), [&udist_int16, &e]() { return udist_int16(e); });
-                    return udist_int16(e); } );
-
-            std::generate( float_array_in.begin(), float_array_in.end(), [&udist_float, &e](){
-                    return udist_float(e); } );
 
+        std::generate(float_array_in.begin(), float_array_in.end(), [&udist_float, &e]() { return udist_float(e); });
     }
 
     std::vector<std::string> valid_item_types = {"byte", "ibyte", "cbyte",
@@ -74,8 +70,6 @@ class ItemTypeHelpersTest : public ::testing::Test
 
     std::array<float, 2 * N> float_array_in;
     std::array<float, 2 * N> float_array_out;
-
-
 };
 
 TEST_F(ItemTypeHelpersTest, CheckValidTypes)
@@ -128,7 +122,6 @@ TEST_F(ItemTypeHelpersTest, CheckMakeConverters)
                         {
                             EXPECT_THROW(converter = make_vector_converter(input_type, output_type), std::runtime_error);
                         }
-
                 }
         }
 }