Improve readability, reorder includes

src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc

@@ -36,12 +36,12 @@
  */
 
 #include "galileo_e5a_noncoherent_iq_acquisition_caf_cc.h"
-#include <sstream>
+#include "control_message_factory.h"
-#include <gnuradio/io_signature.h>
 #include <glog/logging.h>
+#include <gnuradio/io_signature.h>
 #include <volk/volk.h>
 #include <volk_gnsssdr/volk_gnsssdr.h>
-#include "control_message_factory.h"
+#include <sstream>
 
 using google::LogMessage;
 
@@ -62,11 +62,15 @@ galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr galileo_e5a_noncoherentIQ_make
             samples_per_code, bit_transition_flag, dump, dump_filename, both_signal_components_, CAF_window_hz_, Zero_padding_));
 }
 
+
 galileo_e5a_noncoherentIQ_acquisition_caf_cc::galileo_e5a_noncoherentIQ_acquisition_caf_cc(
     unsigned int sampled_ms,
     unsigned int max_dwells,
-    unsigned int doppler_max, long freq, long fs_in,
+    unsigned int doppler_max,
-    int samples_per_ms, int samples_per_code,
+    long freq,
+    long fs_in,
+    int samples_per_ms,
+    int samples_per_code,
     bool bit_transition_flag,
     bool dump,
     std::string dump_filename,
@@ -167,6 +171,7 @@ galileo_e5a_noncoherentIQ_acquisition_caf_cc::galileo_e5a_noncoherentIQ_acquisit
     d_gr_stream_buffer = 0;
 }
 
+
 galileo_e5a_noncoherentIQ_acquisition_caf_cc::~galileo_e5a_noncoherentIQ_acquisition_caf_cc()
 {
     if (d_num_doppler_bins > 0)
@@ -267,6 +272,7 @@ void galileo_e5a_noncoherentIQ_acquisition_caf_cc::set_local_code(std::complex<f
         }
 }
 
+
 void galileo_e5a_noncoherentIQ_acquisition_caf_cc::init()
 {
     d_gnss_synchro->Flag_valid_acquisition = false;

src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.cc

@@ -49,18 +49,18 @@
  */
 
 #include "pcps_opencl_acquisition_cc.h"
-#include <algorithm>
-#include <fstream>
-#include <iostream>
-#include <sstream>
-#include <glog/logging.h>
-#include <gnuradio/io_signature.h>
-#include <volk/volk.h>
-#include <volk_gnsssdr/volk_gnsssdr.h>
 #include "control_message_factory.h"
 #include "opencl/fft_base_kernels.h"
 #include "opencl/fft_internal.h"
 #include "GPS_L1_CA.h"  //GPS_TWO_PI
+#include <glog/logging.h>
+#include <gnuradio/io_signature.h>
+#include <volk/volk.h>
+#include <volk_gnsssdr/volk_gnsssdr.h>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <sstream>
 
 
 using google::LogMessage;
@@ -78,10 +78,15 @@ pcps_opencl_acquisition_cc_sptr pcps_make_opencl_acquisition_cc(
             samples_per_code, bit_transition_flag, dump, dump_filename));
 }
 
+
 pcps_opencl_acquisition_cc::pcps_opencl_acquisition_cc(
-    unsigned int sampled_ms, unsigned int max_dwells,
+    unsigned int sampled_ms,
-    unsigned int doppler_max, long freq, long fs_in,
+    unsigned int max_dwells,
-    int samples_per_ms, int samples_per_code,
+    unsigned int doppler_max,
+    long freq,
+    long fs_in,
+    int samples_per_ms,
+    int samples_per_code,
     bool bit_transition_flag,
     bool dump,
     std::string dump_filename) : gr::block("pcps_opencl_acquisition_cc",
@@ -339,6 +344,7 @@ void pcps_opencl_acquisition_cc::init()
         }
 }
 
+
 void pcps_opencl_acquisition_cc::set_local_code(std::complex<float> *code)
 {
     if (d_opencl == 0)
@@ -374,6 +380,7 @@ void pcps_opencl_acquisition_cc::set_local_code(std::complex<float> *code)
         }
 }
 
+
 void pcps_opencl_acquisition_cc::acquisition_core_volk()
 {
     // initialize acquisition algorithm
@@ -496,6 +503,7 @@ void pcps_opencl_acquisition_cc::acquisition_core_volk()
     d_core_working = false;
 }
 
+
 void pcps_opencl_acquisition_cc::acquisition_core_opencl()
 {
     // initialize acquisition algorithm
@@ -687,6 +695,7 @@ void pcps_opencl_acquisition_cc::set_state(int state)
         }
 }
 
