Merge branch 'std-pointers' into next

.github/workflows/main.yml

@@ -70,7 +70,7 @@ jobs:
     - name: install dependencies
       run: sudo apt-get install python3-pip && sudo pip3 install cpplint
     - name: run checks
-      run: find ./src/ -iname *.h -o -iname *.cc | xargs cpplint --filter=-,+build/class,+build/c++14,+build/deprecated,+build/explicit_make_pair,+build/include_what_you_use,+build/printf_format,+build/storage_class,+readability/constructors,+readability/namespace,+readability/newline,+readability/utf8,+runtime/casting,+runtime/explicit,+runtime/indentation_namespace,+runtime/init,+runtime/invalid_increment,+runtime/member_string_references,+runtime/memset,+runtime/operator,+runtime/printf,+runtime/printf_format,+whitespace/blank_line,+whitespace/comma,+whitespace/comments,+whitespace/empty_conditional_body,+whitespace/end-of-line,+whitespace/ending-newline,+whitespace/semicolon,+whitespace/tab
+      run: find ./src/ -iname *.h -o -iname *.cc | xargs cpplint --filter=-,+build/class,+build/c++14,+build/deprecated,+build/explicit_make_pair,+build/printf_format,+build/storage_class,+readability/constructors,+readability/namespace,+readability/newline,+readability/utf8,+runtime/casting,+runtime/explicit,+runtime/indentation_namespace,+runtime/init,+runtime/invalid_increment,+runtime/member_string_references,+runtime/memset,+runtime/operator,+runtime/printf,+runtime/printf_format,+whitespace/blank_line,+whitespace/comma,+whitespace/comments,+whitespace/empty_conditional_body,+whitespace/end-of-line,+whitespace/ending-newline,+whitespace/semicolon,+whitespace/tab
 
 
   prettier-markdown:

cmake/Modules/FindGNURADIO.cmake

@@ -270,6 +270,18 @@ endif()
 
 find_package_handle_standard_args(GNURADIO DEFAULT_MSG GNURADIO_RUNTIME_FOUND)
 
+# Detect if using standard pointers
+set(GNURADIO_USES_STD_POINTERS FALSE)
+if(GNURADIO_VERSION VERSION_GREATER 3.8.99)
+    file(STRINGS ${GNURADIO_RUNTIME_INCLUDE_DIRS}/gnuradio/basic_block.h _basic_block)
+    foreach(_loop_var IN LISTS _basic_block)
+        string(STRIP "${_loop_var}" _file_line)
+        if("public std::enable_shared_from_this<basic_block>" STREQUAL "${_file_line}")
+            set(GNURADIO_USES_STD_POINTERS TRUE)
+        endif()
+    endforeach()
+endif()
+
 # Search for IIO component
 if(GNURADIO_VERSION VERSION_GREATER 3.8.99)
     pkg_check_modules(PC_GNURADIO_IIO QUIET gnuradio-iio)

docs/changelog.md

@@ -10,6 +10,11 @@ SPDX-FileCopyrightText: 2011-2020 Carles Fernandez-Prades <carles.fernandez@cttc
 
 ## Unreleased
 
+### Improvements in Maintainability:
+
+- The software can now be built against the GNU Radio 3.9 API that uses C++11
+  smart pointers instead of Boost smart pointers.
+
 ### Improvements in Reproducibility:
 
 - Improved reproducibility of the volk_gnsssdr library: Drop compile-time CPU

src/algorithms/PVT/gnuradio_blocks/CMakeLists.txt