+
 int pcps_opencl_acquisition_cc::general_work(int noutput_items,
     gr_vector_int &ninput_items, gr_vector_const_void_star &input_items,
     gr_vector_void_star &output_items __attribute__((unused)))

src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.h

@@ -51,14 +51,14 @@
 #ifndef GNSS_SDR_PCPS_OPENCL_ACQUISITION_CC_H_
 #define GNSS_SDR_PCPS_OPENCL_ACQUISITION_CC_H_
 
-#include <fstream>
+#include "gnss_synchro.h"
-#include <string>
+#include "opencl/fft_internal.h"
-#include <vector>
 #include <gnuradio/block.h>
 #include <gnuradio/gr_complex.h>
 #include <gnuradio/fft/fft.h>
-#include "opencl/fft_internal.h"
+#include <fstream>
-#include "gnss_synchro.h"
+#include <string>
+#include <vector>
 
 #ifdef __APPLE__
 #include "opencl/cl.hpp"

src/algorithms/input_filter/gnuradio_blocks/notch_cc.cc

@@ -45,9 +45,13 @@ notch_sptr make_notch_filter(float pfa, float p_c_factor,
 }
 
 
-Notch::Notch(float pfa, float p_c_factor, int length_, int n_segments_est, int n_segments_reset) : gr::block("Notch",
+Notch::Notch(float pfa,
-                                                                                                       gr::io_signature::make(1, 1, sizeof(gr_complex)),
+    float p_c_factor,
-                                                                                                       gr::io_signature::make(1, 1, sizeof(gr_complex)))
+    int length_,
+    int n_segments_est,
+    int n_segments_reset) : gr::block("Notch",
+                                gr::io_signature::make(1, 1, sizeof(gr_complex)),
+                                gr::io_signature::make(1, 1, sizeof(gr_complex)))
 {
     const int alignment_multiple = volk_get_alignment() / sizeof(gr_complex);
     set_alignment(std::max(1, alignment_multiple));
@@ -79,6 +83,7 @@ Notch::~Notch()
     volk_free(power_spect);
 }
 
+
 void Notch::forecast(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items_required)
 {
     for (unsigned int aux = 0; aux < ninput_items_required.size(); aux++)
@@ -87,6 +92,7 @@ void Notch::forecast(int noutput_items __attribute__((unused)), gr_vector_int &n
         }
 }
 