@@ -43,6 +43,12 @@ target_link_libraries(pvt_gr_blocks
         Boost::serialization
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(pvt_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_CLANG_TIDY)
     if(CLANG_TIDY_EXE)
         set_target_properties(pvt_gr_blocks

src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_gs.h

@@ -24,7 +24,6 @@
 #include "rtklib.h"
 #include <boost/date_time/gregorian/gregorian.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/shared_ptr.hpp>   // for boost::shared_ptr
 #include <gnuradio/sync_block.h>  // for sync_block
 #include <gnuradio/types.h>       // for gr_vector_const_void_star
 #include <pmt/pmt.h>              // for pmt_t
@@ -37,6 +36,10 @@
 #include <sys/types.h>            // for key_t
 #include <utility>                // for pair
 #include <vector>                 // for vector
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Beidou_Dnav_Almanac;
 class Beidou_Dnav_Ephemeris;
@@ -55,7 +58,11 @@ class Rtcm_Printer;
 class Rtklib_Solver;
 class rtklib_pvt_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using rtklib_pvt_gs_sptr = std::shared_ptr<rtklib_pvt_gs>;
+#else
 using rtklib_pvt_gs_sptr = boost::shared_ptr<rtklib_pvt_gs>;
+#endif
 
 rtklib_pvt_gs_sptr rtklib_make_pvt_gs(uint32_t nchannels,
     const Pvt_Conf& conf_,

src/algorithms/acquisition/adapters/CMakeLists.txt

@@ -100,6 +100,12 @@ target_link_libraries(acquisition_adapters
         Gnuradio::fft
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(acquisition_adapters
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_FPGA)
     target_link_libraries(acquisition_adapters
         PRIVATE

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fine_doppler.cc

@@ -161,7 +161,35 @@ void GpsL1CaPcpsAcquisitionFineDoppler::set_state(int state)
     acquisition_cc_->set_state(state);
 }
 
+#if GNURADIO_USES_STD_POINTERS
+void GpsL1CaPcpsAcquisitionFineDoppler::connect(std::shared_ptr<gr::top_block> top_block)
+{
+    if (top_block)
+        { /* top_block is not null */
+        };
+    // nothing to disconnect, now the tracking uses gr_sync_decimator
+}
 
+
+void GpsL1CaPcpsAcquisitionFineDoppler::disconnect(std::shared_ptr<gr::top_block> top_block)
+{
+    if (top_block)
+        { /* top_block is not null */
+        };
+    // nothing to disconnect, now the tracking uses gr_sync_decimator
+}
+
+std::shared_ptr<gr::basic_block> GpsL1CaPcpsAcquisitionFineDoppler::get_left_block()
+{
+    return acquisition_cc_;
+}
+
+
+std::shared_ptr<gr::basic_block> GpsL1CaPcpsAcquisitionFineDoppler::get_right_block()
+{
+    return acquisition_cc_;
+}
+#else
 void GpsL1CaPcpsAcquisitionFineDoppler::connect(boost::shared_ptr<gr::top_block> top_block)
 {
     if (top_block)
@@ -179,7 +207,6 @@ void GpsL1CaPcpsAcquisitionFineDoppler::disconnect(boost::shared_ptr<gr::top_blo
     // nothing to disconnect, now the tracking uses gr_sync_decimator
 }
 
-
 boost::shared_ptr<gr::basic_block> GpsL1CaPcpsAcquisitionFineDoppler::get_left_block()
 {
     return acquisition_cc_;
@@ -190,3 +217,4 @@ boost::shared_ptr<gr::basic_block> GpsL1CaPcpsAcquisitionFineDoppler::get_right_
 {
     return acquisition_cc_;
 }
+#endif

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fine_doppler.h

@@ -29,6 +29,12 @@
 #include <memory>
 #include <string>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+using pcps_acquisition_fine_doppler_cc_sptr = std::shared_ptr<pcps_acquisition_fine_doppler_cc>;
+#else
+#include <boost/shared_ptr.hpp>
+using pcps_acquisition_fine_doppler_cc_sptr = boost::shared_ptr<pcps_acquisition_fine_doppler_cc>;
+#endif
 
 class ConfigurationInterface;
 
@@ -64,11 +70,17 @@ public:
         return item_size_;
     }
 
+#if GNURADIO_USES_STD_POINTERS
+    void connect(std::shared_ptr<gr::top_block> top_block) override;
+    void disconnect(std::shared_ptr<gr::top_block> top_block) override;
+    std::shared_ptr<gr::basic_block> get_left_block() override;
+    std::shared_ptr<gr::basic_block> get_right_block() override;
+#else
     void connect(boost::shared_ptr<gr::top_block> top_block) override;
     void disconnect(boost::shared_ptr<gr::top_block> top_block) override;
     boost::shared_ptr<gr::basic_block> get_left_block() override;
     boost::shared_ptr<gr::basic_block> get_right_block() override;
-
+#endif
     /*!
      * \brief Set acquisition/tracking common Gnss_Synchro object pointer
      * to efficiently exchange synchronization data between acquisition and

src/algorithms/acquisition/gnuradio_blocks/CMakeLists.txt

@@ -81,6 +81,12 @@ target_include_directories(acquisition_gr_blocks
         ${CMAKE_SOURCE_DIR}/src/core/receiver
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(acquisition_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_ARMA_NO_DEBUG)
     target_compile_definitions(acquisition_gr_blocks
         PUBLIC -DARMA_NO_BOUND_CHECKING=1

src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.h

@@ -37,10 +37,18 @@
 #include <string>
 #include <utility>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class galileo_e5a_noncoherentIQ_acquisition_caf_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr = std::shared_ptr<galileo_e5a_noncoherentIQ_acquisition_caf_cc>;
+#else
 using galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr = boost::shared_ptr<galileo_e5a_noncoherentIQ_acquisition_caf_cc>;
+#endif
 
 galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr galileo_e5a_noncoherentIQ_make_acquisition_caf_cc(
     unsigned int sampled_ms,

src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.h

@@ -31,10 +31,18 @@
 #include <string>
 #include <utility>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class galileo_pcps_8ms_acquisition_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using galileo_pcps_8ms_acquisition_cc_sptr = std::shared_ptr<galileo_pcps_8ms_acquisition_cc>;
+#else
 using galileo_pcps_8ms_acquisition_cc_sptr = boost::shared_ptr<galileo_pcps_8ms_acquisition_cc>;
+#endif
 
 galileo_pcps_8ms_acquisition_cc_sptr
 galileo_pcps_8ms_make_acquisition_cc(uint32_t sampled_ms,

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h

@@ -62,11 +62,19 @@
 #include <memory>
 #include <string>
 #include <utility>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Gnss_Synchro;
 class pcps_acquisition;
 
+#if GNURADIO_USES_STD_POINTERS
+using pcps_acquisition_sptr = std::shared_ptr<pcps_acquisition>;
+#else
 using pcps_acquisition_sptr = boost::shared_ptr<pcps_acquisition>;
+#endif
 
 pcps_acquisition_sptr pcps_make_acquisition(const Acq_Conf& conf_);
 

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.h

@@ -55,10 +55,18 @@
 #include <memory>
 #include <string>
 #include <utility>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class pcps_acquisition_fine_doppler_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using pcps_acquisition_fine_doppler_cc_sptr = std::shared_ptr<pcps_acquisition_fine_doppler_cc>;
+#else
 using pcps_acquisition_fine_doppler_cc_sptr = boost::shared_ptr<pcps_acquisition_fine_doppler_cc>;
+#endif
 
 pcps_acquisition_fine_doppler_cc_sptr pcps_make_acquisition_fine_doppler_cc(const Acq_Conf& conf_);
 

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.h

@@ -32,7 +32,6 @@
 
 #include "channel_fsm.h"
 #include "fpga_acquisition.h"
-#include <boost/shared_ptr.hpp>
 #include <glog/logging.h>
 #include <cstdint>  // for uint32_t
 #include <memory>   // for shared_ptr
@@ -62,7 +61,7 @@ typedef struct
 
 class pcps_acquisition_fpga;
 
-using pcps_acquisition_fpga_sptr = boost::shared_ptr<pcps_acquisition_fpga>;
+using pcps_acquisition_fpga_sptr = std::shared_ptr<pcps_acquisition_fpga>;
 
 pcps_acquisition_fpga_sptr pcps_make_acquisition_fpga(pcpsconf_fpga_t conf_);
 

src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.h

@@ -47,10 +47,18 @@
 #include <string>
 #include <utility>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class pcps_assisted_acquisition_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using pcps_assisted_acquisition_cc_sptr = std::shared_ptr<pcps_assisted_acquisition_cc>;
+#else
 using pcps_assisted_acquisition_cc_sptr = boost::shared_ptr<pcps_assisted_acquisition_cc>;
+#endif
 
 pcps_assisted_acquisition_cc_sptr pcps_make_assisted_acquisition_cc(
     int32_t max_dwells,

src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.h

@@ -36,11 +36,19 @@
 #include <string>
 #include <utility>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class pcps_cccwsr_acquisition_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using pcps_cccwsr_acquisition_cc_sptr = std::shared_ptr<pcps_cccwsr_acquisition_cc>;
+#else
 using pcps_cccwsr_acquisition_cc_sptr = boost::shared_ptr<pcps_cccwsr_acquisition_cc>;
+#endif
 
 pcps_cccwsr_acquisition_cc_sptr pcps_cccwsr_make_acquisition_cc(
     uint32_t sampled_ms,

src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.h

@@ -56,7 +56,7 @@
 
 class pcps_opencl_acquisition_cc;
 
-typedef boost::shared_ptr<pcps_opencl_acquisition_cc> pcps_opencl_acquisition_cc_sptr;
+typedef std::shared_ptr<pcps_opencl_acquisition_cc> pcps_opencl_acquisition_cc_sptr;
 
 pcps_opencl_acquisition_cc_sptr pcps_make_opencl_acquisition_cc(
     uint32_t sampled_ms,

src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.h

@@ -53,10 +53,18 @@
 #include <string>
 #include <utility>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class pcps_quicksync_acquisition_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using pcps_quicksync_acquisition_cc_sptr = std::shared_ptr<pcps_quicksync_acquisition_cc>;
+#else
 using pcps_quicksync_acquisition_cc_sptr = boost::shared_ptr<pcps_quicksync_acquisition_cc>;
+#endif
 
 pcps_quicksync_acquisition_cc_sptr pcps_quicksync_make_acquisition_cc(
     uint32_t folding_factor,

src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.h

@@ -50,11 +50,18 @@
 #include <string>
 #include <utility>
 #include <vector>
-
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class pcps_tong_acquisition_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using pcps_tong_acquisition_cc_sptr = std::shared_ptr<pcps_tong_acquisition_cc>;
+#else
 using pcps_tong_acquisition_cc_sptr = boost::shared_ptr<pcps_tong_acquisition_cc>;
+#endif
 
 pcps_tong_acquisition_cc_sptr pcps_tong_make_acquisition_cc(
     uint32_t sampled_ms,

src/algorithms/channel/libs/CMakeLists.txt

@@ -41,6 +41,12 @@ target_include_directories(channel_libs
         ${CMAKE_SOURCE_DIR}/src/core/receiver
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(channel_libs
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_CLANG_TIDY)
     if(CLANG_TIDY_EXE)
         set_target_properties(channel_libs

src/algorithms/channel/libs/channel_msg_receiver_cc.h

@@ -24,10 +24,18 @@
 #include <gnuradio/block.h>
 #include <pmt/pmt.h>
 #include <memory>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class channel_msg_receiver_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using channel_msg_receiver_cc_sptr = std::shared_ptr<channel_msg_receiver_cc>;
+#else
 using channel_msg_receiver_cc_sptr = boost::shared_ptr<channel_msg_receiver_cc>;
+#endif
 
 channel_msg_receiver_cc_sptr channel_msg_receiver_make_cc(std::shared_ptr<ChannelFsm> channel_fsm, bool repeat);
 

src/algorithms/data_type_adapter/gnuradio_blocks/CMakeLists.txt

@@ -38,6 +38,12 @@ target_link_libraries(data_type_gr_blocks
         Volk::volk
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(data_type_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 set_property(TARGET data_type_gr_blocks
     APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>

src/algorithms/data_type_adapter/gnuradio_blocks/interleaved_byte_to_complex_byte.h

@@ -20,12 +20,20 @@
 #ifndef GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_BYTE_H
 #define GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_BYTE_H
 
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/sync_decimator.h>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class interleaved_byte_to_complex_byte;
 
+#if GNURADIO_USES_STD_POINTERS
+using interleaved_byte_to_complex_byte_sptr = std::shared_ptr<interleaved_byte_to_complex_byte>;
+#else
 using interleaved_byte_to_complex_byte_sptr = boost::shared_ptr<interleaved_byte_to_complex_byte>;
+#endif
 
 interleaved_byte_to_complex_byte_sptr make_interleaved_byte_to_complex_byte();
 

src/algorithms/data_type_adapter/gnuradio_blocks/interleaved_byte_to_complex_short.h

@@ -20,12 +20,20 @@
 #ifndef GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_SHORT_H
 #define GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_SHORT_H
 
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/sync_decimator.h>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class interleaved_byte_to_complex_short;
 
+#if GNURADIO_USES_STD_POINTERS
+using interleaved_byte_to_complex_short_sptr = std::shared_ptr<interleaved_byte_to_complex_short>;
+#else
 using interleaved_byte_to_complex_short_sptr = boost::shared_ptr<interleaved_byte_to_complex_short>;
+#endif
 
 interleaved_byte_to_complex_short_sptr make_interleaved_byte_to_complex_short();
 

src/algorithms/data_type_adapter/gnuradio_blocks/interleaved_short_to_complex_short.h

@@ -20,12 +20,20 @@
 #ifndef GNSS_SDR_INTERLEAVED_SHORT_TO_COMPLEX_SHORT_H
 #define GNSS_SDR_INTERLEAVED_SHORT_TO_COMPLEX_SHORT_H
 
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/sync_decimator.h>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class interleaved_short_to_complex_short;
 
+#if GNURADIO_USES_STD_POINTERS
+using interleaved_short_to_complex_short_sptr = std::shared_ptr<interleaved_short_to_complex_short>;
+#else
 using interleaved_short_to_complex_short_sptr = boost::shared_ptr<interleaved_short_to_complex_short>;
+#endif
 
 interleaved_short_to_complex_short_sptr make_interleaved_short_to_complex_short();
 

src/algorithms/input_filter/gnuradio_blocks/CMakeLists.txt

@@ -40,6 +40,12 @@ target_link_libraries(input_filter_gr_blocks
         Log4cpp::log4cpp
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(input_filter_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_CLANG_TIDY)
     if(CLANG_TIDY_EXE)
         set_target_properties(input_filter_gr_blocks

src/algorithms/input_filter/gnuradio_blocks/beamformer.h

@@ -22,10 +22,19 @@
 
 #include <gnuradio/sync_block.h>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class beamformer;
 
+#if GNURADIO_USES_STD_POINTERS
+using beamformer_sptr = std::shared_ptr<beamformer>;
+#else
 using beamformer_sptr = boost::shared_ptr<beamformer>;
+#endif
 
 beamformer_sptr make_beamformer_sptr();
 

src/algorithms/input_filter/gnuradio_blocks/notch_cc.h

@@ -20,15 +20,22 @@
 #ifndef GNSS_SDR_NOTCH_H
 #define GNSS_SDR_NOTCH_H
 
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/block.h>
 #include <gnuradio/fft/fft.h>
 #include <cstdint>
-#include <memory>
 
 class Notch;
 
+#if GNURADIO_USES_STD_POINTERS
+using notch_sptr = std::shared_ptr<Notch>;
+#else
 using notch_sptr = boost::shared_ptr<Notch>;
+#endif
 
 notch_sptr make_notch_filter(
     float pfa,

src/algorithms/input_filter/gnuradio_blocks/notch_lite_cc.h

@@ -20,15 +20,22 @@
 #ifndef GNSS_SDR_NOTCH_LITE_H
 #define GNSS_SDR_NOTCH_LITE_H
 
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/block.h>
 #include <gnuradio/fft/fft.h>
 #include <cstdint>
-#include <memory>
 
 class NotchLite;
 
+#if GNURADIO_USES_STD_POINTERS
+using notch_lite_sptr = std::shared_ptr<NotchLite>;
+#else
 using notch_lite_sptr = boost::shared_ptr<NotchLite>;
+#endif
 
 notch_lite_sptr make_notch_filter_lite(
     float p_c_factor,

src/algorithms/input_filter/gnuradio_blocks/pulse_blanking_cc.h

@@ -20,13 +20,21 @@
 #ifndef GNSS_SDR_PULSE_BLANKING_H
 #define GNSS_SDR_PULSE_BLANKING_H
 
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/block.h>
 #include <cstdint>
 
 class pulse_blanking_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using pulse_blanking_cc_sptr = std::shared_ptr<pulse_blanking_cc>;
+#else
 using pulse_blanking_cc_sptr = boost::shared_ptr<pulse_blanking_cc>;
+#endif
 
 pulse_blanking_cc_sptr make_pulse_blanking_cc(
     float pfa,

src/algorithms/libs/CMakeLists.txt

@@ -104,6 +104,12 @@ target_link_libraries(algorithms_libs
         Glog::glog
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(algorithms_libs
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_OPENCL)
     target_link_libraries(algorithms_libs PUBLIC OpenCL::OpenCL)
     target_include_directories(algorithms_libs PUBLIC

src/algorithms/libs/byte_x2_to_complex_byte.h

@@ -20,14 +20,22 @@
 #ifndef GNSS_SDR_BYTE_X2_TO_COMPLEX_BYTE_H
 #define GNSS_SDR_BYTE_X2_TO_COMPLEX_BYTE_H
 
-
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/sync_block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 
 class byte_x2_to_complex_byte;
 
+#if GNURADIO_USES_STD_POINTERS
+using byte_x2_to_complex_byte_sptr = std::shared_ptr<byte_x2_to_complex_byte>;
+#else
 using byte_x2_to_complex_byte_sptr = boost::shared_ptr<byte_x2_to_complex_byte>;
+#endif
+
 
 byte_x2_to_complex_byte_sptr make_byte_x2_to_complex_byte();
 

src/algorithms/libs/complex_byte_to_float_x2.h

@@ -21,13 +21,21 @@
 #define GNSS_SDR_COMPLEX_BYTE_TO_FLOAT_X2_H
 
 
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/sync_block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 
 class complex_byte_to_float_x2;
 
+#if GNURADIO_USES_STD_POINTERS
+using complex_byte_to_float_x2_sptr = std::shared_ptr<complex_byte_to_float_x2>;
+#else
 using complex_byte_to_float_x2_sptr = boost::shared_ptr<complex_byte_to_float_x2>;
+#endif
 
 complex_byte_to_float_x2_sptr make_complex_byte_to_float_x2();
 

src/algorithms/libs/complex_float_to_complex_byte.h

@@ -20,14 +20,22 @@
 #ifndef GNSS_SDR_COMPLEX_FLOAT_TO_COMPLEX_BYTE_H
 #define GNSS_SDR_COMPLEX_FLOAT_TO_COMPLEX_BYTE_H
 
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/sync_block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 
 
 class complex_float_to_complex_byte;
 
+#if GNURADIO_USES_STD_POINTERS
+using complex_float_to_complex_byte_sptr = std::shared_ptr<complex_float_to_complex_byte>;
+#else
 using complex_float_to_complex_byte_sptr = boost::shared_ptr<complex_float_to_complex_byte>;
+#endif
 
 complex_float_to_complex_byte_sptr make_complex_float_to_complex_byte();
 

src/algorithms/libs/conjugate_cc.h

@@ -20,13 +20,21 @@
 #ifndef GNSS_SDR_CONJUGATE_CC_H
 #define GNSS_SDR_CONJUGATE_CC_H
 
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/sync_block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 
 class conjugate_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using conjugate_cc_sptr = std::shared_ptr<conjugate_cc>;
+#else
 using conjugate_cc_sptr = boost::shared_ptr<conjugate_cc>;
+#endif
 
 conjugate_cc_sptr make_conjugate_cc();
 

src/algorithms/libs/conjugate_ic.h

@@ -20,13 +20,21 @@
 #ifndef GNSS_SDR_CONJUGATE_IC_H
 #define GNSS_SDR_CONJUGATE_IC_H
 
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/sync_block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class conjugate_ic;
 
+#if GNURADIO_USES_STD_POINTERS
+using conjugate_ic_sptr = std::shared_ptr<conjugate_ic>;
+#else
 using conjugate_ic_sptr = boost::shared_ptr<conjugate_ic>;
+#endif
 
 conjugate_ic_sptr make_conjugate_ic();
 

src/algorithms/libs/conjugate_sc.h

@@ -20,13 +20,21 @@
 #ifndef GNSS_SDR_CONJUGATE_SC_H
 #define GNSS_SDR_CONJUGATE_SC_H
 
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/sync_block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 
 class conjugate_sc;
 
+#if GNURADIO_USES_STD_POINTERS
+using conjugate_sc_sptr = std::shared_ptr<conjugate_sc>;
+#else
 using conjugate_sc_sptr = boost::shared_ptr<conjugate_sc>;
+#endif
 
 conjugate_sc_sptr make_conjugate_sc();
 

src/algorithms/libs/cshort_to_float_x2.h

@@ -21,13 +21,21 @@
 #define GNSS_SDR_CSHORT_TO_FLOAT_X2_H
 
 
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/sync_block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 
 class cshort_to_float_x2;
 
+#if GNURADIO_USES_STD_POINTERS
+using cshort_to_float_x2_sptr = std::shared_ptr<cshort_to_float_x2>;
+#else
 using cshort_to_float_x2_sptr = boost::shared_ptr<cshort_to_float_x2>;
+#endif
 
 cshort_to_float_x2_sptr make_cshort_to_float_x2();
 

src/algorithms/libs/short_x2_to_cshort.h

@@ -21,13 +21,21 @@
 #define GNSS_SDR_SHORT_X2_TO_CSHORT_H
 
 
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
 #include <boost/shared_ptr.hpp>
+#endif
 #include <gnuradio/sync_block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 
 class short_x2_to_cshort;
 
+#if GNURADIO_USES_STD_POINTERS
+using short_x2_to_cshort_sptr = std::shared_ptr<short_x2_to_cshort>;
+#else
 using short_x2_to_cshort_sptr = boost::shared_ptr<short_x2_to_cshort>;
+#endif
 
 short_x2_to_cshort_sptr make_short_x2_to_cshort();
 

src/algorithms/observables/gnuradio_blocks/CMakeLists.txt

@@ -47,6 +47,12 @@ target_link_libraries(obs_gr_blocks
         Matio::matio
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(obs_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_CLANG_TIDY)
     if(CLANG_TIDY_EXE)
         set_target_properties(obs_gr_blocks

src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.h

@@ -25,7 +25,6 @@
 
 #include "obs_conf.h"
 #include <boost/circular_buffer.hpp>  // for boost::circular_buffer
-#include <boost/shared_ptr.hpp>       // for boost::shared_ptr
 #include <gnuradio/block.h>           // for block
 #include <gnuradio/types.h>           // for gr_vector_int
 #include <cstdint>                    // for int32_t
@@ -34,6 +33,11 @@
 #include <memory>                     // for std:shared_ptr
 #include <string>                     // for std::string
 #include <vector>                     // for std::vector
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Gnss_Synchro;
 class hybrid_observables_gs;
@@ -41,7 +45,11 @@ class hybrid_observables_gs;
 template <class T>
 class Gnss_circular_deque;
 
+#if GNURADIO_USES_STD_POINTERS
+using hybrid_observables_gs_sptr = std::shared_ptr<hybrid_observables_gs>;
+#else
 using hybrid_observables_gs_sptr = boost::shared_ptr<hybrid_observables_gs>;
+#endif
 
 hybrid_observables_gs_sptr hybrid_observables_gs_make(const Obs_Conf& conf_);
 

src/algorithms/resampler/gnuradio_blocks/CMakeLists.txt

@@ -38,6 +38,12 @@ target_link_libraries(resampler_gr_blocks
         Volk::volk
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(resampler_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_CLANG_TIDY)
     if(CLANG_TIDY_EXE)
         set_target_properties(resampler_gr_blocks

src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cb.h

@@ -21,12 +21,21 @@
 #ifndef GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CB_H
 #define GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CB_H
 
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/block.h>
 #include <cstdint>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class direct_resampler_conditioner_cb;
+
+#if GNURADIO_USES_STD_POINTERS
+using direct_resampler_conditioner_cb_sptr = std::shared_ptr<direct_resampler_conditioner_cb>;
+#else
 using direct_resampler_conditioner_cb_sptr = boost::shared_ptr<direct_resampler_conditioner_cb>;
+#endif
 
 direct_resampler_conditioner_cb_sptr direct_resampler_make_conditioner_cb(
     double sample_freq_in,

src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cc.h

@@ -28,13 +28,21 @@
 #ifndef GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CC_H
 #define GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CC_H
 
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/block.h>
 #include <cstdint>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class direct_resampler_conditioner_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using direct_resampler_conditioner_cc_sptr = std::shared_ptr<direct_resampler_conditioner_cc>;
+#else
 using direct_resampler_conditioner_cc_sptr = boost::shared_ptr<direct_resampler_conditioner_cc>;
+#endif
 
 direct_resampler_conditioner_cc_sptr direct_resampler_make_conditioner_cc(
     double sample_freq_in,

src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cs.h

@@ -21,12 +21,20 @@
 #ifndef GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CS_H
 #define GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CS_H
 
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/block.h>
 #include <cstdint>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class direct_resampler_conditioner_cs;
+#if GNURADIO_USES_STD_POINTERS
+using direct_resampler_conditioner_cs_sptr = std::shared_ptr<direct_resampler_conditioner_cs>;
+#else
 using direct_resampler_conditioner_cs_sptr = boost::shared_ptr<direct_resampler_conditioner_cs>;
+#endif
 
 direct_resampler_conditioner_cs_sptr direct_resampler_make_conditioner_cs(
     double sample_freq_in,

src/algorithms/signal_generator/adapters/CMakeLists.txt

@@ -33,6 +33,12 @@ target_include_directories(signal_generator_adapters
         ${CMAKE_SOURCE_DIR}/src/core/receiver
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(signal_generator_adapters
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_CLANG_TIDY)
     if(CLANG_TIDY_EXE)
         set_target_properties(signal_generator_adapters

src/algorithms/signal_generator/adapters/signal_generator.h

@@ -79,7 +79,11 @@ private:
     size_t item_size_;
     bool dump_;
     std::string dump_filename_;
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> gen_source_;
+#else
     boost::shared_ptr<gr::block> gen_source_;
+#endif
     gr::blocks::vector_to_stream::sptr vector_to_stream_;
     gr::blocks::file_sink::sptr file_sink_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t> > queue_;

src/algorithms/signal_generator/gnuradio_blocks/CMakeLists.txt

@@ -31,6 +31,12 @@ target_include_directories(signal_generator_gr_blocks
         ${CMAKE_SOURCE_DIR}/src/algorithms/libs
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(signal_generator_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_CLANG_TIDY)
     if(CLANG_TIDY_EXE)
         set_target_properties(signal_generator_gr_blocks

src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.h

@@ -25,21 +25,30 @@
 #include <random>
 #include <string>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class signal_generator_c;
 
 /*
-* We use boost::shared_ptr's instead of raw pointers for all access
+* We use std::shared_ptr's instead of raw pointers for all access
 * to gr_blocks (and many other data structures). The shared_ptr gets
 * us transparent reference counting, which greatly simplifies storage
 * management issues.
 *
 * See https://www.boost.org/doc/libs/release/libs/smart_ptr/doc/html/smart_ptr.html
 *
-* As a convention, the _sptr suffix indicates a boost::shared_ptr
+* As a convention, the _sptr suffix indicates a std::shared_ptr
 */
+#if GNURADIO_USES_STD_POINTERS
+using signal_generator_c_sptr = std::shared_ptr<signal_generator_c>;
+#else
 using signal_generator_c_sptr = boost::shared_ptr<signal_generator_c>;
+#endif
 
 /*!
 * \brief Return a shared_ptr to a new instance of gen_source.

src/algorithms/signal_source/adapters/CMakeLists.txt

@@ -152,6 +152,12 @@ target_link_libraries(signal_source_adapters
         Volk::volk
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(signal_source_adapters
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_RAW_UDP AND PCAP_FOUND)
     target_link_libraries(signal_source_adapters
         PRIVATE

src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.h

@@ -24,7 +24,6 @@
 #include "concurrent_queue.h"
 #include "fpga_switch.h"
 #include "gnss_block_interface.h"
-#include <boost/shared_ptr.hpp>
 #include <pmt/pmt.h>
 #include <cstdint>
 #include <memory>

src/algorithms/signal_source/adapters/custom_udp_signal_source.h

@@ -24,7 +24,6 @@
 #include "concurrent_queue.h"
 #include "gnss_block_interface.h"
 #include "gr_complex_ip_packet_source.h"
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/blocks/file_sink.h>
 #include <gnuradio/blocks/null_sink.h>
 #include <pmt/pmt.h>
@@ -32,6 +31,10 @@
 #include <stdexcept>
 #include <string>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class ConfigurationInterface;
@@ -86,9 +89,16 @@ private:
     size_t item_size_;
     bool dump_;
     std::string dump_filename_;
+#if GNURADIO_USES_STD_POINTERS
+    std::vector<std::shared_ptr<gr::block>> null_sinks_;
+    std::vector<std::shared_ptr<gr::block>> file_sink_;
+#else
     std::vector<boost::shared_ptr<gr::block>> null_sinks_;
-    Gr_Complex_Ip_Packet_Source::sptr udp_gnss_rx_source_;
     std::vector<boost::shared_ptr<gr::block>> file_sink_;
+#endif
+
+    Gr_Complex_Ip_Packet_Source::sptr udp_gnss_rx_source_;
+
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
 };
 

src/algorithms/signal_source/adapters/file_signal_source.h

@@ -34,6 +34,10 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class ConfigurationInterface;
 
@@ -110,7 +114,11 @@ private:
     uint32_t in_streams_;
     uint32_t out_streams_;
     gr::blocks::file_source::sptr file_source_;
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr sink_;
     gr::blocks::throttle::sptr throttle_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

src/algorithms/signal_source/adapters/flexiband_signal_source.h

@@ -96,8 +96,8 @@ private:
 
     gr::block_sptr flexiband_source_;
 
-    std::vector<boost::shared_ptr<gr::block>> char_to_float;
-    std::vector<boost::shared_ptr<gr::block>> float_to_complex_;
+    std::vector<std::shared_ptr<gr::block>> char_to_float;
+    std::vector<std::shared_ptr<gr::block>> float_to_complex_;
     std::vector<gr::blocks::null_sink::sptr> null_sinks_;
 
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

src/algorithms/signal_source/adapters/fmcomms2_signal_source.h

@@ -23,7 +23,6 @@
 #define GNSS_SDR_FMCOMMS2_SIGNAL_SOURCE_H
 
 #include "gnss_block_interface.h"
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/blocks/file_sink.h>
 #if GRIIO_INCLUDE_HAS_GNURADIO
 #include <gnuradio/iio/fmcomms2_source.h>
@@ -35,6 +34,10 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class ConfigurationInterface;
 
@@ -118,7 +121,11 @@ private:
 
     gr::iio::fmcomms2_source_f32c::sptr fmcomms2_source_f32c_;
 
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr file_sink_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
 };

src/algorithms/signal_source/adapters/multichannel_file_signal_source.h

@@ -35,6 +35,10 @@
 #include <memory>
 #include <string>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class ConfigurationInterface;
 
@@ -110,7 +114,11 @@ private:
     uint32_t in_streams_;
     uint32_t out_streams_;
     std::vector<gr::blocks::file_source::sptr> file_source_vec_;
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr sink_;
     std::vector<gr::blocks::throttle::sptr> throttle_vec_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

src/algorithms/signal_source/adapters/nsr_file_signal_source.h

@@ -34,6 +34,10 @@
 #include <pmt/pmt.h>
 #include <memory>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class ConfigurationInterface;
 
@@ -110,7 +114,11 @@ private:
     uint32_t out_streams_;
     gr::blocks::file_source::sptr file_source_;
     unpack_byte_2bit_samples_sptr unpack_byte_;
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr sink_;
     gr::blocks::throttle::sptr throttle_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

src/algorithms/signal_source/adapters/osmosdr_signal_source.h

@@ -24,7 +24,6 @@
 
 #include "concurrent_queue.h"
 #include "gnss_block_interface.h"
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/blocks/file_sink.h>
 #include <pmt/pmt.h>
 #include <cstdint>
@@ -32,6 +31,10 @@
 #include <osmosdr/source.h>
 #include <stdexcept>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class ConfigurationInterface;
 
@@ -99,7 +102,11 @@ private:
 
     std::string antenna_;
 
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr file_sink_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
 };

src/algorithms/signal_source/adapters/plutosdr_signal_source.h

@@ -22,7 +22,6 @@
 #define GNSS_SDR_PLUTOSDR_SIGNAL_SOURCE_H
 
 #include "gnss_block_interface.h"
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/blocks/file_sink.h>
 #if GRIIO_INCLUDE_HAS_GNURADIO
 #include <gnuradio/iio/pluto_source.h>
@@ -34,6 +33,10 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class ConfigurationInterface;
@@ -103,7 +106,11 @@ private:
 
     gr::iio::pluto_source::sptr plutosdr_source_;
 
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr file_sink_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
 };

src/algorithms/signal_source/adapters/rtl_tcp_signal_source.h

@@ -24,7 +24,6 @@
 #include "concurrent_queue.h"
 #include "gnss_block_interface.h"
 #include "rtl_tcp_signal_source_c.h"
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/blocks/deinterleave.h>
 #include <gnuradio/blocks/file_sink.h>
 #include <gnuradio/blocks/float_to_complex.h>
@@ -32,6 +31,10 @@
 #include <memory>
 #include <stdexcept>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class ConfigurationInterface;
@@ -102,7 +105,11 @@ private:
 
     rtl_tcp_signal_source_c_sptr signal_source_;
 
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr file_sink_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
 };

src/algorithms/signal_source/adapters/spir_file_signal_source.h

@@ -32,6 +32,10 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class ConfigurationInterface;
 
@@ -108,7 +112,11 @@ private:
     unsigned int out_streams_;
     gr::blocks::file_source::sptr file_source_;
     unpack_intspir_1bit_samples_sptr unpack_intspir_;
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr sink_;
     gr::blocks::throttle::sptr throttle_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.h

@@ -37,6 +37,10 @@
 #include <memory>
 #include <string>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class ConfigurationInterface;
@@ -119,7 +123,11 @@ private:
     std::vector<gr::blocks::endian_swap::sptr> endian_vec_;
     std::vector<gr::blocks::null_sink::sptr> null_sinks_;
     std::vector<unpack_spir_gss6450_samples_sptr> unpack_spir_vec_;
+#if GNURADIO_USES_STD_POINTERS
+    std::vector<std::shared_ptr<gr::block>> valve_vec_;
+#else
     std::vector<boost::shared_ptr<gr::block>> valve_vec_;
+#endif
     std::vector<gr::blocks::file_sink::sptr> sink_vec_;
     std::vector<gr::blocks::throttle::sptr> throttle_vec_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

src/algorithms/signal_source/adapters/two_bit_cpx_file_signal_source.h

@@ -35,6 +35,10 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class ConfigurationInterface;
@@ -115,7 +119,11 @@ private:
     gr::blocks::file_source::sptr file_source_;
     unpack_byte_2bit_cpx_samples_sptr unpack_byte_;
     gr::blocks::interleaved_short_to_complex::sptr inter_shorts_to_cpx_;
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr sink_;
     gr::blocks::throttle::sptr throttle_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

src/algorithms/signal_source/adapters/two_bit_packed_file_signal_source.h

@@ -36,6 +36,10 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class ConfigurationInterface;
@@ -134,7 +138,11 @@ private:
     gr::blocks::file_source::sptr file_source_;
     unpack_2bit_samples_sptr unpack_samples_;
     gr::basic_block_sptr char_to_float_;
+#if GNURADIO_USES_STD_POINTERS
+    std::shared_ptr<gr::block> valve_;
+#else
     boost::shared_ptr<gr::block> valve_;
+#endif
     gr::blocks::file_sink::sptr sink_;
     gr::blocks::throttle::sptr throttle_;
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

src/algorithms/signal_source/adapters/uhd_signal_source.h

@@ -22,7 +22,6 @@
 
 #include "concurrent_queue.h"
 #include "gnss_block_interface.h"
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/blocks/file_sink.h>
 #include <gnuradio/hier_block2.h>
 #include <gnuradio/uhd/usrp_source.h>
@@ -31,6 +30,10 @@
 #include <memory>
 #include <string>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class ConfigurationInterface;
@@ -94,8 +97,11 @@ private:
     std::vector<uint64_t> samples_;
     std::vector<bool> dump_;
     std::vector<std::string> dump_filename_;
-
+#if GNURADIO_USES_STD_POINTERS
+    std::vector<std::shared_ptr<gr::block>> valve_;
+#else
     std::vector<boost::shared_ptr<gr::block>> valve_;
+#endif
     std::vector<gr::blocks::file_sink::sptr> file_sink_;
 
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

src/algorithms/signal_source/gnuradio_blocks/CMakeLists.txt

@@ -66,6 +66,12 @@ target_include_directories(signal_source_gr_blocks
         ${CMAKE_SOURCE_DIR}/src/core/receiver
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(signal_source_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_RAW_UDP AND PCAP_FOUND)
     target_link_libraries(signal_source_gr_blocks
         PUBLIC

src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.h

@@ -31,11 +31,20 @@
 #include <pcap.h>
 #include <string>
 #include <sys/ioctl.h>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Gr_Complex_Ip_Packet_Source : virtual public gr::sync_block
 {
 public:
+#if GNURADIO_USES_STD_POINTERS
+    typedef std::shared_ptr<Gr_Complex_Ip_Packet_Source> sptr;
+#else
     typedef boost::shared_ptr<Gr_Complex_Ip_Packet_Source> sptr;
+#endif
     static sptr make(std::string src_device,
         const std::string &origin_address,
         int udp_port,

src/algorithms/signal_source/gnuradio_blocks/labsat23_source.h

@@ -25,13 +25,20 @@
 #include <pmt/pmt.h>
 #include <cstdint>
 #include <fstream>
-#include <memory>
 #include <string>
-
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class labsat23_source;
 
+#if GNURADIO_USES_STD_POINTERS
+using labsat23_source_sptr = std::shared_ptr<labsat23_source>;
+#else
 using labsat23_source_sptr = boost::shared_ptr<labsat23_source>;
+#endif
 
 labsat23_source_sptr labsat23_make_source_sptr(
     const char *signal_file_basename,

src/algorithms/signal_source/gnuradio_blocks/rtl_tcp_signal_source_c.h

@@ -37,10 +37,19 @@
 #include <cstdint>
 #include <string>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class rtl_tcp_signal_source_c;
 
+#if GNURADIO_USES_STD_POINTERS
+using rtl_tcp_signal_source_c_sptr = std::shared_ptr<rtl_tcp_signal_source_c>;
+#else
 using rtl_tcp_signal_source_c_sptr = boost::shared_ptr<rtl_tcp_signal_source_c>;
+#endif
 
 #if BOOST_GREATER_1_65
 using b_io_context = boost::asio::io_context;

src/algorithms/signal_source/gnuradio_blocks/unpack_2bit_samples.h

@@ -60,10 +60,19 @@
 #include <gnuradio/sync_interpolator.h>
 #include <cstdint>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class unpack_2bit_samples;
 
+#if GNURADIO_USES_STD_POINTERS
+using unpack_2bit_samples_sptr = std::shared_ptr<unpack_2bit_samples>;
+#else
 using unpack_2bit_samples_sptr = boost::shared_ptr<unpack_2bit_samples>;
+#endif
 
 unpack_2bit_samples_sptr make_unpack_2bit_samples(
     bool big_endian_bytes,

src/algorithms/signal_source/gnuradio_blocks/unpack_byte_2bit_cpx_samples.h

@@ -25,10 +25,19 @@
 #define GNSS_SDR_UNPACK_BYTE_2BIT_CPX_SAMPLES_H
 
 #include <gnuradio/sync_interpolator.h>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class unpack_byte_2bit_cpx_samples;
 
+#if GNURADIO_USES_STD_POINTERS
+using unpack_byte_2bit_cpx_samples_sptr = std::shared_ptr<unpack_byte_2bit_cpx_samples>;
+#else
 using unpack_byte_2bit_cpx_samples_sptr = boost::shared_ptr<unpack_byte_2bit_cpx_samples>;
+#endif
 
 unpack_byte_2bit_cpx_samples_sptr make_unpack_byte_2bit_cpx_samples();
 

src/algorithms/signal_source/gnuradio_blocks/unpack_byte_2bit_samples.h

@@ -21,10 +21,19 @@
 #define GNSS_SDR_UNPACK_BYTE_2BIT_SAMPLES_H
 
 #include <gnuradio/sync_interpolator.h>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class unpack_byte_2bit_samples;
 
+#if GNURADIO_USES_STD_POINTERS
+using unpack_byte_2bit_samples_sptr = std::shared_ptr<unpack_byte_2bit_samples>;
+#else
 using unpack_byte_2bit_samples_sptr = boost::shared_ptr<unpack_byte_2bit_samples>;
+#endif
 
 unpack_byte_2bit_samples_sptr make_unpack_byte_2bit_samples();
 

src/algorithms/signal_source/gnuradio_blocks/unpack_byte_4bit_samples.h

@@ -26,7 +26,7 @@
 
 class unpack_byte_4bit_samples;
 
-using unpack_byte_4bit_samples_sptr = boost::shared_ptr<unpack_byte_4bit_samples>;
+using unpack_byte_4bit_samples_sptr = std::shared_ptr<unpack_byte_4bit_samples>;
 
 unpack_byte_4bit_samples_sptr make_unpack_byte_4bit_samples();
 

src/algorithms/signal_source/gnuradio_blocks/unpack_intspir_1bit_samples.h

@@ -21,10 +21,19 @@
 #define GNSS_SDR_UNPACK_INTSPIR_1BIT_SAMPLES_H
 
 #include <gnuradio/sync_interpolator.h>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class unpack_intspir_1bit_samples;
 
+#if GNURADIO_USES_STD_POINTERS
+using unpack_intspir_1bit_samples_sptr = std::shared_ptr<unpack_intspir_1bit_samples>;
+#else
 using unpack_intspir_1bit_samples_sptr = boost::shared_ptr<unpack_intspir_1bit_samples>;
+#endif
 
 unpack_intspir_1bit_samples_sptr make_unpack_intspir_1bit_samples();
 

src/algorithms/signal_source/gnuradio_blocks/unpack_spir_gss6450_samples.h

@@ -22,10 +22,19 @@
 #define GNSS_SDR_UNPACK_SPIR_GSS6450_SAMPLES_H
 
 #include <gnuradio/sync_interpolator.h>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class unpack_spir_gss6450_samples;
 
+#if GNURADIO_USES_STD_POINTERS
+using unpack_spir_gss6450_samples_sptr = std::shared_ptr<unpack_spir_gss6450_samples>;
+#else
 using unpack_spir_gss6450_samples_sptr = boost::shared_ptr<unpack_spir_gss6450_samples>;
+#endif
 
 unpack_spir_gss6450_samples_sptr make_unpack_spir_gss6450_samples(unsigned int adc_nbit_);
 

src/algorithms/signal_source/libs/CMakeLists.txt

@@ -55,6 +55,12 @@ target_include_directories(signal_source_libs
         ${CMAKE_SOURCE_DIR}/src/core/receiver
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(signal_source_libs
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_FMCOMMS2 OR ENABLE_AD9361)
     target_link_libraries(signal_source_libs
         PUBLIC

src/algorithms/signal_source/libs/gnss_sdr_valve.cc

@@ -43,7 +43,20 @@ Gnss_Sdr_Valve::Gnss_Sdr_Valve(size_t sizeof_stream_item,
     d_open_valve = false;
 }
 
+#if GNURADIO_USES_STD_POINTERS
+std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(size_t sizeof_stream_item, uint64_t nitems, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue, bool stop_flowgraph)
+{
+    std::shared_ptr<Gnss_Sdr_Valve> valve_(new Gnss_Sdr_Valve(sizeof_stream_item, nitems, std::move(queue), stop_flowgraph));
+    return valve_;
+}
 
+
+std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(size_t sizeof_stream_item, uint64_t nitems, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue)
+{
+    std::shared_ptr<Gnss_Sdr_Valve> valve_(new Gnss_Sdr_Valve(sizeof_stream_item, nitems, std::move(queue), true));
+    return valve_;
+}
+#else
 boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(size_t sizeof_stream_item, uint64_t nitems, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue, bool stop_flowgraph)
 {
     boost::shared_ptr<Gnss_Sdr_Valve> valve_(new Gnss_Sdr_Valve(sizeof_stream_item, nitems, std::move(queue), stop_flowgraph));
@@ -56,6 +69,7 @@ boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(size_t sizeof_stream_item,
     boost::shared_ptr<Gnss_Sdr_Valve> valve_(new Gnss_Sdr_Valve(sizeof_stream_item, nitems, std::move(queue), true));
     return valve_;
 }
+#endif
 
 
 void Gnss_Sdr_Valve::open_valve()

src/algorithms/signal_source/libs/gnss_sdr_valve.h

@@ -24,16 +24,31 @@
 #define GNSS_SDR_GNSS_SDR_VALVE_H
 
 #include "concurrent_queue.h"
-#include <boost/shared_ptr.hpp>
 #include <gnuradio/sync_block.h>  // for sync_block
 #include <gnuradio/types.h>       // for gr_vector_const_void_star
 #include <pmt/pmt.h>
 #include <cstddef>  // for size_t
 #include <cstdint>
+#if GNURADIO_USES_STD_POINTERS
 #include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Gnss_Sdr_Valve;
 
+#if GNURADIO_USES_STD_POINTERS
+std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
+    size_t sizeof_stream_item,
+    uint64_t nitems,
+    std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue);
+
+std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
+    size_t sizeof_stream_item,
+    uint64_t nitems,
+    std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue,
+    bool stop_flowgraph);
+#else
 boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
     size_t sizeof_stream_item,
     uint64_t nitems,
@@ -44,6 +59,7 @@ boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
     uint64_t nitems,
     std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue,
     bool stop_flowgraph);
+#endif
 
 /*!
  * \brief Implementation of a GNU Radio block that sends a STOP message to the
@@ -59,6 +75,18 @@ public:
         gr_vector_void_star &output_items);
 
 private:
+#if GNURADIO_USES_STD_POINTERS
+    friend std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
+        size_t sizeof_stream_item,
+        uint64_t nitems,
+        std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue);
+
+    friend std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
+        size_t sizeof_stream_item,
+        uint64_t nitems,
+        std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue,
+        bool stop_flowgraph);
+#else
     friend boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
         size_t sizeof_stream_item,
         uint64_t nitems,
@@ -69,7 +97,7 @@ private:
         uint64_t nitems,
         std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue,
         bool stop_flowgraph);
-
+#endif
     Gnss_Sdr_Valve(size_t sizeof_stream_item,
         uint64_t nitems,
         std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue, bool stop_flowgraph);

src/algorithms/telemetry_decoder/gnuradio_blocks/CMakeLists.txt

@@ -53,6 +53,12 @@ target_link_libraries(telemetry_decoder_gr_blocks
         Glog::glog
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(telemetry_decoder_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_CLANG_TIDY)
     if(CLANG_TIDY_EXE)
         set_target_properties(telemetry_decoder_gr_blocks

src/algorithms/telemetry_decoder/gnuradio_blocks/beidou_b1i_telemetry_decoder_gs.h

@@ -26,18 +26,26 @@
 #include "beidou_dnav_navigation_message.h"
 #include "gnss_satellite.h"
 #include <boost/circular_buffer.hpp>
-#include <boost/shared_ptr.hpp>  // for boost::shared_ptr
-#include <gnuradio/block.h>      // for block
-#include <gnuradio/types.h>      // for gr_vector_const_void_star
+#include <gnuradio/block.h>  // for block
+#include <gnuradio/types.h>  // for gr_vector_const_void_star
 #include <array>
 #include <cstdint>
 #include <fstream>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class beidou_b1i_telemetry_decoder_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using beidou_b1i_telemetry_decoder_gs_sptr = std::shared_ptr<beidou_b1i_telemetry_decoder_gs>;
+#else
 using beidou_b1i_telemetry_decoder_gs_sptr = boost::shared_ptr<beidou_b1i_telemetry_decoder_gs>;
+#endif
 
 beidou_b1i_telemetry_decoder_gs_sptr beidou_b1i_make_telemetry_decoder_gs(
     const Gnss_Satellite &satellite,

src/algorithms/telemetry_decoder/gnuradio_blocks/beidou_b3i_telemetry_decoder_gs.h

@@ -23,18 +23,27 @@
 #include "beidou_dnav_navigation_message.h"
 #include "gnss_satellite.h"
 #include <boost/circular_buffer.hpp>
-#include <boost/shared_ptr.hpp>  // for boost::shared_ptr
-#include <gnuradio/block.h>      // for block
-#include <gnuradio/types.h>      // for gr_vector_const_void_star
+#include <gnuradio/block.h>  // for block
+#include <gnuradio/types.h>  // for gr_vector_const_void_star
 #include <array>
 #include <cstdint>
 #include <fstream>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class beidou_b3i_telemetry_decoder_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using beidou_b3i_telemetry_decoder_gs_sptr =
+    std::shared_ptr<beidou_b3i_telemetry_decoder_gs>;
+#else
 using beidou_b3i_telemetry_decoder_gs_sptr =
     boost::shared_ptr<beidou_b3i_telemetry_decoder_gs>;
+#endif
 
 beidou_b3i_telemetry_decoder_gs_sptr beidou_b3i_make_telemetry_decoder_gs(
     const Gnss_Satellite &satellite,

src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_telemetry_decoder_gs.cc

@@ -36,7 +36,7 @@
 #include <cstdlib>          // for abs
 #include <exception>        // for exception
 #include <iostream>         // for cout
-#include <memory>           // for shared_ptr, make_shared
+#include <memory>           // for make_shared
 
 
 #define CRC_ERROR_LIMIT 6

src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_telemetry_decoder_gs.h

@@ -26,18 +26,26 @@
 #include "galileo_navigation_message.h"
 #include "gnss_satellite.h"
 #include <boost/circular_buffer.hpp>
-#include <boost/shared_ptr.hpp>  // for boost::shared_ptr
-#include <gnuradio/block.h>      // for block
-#include <gnuradio/types.h>      // for gr_vector_const_void_star
+#include <gnuradio/block.h>  // for block
+#include <gnuradio/types.h>  // for gr_vector_const_void_star
 #include <array>
 #include <cstdint>
 #include <fstream>
 #include <string>
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>  // for std::shared_ptr
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class galileo_telemetry_decoder_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using galileo_telemetry_decoder_gs_sptr = std::shared_ptr<galileo_telemetry_decoder_gs>;
+#else
 using galileo_telemetry_decoder_gs_sptr = boost::shared_ptr<galileo_telemetry_decoder_gs>;
+#endif
 
 galileo_telemetry_decoder_gs_sptr galileo_make_telemetry_decoder_gs(
     const Gnss_Satellite &satellite,

src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l1_ca_telemetry_decoder_gs.h

@@ -27,18 +27,26 @@
 #include "gnss_satellite.h"
 #include "gnss_synchro.h"
 #include <boost/circular_buffer.hpp>
-#include <boost/shared_ptr.hpp>  // for boost::shared_ptr
-#include <gnuradio/block.h>      // for block
-#include <gnuradio/types.h>      // for gr_vector_const_void_star
+#include <gnuradio/block.h>  // for block
+#include <gnuradio/types.h>  // for gr_vector_const_void_star
 #include <array>
 #include <cstdint>
 #include <fstream>  // for ofstream
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>  // for std::shared_ptr
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class glonass_l1_ca_telemetry_decoder_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using glonass_l1_ca_telemetry_decoder_gs_sptr = std::shared_ptr<glonass_l1_ca_telemetry_decoder_gs>;
+#else
 using glonass_l1_ca_telemetry_decoder_gs_sptr = boost::shared_ptr<glonass_l1_ca_telemetry_decoder_gs>;
+#endif
 
 glonass_l1_ca_telemetry_decoder_gs_sptr glonass_l1_ca_make_telemetry_decoder_gs(
     const Gnss_Satellite &satellite,

src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l2_ca_telemetry_decoder_gs.h

@@ -26,18 +26,25 @@
 #include "gnss_satellite.h"
 #include "gnss_synchro.h"
 #include <boost/circular_buffer.hpp>
-#include <boost/shared_ptr.hpp>  // for boost::shared_ptr
 #include <gnuradio/block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 #include <array>
 #include <cstdint>
 #include <fstream>
 #include <string>
-
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>  // for std::shared_ptr
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class glonass_l2_ca_telemetry_decoder_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using glonass_l2_ca_telemetry_decoder_gs_sptr = std::shared_ptr<glonass_l2_ca_telemetry_decoder_gs>;
+#else
 using glonass_l2_ca_telemetry_decoder_gs_sptr = boost::shared_ptr<glonass_l2_ca_telemetry_decoder_gs>;
+#endif
 
 glonass_l2_ca_telemetry_decoder_gs_sptr glonass_l2_ca_make_telemetry_decoder_gs(
     const Gnss_Satellite &satellite,

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_gs.h

@@ -25,18 +25,25 @@
 #include "gnss_synchro.h"
 #include "gps_navigation_message.h"
 #include <boost/circular_buffer.hpp>
-#include <boost/shared_ptr.hpp>  // for boost::shared_ptr
-#include <gnuradio/block.h>      // for block
-#include <gnuradio/types.h>      // for gr_vector_const_void_star
-#include <array>                 // for array
-#include <cstdint>               // for int32_t
-#include <fstream>               // for ofstream
-#include <string>                // for string
-
+#include <gnuradio/block.h>  // for block
+#include <gnuradio/types.h>  // for gr_vector_const_void_star
+#include <array>             // for array
+#include <cstdint>           // for int32_t
+#include <fstream>           // for ofstream
+#include <string>            // for string
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>  // for std::shared_ptr
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class gps_l1_ca_telemetry_decoder_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using gps_l1_ca_telemetry_decoder_gs_sptr = std::shared_ptr<gps_l1_ca_telemetry_decoder_gs>;
+#else
 using gps_l1_ca_telemetry_decoder_gs_sptr = boost::shared_ptr<gps_l1_ca_telemetry_decoder_gs>;
+#endif
 
 gps_l1_ca_telemetry_decoder_gs_sptr gps_l1_ca_make_telemetry_decoder_gs(
     const Gnss_Satellite &satellite,

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l2c_telemetry_decoder_gs.h

@@ -22,12 +22,16 @@
 
 #include "gnss_satellite.h"
 #include "gps_cnav_navigation_message.h"
-#include <boost/shared_ptr.hpp>  // for boost::shared_ptr
 #include <gnuradio/block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 #include <cstdint>
 #include <fstream>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>  // for std::shared_ptr
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 extern "C"
 {
@@ -37,7 +41,11 @@ extern "C"
 
 class gps_l2c_telemetry_decoder_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using gps_l2c_telemetry_decoder_gs_sptr = std::shared_ptr<gps_l2c_telemetry_decoder_gs>;
+#else
 using gps_l2c_telemetry_decoder_gs_sptr = boost::shared_ptr<gps_l2c_telemetry_decoder_gs>;
+#endif
 
 gps_l2c_telemetry_decoder_gs_sptr gps_l2c_make_telemetry_decoder_gs(
     const Gnss_Satellite &satellite,

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l5_telemetry_decoder_gs.h

@@ -24,12 +24,16 @@
 #include "gnss_satellite.h"               // for Gnss_Satellite
 #include "gps_cnav_navigation_message.h"  // for Gps_CNAV_Navigation_Message
 #include <boost/circular_buffer.hpp>
-#include <boost/shared_ptr.hpp>  // for boost::shared_ptr
 #include <gnuradio/block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 #include <cstdint>
 #include <fstream>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>  // for std::shared_ptr
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 extern "C"
 {
@@ -39,7 +43,11 @@ extern "C"
 
 class gps_l5_telemetry_decoder_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using gps_l5_telemetry_decoder_gs_sptr = std::shared_ptr<gps_l5_telemetry_decoder_gs>;
+#else
 using gps_l5_telemetry_decoder_gs_sptr = boost::shared_ptr<gps_l5_telemetry_decoder_gs>;
+#endif
 
 gps_l5_telemetry_decoder_gs_sptr gps_l5_make_telemetry_decoder_gs(
     const Gnss_Satellite &satellite,

src/algorithms/telemetry_decoder/gnuradio_blocks/sbas_l1_telemetry_decoder_gs.h

@@ -21,24 +21,32 @@
 #define GNSS_SDR_SBAS_L1_TELEMETRY_DECODER_GS_H
 
 #include "gnss_satellite.h"
-#include <boost/crc.hpp>         // for crc_optimal
-#include <boost/shared_ptr.hpp>  // for boost::shared_ptr
+#include <boost/crc.hpp>  // for crc_optimal
 #include <gnuradio/block.h>
 #include <gnuradio/types.h>  // for gr_vector_const_void_star
 #include <cstddef>           // for size_t
 #include <cstdint>
 #include <deque>
 #include <fstream>
-#include <memory>
+#include <memory>  // for std::shared_ptr
 #include <string>
 #include <utility>  // for pair
 #include <vector>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>  // for std::shared_ptr
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Viterbi_Decoder;
 
 class sbas_l1_telemetry_decoder_gs;
 
+#if GNURADIO_USES_STD_POINTERS
+using sbas_l1_telemetry_decoder_gs_sptr = std::shared_ptr<sbas_l1_telemetry_decoder_gs>;
+#else
 using sbas_l1_telemetry_decoder_gs_sptr = boost::shared_ptr<sbas_l1_telemetry_decoder_gs>;
+#endif
 
 sbas_l1_telemetry_decoder_gs_sptr sbas_l1_make_telemetry_decoder_gs(
     const Gnss_Satellite &satellite,

src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt

@@ -92,6 +92,12 @@ target_link_libraries(tracking_gr_blocks
         Glog::glog
 )
 
+if(GNURADIO_USES_STD_POINTERS)
+    target_compile_definitions(tracking_gr_blocks
+        PUBLIC -DGNURADIO_USES_STD_POINTERS=1
+    )
+endif()
+
 if(ENABLE_CUDA AND NOT CMAKE_VERSION VERSION_GREATER 3.11)
     target_link_libraries(tracking_gr_blocks
         PUBLIC

src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.h

@@ -27,7 +27,6 @@
 #include "tracking_FLL_PLL_filter.h"  // for PLL/FLL filter
 #include "tracking_loop_filter.h"     // for DLL filter
 #include <boost/circular_buffer.hpp>
-#include <boost/shared_ptr.hpp>               // for boost::shared_ptr
 #include <gnuradio/block.h>                   // for block
 #include <gnuradio/gr_complex.h>              // for gr_complex
 #include <gnuradio/types.h>                   // for gr_vector_int, gr_vector...
@@ -37,11 +36,21 @@
 #include <fstream>                            // for string, ofstream
 #include <string>
 #include <utility>  // for pair
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Gnss_Synchro;
 class dll_pll_veml_tracking;
 
+#if GNURADIO_USES_STD_POINTERS
+using dll_pll_veml_tracking_sptr = std::shared_ptr<dll_pll_veml_tracking>;
+#else
 using dll_pll_veml_tracking_sptr = boost::shared_ptr<dll_pll_veml_tracking>;
+#endif
+
 
 dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(const Dll_Pll_Conf &conf_);
 

src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking_fpga.h

@@ -26,7 +26,6 @@
 #include "tracking_FLL_PLL_filter.h"  // for PLL/FLL filter
 #include "tracking_loop_filter.h"     // for DLL filter
 #include <boost/circular_buffer.hpp>
-#include <boost/shared_ptr.hpp>               // for boost::shared_ptr
 #include <gnuradio/block.h>                   // for block
 #include <gnuradio/gr_complex.h>              // for gr_complex
 #include <gnuradio/types.h>                   // for gr_vector_int, gr_vector...
@@ -34,15 +33,23 @@
 #include <volk_gnsssdr/volk_gnsssdr_alloc.h>  // for volk_gnsssdr::vector
 #include <cstdint>                            // for int32_t
 #include <fstream>                            // for string, ofstream
-#include <memory>
+#include <memory>                             // for std::shared_ptr
 #include <string>
 #include <utility>  // for pair
+#if GNURADIO_USES_STD_POINTERS
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Fpga_Multicorrelator_8sc;
 class Gnss_Synchro;
 class dll_pll_veml_tracking_fpga;
 
+#if GNURADIO_USES_STD_POINTERS
+using dll_pll_veml_tracking_fpga_sptr = std::shared_ptr<dll_pll_veml_tracking_fpga>;
+#else
 using dll_pll_veml_tracking_fpga_sptr = boost::shared_ptr<dll_pll_veml_tracking_fpga>;
+#endif
 
 dll_pll_veml_tracking_fpga_sptr dll_pll_veml_make_tracking_fpga(const Dll_Pll_Conf_Fpga &conf_);
 

src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.h

@@ -36,11 +36,20 @@
 #include <fstream>
 #include <map>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class Galileo_E1_Tcp_Connector_Tracking_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using galileo_e1_tcp_connector_tracking_cc_sptr = std::shared_ptr<Galileo_E1_Tcp_Connector_Tracking_cc>;
+#else
 using galileo_e1_tcp_connector_tracking_cc_sptr = boost::shared_ptr<Galileo_E1_Tcp_Connector_Tracking_cc>;
+#endif
 
 galileo_e1_tcp_connector_tracking_cc_sptr
 galileo_e1_tcp_connector_make_tracking_cc(

src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_c_aid_tracking_cc.h

@@ -40,11 +40,20 @@
 #include <fstream>
 #include <map>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 
 class glonass_l1_ca_dll_pll_c_aid_tracking_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using glonass_l1_ca_dll_pll_c_aid_tracking_cc_sptr = std::shared_ptr<glonass_l1_ca_dll_pll_c_aid_tracking_cc>;
+#else
 using glonass_l1_ca_dll_pll_c_aid_tracking_cc_sptr = boost::shared_ptr<glonass_l1_ca_dll_pll_c_aid_tracking_cc>;
+#endif
 
 glonass_l1_ca_dll_pll_c_aid_tracking_cc_sptr
 glonass_l1_ca_dll_pll_c_aid_make_tracking_cc(

src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_c_aid_tracking_sc.h

@@ -40,10 +40,19 @@
 #include <fstream>
 #include <map>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class glonass_l1_ca_dll_pll_c_aid_tracking_sc;
 
+#if GNURADIO_USES_STD_POINTERS
+using glonass_l1_ca_dll_pll_c_aid_tracking_sc_sptr = std::shared_ptr<glonass_l1_ca_dll_pll_c_aid_tracking_sc>;
+#else
 using glonass_l1_ca_dll_pll_c_aid_tracking_sc_sptr = boost::shared_ptr<glonass_l1_ca_dll_pll_c_aid_tracking_sc>;
+#endif
 
 glonass_l1_ca_dll_pll_c_aid_tracking_sc_sptr
 glonass_l1_ca_dll_pll_c_aid_make_tracking_sc(

src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_tracking_cc.h

@@ -37,10 +37,19 @@
 #include <fstream>
 #include <map>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Glonass_L1_Ca_Dll_Pll_Tracking_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using glonass_l1_ca_dll_pll_tracking_cc_sptr = std::shared_ptr<Glonass_L1_Ca_Dll_Pll_Tracking_cc>;
+#else
 using glonass_l1_ca_dll_pll_tracking_cc_sptr = boost::shared_ptr<Glonass_L1_Ca_Dll_Pll_Tracking_cc>;
+#endif
 
 glonass_l1_ca_dll_pll_tracking_cc_sptr
 glonass_l1_ca_dll_pll_make_tracking_cc(

src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_c_aid_tracking_cc.h

@@ -37,10 +37,19 @@
 #include <fstream>
 #include <map>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class glonass_l2_ca_dll_pll_c_aid_tracking_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using glonass_l2_ca_dll_pll_c_aid_tracking_cc_sptr = std::shared_ptr<glonass_l2_ca_dll_pll_c_aid_tracking_cc>;
+#else
 using glonass_l2_ca_dll_pll_c_aid_tracking_cc_sptr = boost::shared_ptr<glonass_l2_ca_dll_pll_c_aid_tracking_cc>;
+#endif
 
 glonass_l2_ca_dll_pll_c_aid_tracking_cc_sptr
 glonass_l2_ca_dll_pll_c_aid_make_tracking_cc(

src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_c_aid_tracking_sc.h

@@ -37,10 +37,20 @@
 #include <fstream>
 #include <map>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class glonass_l2_ca_dll_pll_c_aid_tracking_sc;
 
+#if GNURADIO_USES_STD_POINTERS
+using glonass_l2_ca_dll_pll_c_aid_tracking_sc_sptr = std::shared_ptr<glonass_l2_ca_dll_pll_c_aid_tracking_sc>;
+#else
 using glonass_l2_ca_dll_pll_c_aid_tracking_sc_sptr = boost::shared_ptr<glonass_l2_ca_dll_pll_c_aid_tracking_sc>;
+#endif
+
 
 glonass_l2_ca_dll_pll_c_aid_tracking_sc_sptr
 glonass_l2_ca_dll_pll_c_aid_make_tracking_sc(

src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_tracking_cc.h

@@ -35,10 +35,19 @@
 #include <fstream>
 #include <map>
 #include <string>
+#if GNURADIO_USES_STD_POINTERS
+#include <memory>
+#else
+#include <boost/shared_ptr.hpp>
+#endif
 
 class Glonass_L2_Ca_Dll_Pll_Tracking_cc;
 
+#if GNURADIO_USES_STD_POINTERS
+using glonass_l2_ca_dll_pll_tracking_cc_sptr = std::shared_ptr<Glonass_L2_Ca_Dll_Pll_Tracking_cc>;
+#else
 using glonass_l2_ca_dll_pll_tracking_cc_sptr = boost::shared_ptr<Glonass_L2_Ca_Dll_Pll_Tracking_cc>;
+#endif
 
 glonass_l2_ca_dll_pll_tracking_cc_sptr
 glonass_l2_ca_dll_pll_make_tracking_cc(

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_gpu_cc.h

@@ -38,7 +38,7 @@
 
 class Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc;
 
-typedef boost::shared_ptr<Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc>
+typedef std::shared_ptr<Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc>
     gps_l1_ca_dll_pll_tracking_gpu_cc_sptr;
 
 gps_l1_ca_dll_pll_tracking_gpu_cc_sptr