+
 int Notch::general_work(int noutput_items, gr_vector_int &ninput_items __attribute__((unused)),
     gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
 {

src/algorithms/input_filter/gnuradio_blocks/notch_lite_cc.cc

@@ -43,9 +43,15 @@ notch_lite_sptr make_notch_filter_lite(float p_c_factor, float pfa, int length_,
     return notch_lite_sptr(new NotchLite(p_c_factor, pfa, length_, n_segments_est, n_segments_reset, n_segments_coeff));
 }
 
-NotchLite::NotchLite(float p_c_factor, float pfa, int length_, int n_segments_est, int n_segments_reset, int n_segments_coeff) : gr::block("NotchLite",
+
-                                                                                                                                     gr::io_signature::make(1, 1, sizeof(gr_complex)),
+NotchLite::NotchLite(float p_c_factor,
-                                                                                                                                     gr::io_signature::make(1, 1, sizeof(gr_complex)))
+    float pfa,
+    int length_,
+    int n_segments_est,
+    int n_segments_reset,
+    int n_segments_coeff) : gr::block("NotchLite",
+                                gr::io_signature::make(1, 1, sizeof(gr_complex)),
+                                gr::io_signature::make(1, 1, sizeof(gr_complex)))
 {
     const int alignment_multiple = volk_get_alignment() / sizeof(gr_complex);
     set_alignment(std::max(1, alignment_multiple));
@@ -74,11 +80,13 @@ NotchLite::NotchLite(float p_c_factor, float pfa, int length_, int n_segments_es
     d_fft = std::unique_ptr<gr::fft::fft_complex>(new gr::fft::fft_complex(length_, true));
 }
 
+
 NotchLite::~NotchLite()
 {
     volk_free(power_spect);
 }
 
+
 void NotchLite::forecast(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items_required)
 {
     for (unsigned int aux = 0; aux < ninput_items_required.size(); aux++)
@@ -87,6 +95,7 @@ void NotchLite::forecast(int noutput_items __attribute__((unused)), gr_vector_in
         }
 }
 
+
 int NotchLite::general_work(int noutput_items, gr_vector_int &ninput_items __attribute__((unused)),
     gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
 {

src/algorithms/input_filter/gnuradio_blocks/pulse_blanking_cc.cc

@@ -44,9 +44,12 @@ pulse_blanking_cc_sptr make_pulse_blanking_cc(float pfa, int length_,
 }
 
 
-pulse_blanking_cc::pulse_blanking_cc(float pfa, int length_, int n_segments_est, int n_segments_reset) : gr::block("pulse_blanking_cc",
+pulse_blanking_cc::pulse_blanking_cc(float pfa,
-                                                                                                             gr::io_signature::make(1, 1, sizeof(gr_complex)),
+    int length_,
-                                                                                                             gr::io_signature::make(1, 1, sizeof(gr_complex)))
+    int n_segments_est,
+    int n_segments_reset) : gr::block("pulse_blanking_cc",
+                                gr::io_signature::make(1, 1, sizeof(gr_complex)),
+                                gr::io_signature::make(1, 1, sizeof(gr_complex)))
 {
     const int alignment_multiple = volk_get_alignment() / sizeof(gr_complex);
     set_alignment(std::max(1, alignment_multiple));
@@ -73,6 +76,7 @@ pulse_blanking_cc::~pulse_blanking_cc()
     volk_free(zeros_);
 }
 
+
 void pulse_blanking_cc::forecast(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items_required)
 {
     for (unsigned int aux = 0; aux < ninput_items_required.size(); aux++)
@@ -81,6 +85,7 @@ void pulse_blanking_cc::forecast(int noutput_items __attribute__((unused)), gr_v
         }
 }
 
+
 int pulse_blanking_cc::general_work(int noutput_items, gr_vector_int &ninput_items __attribute__((unused)),
     gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
 {

src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cb.cc

@@ -49,13 +49,14 @@ direct_resampler_conditioner_cb_sptr direct_resampler_make_conditioner_cb(
 
 
 direct_resampler_conditioner_cb::direct_resampler_conditioner_cb(
-    double sample_freq_in, double sample_freq_out) : gr::block("direct_resampler_make_conditioner_cb", gr::io_signature::make(1, 1, sizeof(lv_8sc_t)), gr::io_signature::make(1, 1, sizeof(lv_8sc_t))),
+    double sample_freq_in,
-                                                     d_sample_freq_in(sample_freq_in),
+    double sample_freq_out) : gr::block("direct_resampler_make_conditioner_cb", gr::io_signature::make(1, 1, sizeof(lv_8sc_t)), gr::io_signature::make(1, 1, sizeof(lv_8sc_t))),
-                                                     d_sample_freq_out(
+                              d_sample_freq_in(sample_freq_in),
-                                                         sample_freq_out),
+                              d_sample_freq_out(
-                                                     d_phase(0),
+                                  sample_freq_out),
-                                                     d_lphase(0),
+                              d_phase(0),
-                                                     d_history(1)
+                              d_lphase(0),
+                              d_history(1)
 {
     const double two_32 = 4294967296.0;
     // Computes the phase step multiplying the resampling ratio by 2^32 = 4294967296

src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cc.cc

@@ -49,7 +49,13 @@ direct_resampler_conditioner_cc_sptr direct_resampler_make_conditioner_cc(
 
 
 direct_resampler_conditioner_cc::direct_resampler_conditioner_cc(
-    double sample_freq_in, double sample_freq_out) : gr::block("direct_resampler_conditioner_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)), gr::io_signature::make(1, 1, sizeof(gr_complex))), d_sample_freq_in(sample_freq_in), d_sample_freq_out(sample_freq_out), d_phase(0), d_lphase(0), d_history(1)
+    double sample_freq_in,
+    double sample_freq_out) : gr::block("direct_resampler_conditioner_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)), gr::io_signature::make(1, 1, sizeof(gr_complex))),
+                              d_sample_freq_in(sample_freq_in),
+                              d_sample_freq_out(sample_freq_out),
+                              d_phase(0),
+                              d_lphase(0),
+                              d_history(1)
 {
     // Computes the phase step multiplying the resampling ratio by 2^32 = 4294967296
     const double two_32 = 4294967296.0;

src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cs.cc

@@ -48,13 +48,13 @@ direct_resampler_conditioner_cs_sptr direct_resampler_make_conditioner_cs(
 
 
 direct_resampler_conditioner_cs::direct_resampler_conditioner_cs(
-    double sample_freq_in, double sample_freq_out) : gr::block("direct_resampler_make_conditioner_cs", gr::io_signature::make(1, 1, sizeof(lv_16sc_t)), gr::io_signature::make(1, 1, sizeof(lv_16sc_t))),
+    double sample_freq_in,
-                                                     d_sample_freq_in(sample_freq_in),
+    double sample_freq_out) : gr::block("direct_resampler_make_conditioner_cs", gr::io_signature::make(1, 1, sizeof(lv_16sc_t)), gr::io_signature::make(1, 1, sizeof(lv_16sc_t))),
-                                                     d_sample_freq_out(
+                              d_sample_freq_in(sample_freq_in),
-                                                         sample_freq_out),
+                              d_sample_freq_out(sample_freq_out),
-                                                     d_phase(0),
+                              d_phase(0),
-                                                     d_lphase(0),
+                              d_lphase(0),
-                                                     d_history(1)
+                              d_history(1)
 {
     const double two_32 = 4294967296.0;
     // Computes the phase step multiplying the resampling ratio by 2^32 = 4294967296

src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc

@@ -56,32 +56,41 @@ signal_make_generator_c(std::vector<std::string> signal1, std::vector<std::strin
         data_flag, noise_flag, fs_in, vector_length, BW_BB));
 }
 
+
 /*
 * The private constructor
 */
-signal_generator_c::signal_generator_c(std::vector<std::string> signal1, std::vector<std::string> system, const std::vector<unsigned int> &PRN,
+signal_generator_c::signal_generator_c(std::vector<std::string> signal1,
-    const std::vector<float> &CN0_dB, const std::vector<float> &doppler_Hz,
+    std::vector<std::string> system,
-    const std::vector<unsigned int> &delay_chips, const std::vector<unsigned int> &delay_sec, bool data_flag, bool noise_flag,
+    const std::vector<unsigned int> &PRN,
-    unsigned int fs_in, unsigned int vector_length, float BW_BB) : gr::block("signal_gen_cc", gr::io_signature::make(0, 0, sizeof(gr_complex)),
+    const std::vector<float> &CN0_dB,
-                                                                       gr::io_signature::make(1, 1, sizeof(gr_complex) * vector_length)),
+    const std::vector<float> &doppler_Hz,
-                                                                   signal_(signal1),
+    const std::vector<unsigned int> &delay_chips,
-                                                                   system_(system),
+    const std::vector<unsigned int> &delay_sec,
-                                                                   PRN_(PRN),
+    bool data_flag,
-                                                                   CN0_dB_(CN0_dB),
+    bool noise_flag,
-                                                                   doppler_Hz_(doppler_Hz),
+    unsigned int fs_in,
-                                                                   delay_chips_(delay_chips),
+    unsigned int vector_length,
-                                                                   delay_sec_(delay_sec),
+    float BW_BB) : gr::block("signal_gen_cc", gr::io_signature::make(0, 0, sizeof(gr_complex)), gr::io_signature::make(1, 1, sizeof(gr_complex) * vector_length)),
-                                                                   data_flag_(data_flag),
+                   signal_(signal1),
-                                                                   noise_flag_(noise_flag),
+                   system_(system),
-                                                                   fs_in_(fs_in),
+                   PRN_(PRN),
-                                                                   num_sats_(PRN.size()),
+                   CN0_dB_(CN0_dB),
-                                                                   vector_length_(vector_length),
+                   doppler_Hz_(doppler_Hz),
-                                                                   BW_BB_(BW_BB * static_cast<float>(fs_in) / 2.0)
+                   delay_chips_(delay_chips),
+                   delay_sec_(delay_sec),
+                   data_flag_(data_flag),
+                   noise_flag_(noise_flag),
+                   fs_in_(fs_in),
+                   num_sats_(PRN.size()),
+                   vector_length_(vector_length),
+                   BW_BB_(BW_BB * static_cast<float>(fs_in) / 2.0)
 {
     init();
     generate_codes();
 }
 
+
 void signal_generator_c::init()
 {
     work_counter_ = 0;

src/algorithms/signal_source/gnuradio_blocks/labsat23_source.cc

@@ -6,9 +6,6 @@
  * -------------------------------------------------------------------------
  *
  * Copyright (C) 2010-2018  (see AUTHORS file for a list of contributors)
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
  *
  * GNSS-SDR is a software defined Global Navigation
  *          Satellite Systems receiver
@@ -52,9 +49,10 @@ std::string labsat23_source::generate_filename()
 }
 
 
-labsat23_source::labsat23_source(const char *signal_file_basename, int channel_selector) : gr::block("labsat23_source",
+labsat23_source::labsat23_source(const char *signal_file_basename,
-                                                                                               gr::io_signature::make(0, 0, 0),
+    int channel_selector) : gr::block("labsat23_source",
-                                                                                               gr::io_signature::make(1, 1, sizeof(gr_complex)))
+                                gr::io_signature::make(0, 0, 0),
+                                gr::io_signature::make(1, 1, sizeof(gr_complex)))
 {
     if (channel_selector < 1 or channel_selector > 2)
         {