mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-05-04 16:34:12 +00:00
Code Issues Releases Wiki Activity

Improve handling of the filesystem library

Browse Source
This commit is contained in:
Carles Fernandez 2021-01-16 14:37:19 +01:00
parent 0e9046c956
commit 1287e8fe79
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
49 changed files with 108 additions and 775 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/changelog.md
View File

@ -24,6 +24,7 @@ SPDX-FileCopyrightText: 2011-2021 Carles Fernandez-Prades <carles.fernandez@cttc
### Improvements in Maintainability:
- Improved handling of change in GNU Radio 3.9 FFT API.
- Improved handling of the filesystem library.
&nbsp;

10
src/algorithms/PVT/gnuradio_blocks/CMakeLists.txt
View File

@ -18,16 +18,6 @@ else()
add_library(pvt_gr_blocks rtklib_pvt_gs.cc rtklib_pvt_gs.h)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(pvt_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(pvt_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(pvt_gr_blocks PRIVATE std::filesystem)
else()
target_link_libraries(pvt_gr_blocks PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(pvt_gr_blocks
PUBLIC
algorithms_libs_rtklib

18
src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_gs.cc
View File

@ -32,6 +32,7 @@
#include "glonass_gnav_utc_model.h"
#include "gnss_frequencies.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_make_unique.h"
#include "gps_almanac.h"
#include "gps_cnav_ephemeris.h"
@ -79,23 +80,6 @@
#include <boost/bind/bind.hpp>
#endif
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/path.hpp>
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
#if USE_OLD_BOOST_MATH_COMMON_FACTOR
#include <boost/math/common_factor_rt.hpp>
namespace bc = boost::math;

11
src/algorithms/PVT/libs/CMakeLists.txt
View File

@ -54,16 +54,6 @@ else()
add_library(pvt_libs ${PVT_LIB_SOURCES} ${PROTO_SRCS} ${PVT_LIB_HEADERS} ${PROTO_HDRS})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(pvt_libs PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(pvt_libs PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(pvt_libs PRIVATE std::filesystem)
else()
target_link_libraries(pvt_libs PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(pvt_libs
PUBLIC
Boost::date_time
@ -71,6 +61,7 @@ target_link_libraries(pvt_libs
core_system_parameters
algorithms_libs_rtklib
PRIVATE
algorithms_libs
Gflags::gflags
Glog::glog
Matio::matio

21
src/algorithms/PVT/libs/geojson_printer.cc
View File

@ -17,6 +17,7 @@
#include "geojson_printer.h"
#include "gnss_sdr_filesystem.h"
#include "pvt_solution.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
@ -26,26 +27,6 @@
#include <iostream> // for cout, cerr
#include <sstream> // for stringstream
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
GeoJSON_Printer::GeoJSON_Printer(const std::string& base_path)
{

22
src/algorithms/PVT/libs/gpx_printer.cc
View File

@ -17,6 +17,7 @@
#include "gpx_printer.h"
#include "gnss_sdr_filesystem.h"
#include "pvt_solution.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
@ -26,27 +27,6 @@
#include <iostream> // for cout, cerr
#include <sstream> // for stringstream
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Gpx_Printer::Gpx_Printer(const std::string& base_path)
{

22
src/algorithms/PVT/libs/kml_printer.cc
View File

@ -17,6 +17,7 @@
*/
#include "kml_printer.h"
#include "gnss_sdr_filesystem.h"
#include "pvt_solution.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
@ -28,27 +29,6 @@
#include <sys/stat.h> // for S_IXUSR | S_IRWXG | S_IRWXO
#include <sys/types.h> // for mode_t
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Kml_Printer::Kml_Printer(const std::string& base_path)
{

22
src/algorithms/PVT/libs/nmea_printer.cc
View File

@ -20,6 +20,7 @@
*/
#include "nmea_printer.h"
#include "gnss_sdr_filesystem.h"
#include "rtklib_solution.h"
#include "rtklib_solver.h"
#include <glog/logging.h>
@ -31,27 +32,6 @@
#include <termios.h>
#include <utility>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Nmea_Printer::Nmea_Printer(const std::string& filename, bool flag_nmea_output_file, bool flag_nmea_tty_port, std::string nmea_dump_devname, const std::string& base_path)
{

22
src/algorithms/PVT/libs/rinex_printer.cc
View File

@ -29,6 +29,7 @@
#include "glonass_gnav_almanac.h"
#include "glonass_gnav_ephemeris.h"
#include "glonass_gnav_utc_model.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#include "gps_cnav_ephemeris.h"
#include "gps_cnav_iono.h"
@ -54,27 +55,6 @@
#include <utility>
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Rinex_Printer::Rinex_Printer(int32_t conf_version, const std::string& base_path, const std::string& base_name)
{

22
src/algorithms/PVT/libs/rtcm_printer.cc
View File

@ -21,6 +21,7 @@
#include "galileo_ephemeris.h"
#include "glonass_gnav_ephemeris.h"
#include "glonass_gnav_utc_model.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_make_unique.h"
#include "gnss_synchro.h"
#include "gps_cnav_ephemeris.h"
@ -36,27 +37,6 @@
#include <termios.h> // for tcgetattr
#include <unistd.h> // for close, write
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format off
Rtcm_Printer::Rtcm_Printer(const std::string& filename, bool flag_rtcm_file_dump, bool flag_rtcm_server, bool flag_rtcm_tty_port, uint16_t rtcm_tcp_port, uint16_t rtcm_station_id, const std::string& rtcm_dump_devname, bool time_tag_name, const std::string& base_path)
{

22
src/algorithms/PVT/libs/rtklib_solver.cc
View File

@ -32,6 +32,7 @@
#include "rtklib_solver.h"
#include "Beidou_DNAV.h"
#include "gnss_sdr_filesystem.h"
#include "rtklib_conversions.h"
#include "rtklib_rtkpos.h"
#include "rtklib_solution.h"
@ -41,27 +42,6 @@
#include <utility>
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Rtklib_Solver::Rtklib_Solver(const rtk_t &rtk, int nchannels, const std::string &dump_filename, bool flag_dump_to_file, bool flag_dump_to_mat)
{

10
src/algorithms/acquisition/gnuradio_blocks/CMakeLists.txt
View File

@ -53,16 +53,6 @@ else()
add_library(acquisition_gr_blocks ${ACQ_GR_BLOCKS_SOURCES} ${ACQ_GR_BLOCKS_HEADERS})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(acquisition_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(acquisition_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(acquisition_gr_blocks PRIVATE std::filesystem)
else()
target_link_libraries(acquisition_gr_blocks PRIVATE Boost::filesystem)
endif()
target_link_libraries(acquisition_gr_blocks
PUBLIC
algorithms_libs

20
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc
View File

@ -24,16 +24,8 @@
#include "MATH_CONSTANTS.h" // for TWO_PI
#include "gnss_frequencies.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
#else
#include <filesystem>
#endif
#else
#include <boost/filesystem/path.hpp>
#endif
#include <boost/math/special_functions/gamma.hpp>
#include <gnuradio/io_signature.h>
#include <matio.h>
@ -48,16 +40,6 @@
#include <iostream>
#include <map>
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
namespace fs = std::experimental::filesystem;
#else
namespace fs = std::filesystem;
#endif
#else
namespace fs = boost::filesystem;
#endif
pcps_acquisition_sptr pcps_make_acquisition(const Acq_Conf& conf_)
{

20
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.cc
View File

@ -19,16 +19,8 @@
#include "pcps_acquisition_fine_doppler_cc.h"
#include "GPS_L1_CA.h" // for GPS_L1_CA_CHIP_PERIOD_S
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gps_sdr_signal_replica.h"
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
#else
#include <filesystem>
#endif
#else
#include <boost/filesystem/path.hpp>
#endif
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h>
@ -38,16 +30,6 @@
#include <sstream>
#include <vector>
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
namespace fs = std::experimental::filesystem;
#else
namespace fs = std::filesystem;
#endif
#else
namespace fs = boost::filesystem;
#endif
pcps_acquisition_fine_doppler_cc_sptr pcps_make_acquisition_fine_doppler_cc(const Acq_Conf &conf_)
{

27
src/algorithms/libs/CMakeLists.txt
View File

@ -54,6 +54,7 @@ set(GNSS_SPLIBS_HEADERS
cshort_to_float_x2.h
gnss_sdr_create_directory.h
gnss_sdr_fft.h
gnss_sdr_filesystem.h
gnss_sdr_make_unique.h
gnss_circular_deque.h
geofunctions.h
@ -86,16 +87,6 @@ else()
add_library(algorithms_libs ${GNSS_SPLIBS_SOURCES} ${GNSS_SPLIBS_HEADERS})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(algorithms_libs PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(algorithms_libs PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(algorithms_libs PRIVATE std::filesystem)
else()
target_link_libraries(algorithms_libs PRIVATE Boost::filesystem Boost::system)
endif()
if(NOT has_span)
target_include_directories(algorithms_libs
PUBLIC
@ -124,6 +115,16 @@ if(GNURADIO_USES_STD_POINTERS)
)
endif()
if(FILESYSTEM_FOUND)
target_compile_definitions(algorithms_libs PUBLIC -DHAS_STD_FILESYSTEM=1)
if(find_experimental)
target_compile_definitions(algorithms_libs PUBLIC -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(algorithms_libs PUBLIC std::filesystem)
else()
target_link_libraries(algorithms_libs PUBLIC Boost::filesystem Boost::system)
endif()
if(has_span)
target_compile_definitions(algorithms_libs
PUBLIC -DHAS_STD_SPAN=1
@ -193,14 +194,14 @@ else()
add_library(gnss_sdr_flags gnss_sdr_flags.cc gnss_sdr_flags.h)
endif()
if(${FILESYSTEM_FOUND})
if(FILESYSTEM_FOUND)
target_compile_definitions(gnss_sdr_flags PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
if(find_experimental)
target_compile_definitions(gnss_sdr_flags PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gnss_sdr_flags PRIVATE std::filesystem)
else()
target_link_libraries(gnss_sdr_flags PRIVATE Boost::filesystem)
target_link_libraries(gnss_sdr_flags PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(gnss_sdr_flags

22
src/algorithms/libs/gnss_sdr_create_directory.cc
View File

@ -16,30 +16,10 @@
*/
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include <exception> // for exception
#include <fstream> // for ofstream
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
bool gnss_sdr_create_directory(const std::string& foldername)
{
std::string new_folder;

43
src/algorithms/libs/gnss_sdr_filesystem.h Normal file
View File

@ -0,0 +1,43 @@
/*!
* \file gnss_sdr_filesystem.h
* \brief Helper file for fylesystem library interface
* \author Carles Fernandez Prades, 2021. cfernandez(at)cttc.es
*
* -----------------------------------------------------------------------------
*
* GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
* This file is part of GNSS-SDR.
*
* Copyright (C) 2010-2021 (see AUTHORS file for a list of contributors)
* SPDX-License-Identifier: GPL-3.0-or-later
*
* -----------------------------------------------------------------------------
*/
#ifndef GNSS_SDR_GNSS_SDR_FILESYSTEM_H
#define GNSS_SDR_GNSS_SDR_FILESYSTEM_H
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
#endif // GNSS_SDR_GNSS_SDR_FILESYSTEM_H

14
src/algorithms/libs/gnss_sdr_flags.cc
View File

@ -17,22 +17,10 @@
#include "gnss_sdr_flags.h"
#include "gnss_sdr_filesystem.h"
#include <iostream>
#include <string>
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for exists
namespace fs = boost::filesystem;
#endif
DEFINE_string(c, "-", "Path to the configuration file (if set, overrides --config_file).");

10
src/algorithms/observables/gnuradio_blocks/CMakeLists.txt
View File

@ -18,16 +18,6 @@ else()
add_library(obs_gr_blocks hybrid_observables_gs.cc hybrid_observables_gs.h)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(obs_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(obs_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(obs_gr_blocks PRIVATE std::filesystem)
else()
target_link_libraries(obs_gr_blocks PRIVATE Boost::filesystem)
endif()
target_include_directories(obs_gr_blocks
PUBLIC
${CMAKE_SOURCE_DIR}/src/algorithms/libs

22
src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.cc
View File

@ -20,6 +20,7 @@
#include "gnss_circular_deque.h"
#include "gnss_frequencies.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_make_unique.h"
#include "gnss_synchro.h"
#include <glog/logging.h>
@ -38,27 +39,6 @@
#include <boost/bind/bind.hpp>
#endif
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
hybrid_observables_gs_sptr hybrid_observables_gs_make(const Obs_Conf &conf_)
{

11
src/algorithms/telemetry_decoder/libs/CMakeLists.txt
View File

@ -43,21 +43,12 @@ target_link_libraries(telemetry_decoder_libs
PUBLIC
Volkgnsssdr::volkgnsssdr
PRIVATE
algorithms_libs
Gflags::gflags
Glog::glog
Matio::matio
)
if(FILESYSTEM_FOUND)
target_compile_definitions(telemetry_decoder_libs PRIVATE -DHAS_STD_FILESYSTEM=1)
if(find_experimental)
target_compile_definitions(telemetry_decoder_libs PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(telemetry_decoder_libs PRIVATE std::filesystem)
else()
target_link_libraries(telemetry_decoder_libs PRIVATE Boost::filesystem Boost::system)
endif()
target_include_directories(telemetry_decoder_libs
PUBLIC
${CMAKE_SOURCE_DIR}/src/core/interfaces

21
src/algorithms/telemetry_decoder/libs/tlm_utils.cc
View File

@ -15,6 +15,7 @@
*/
#include "tlm_utils.h"
#include "gnss_sdr_filesystem.h"
#include <matio.h>
#include <array>
#include <cstdint>
@ -22,26 +23,6 @@
#include <iostream>
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for remove
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
int save_tlm_matfile(const std::string &dumpfile)
{

11
src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt
View File

@ -75,21 +75,12 @@ else()
)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(tracking_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(tracking_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(tracking_gr_blocks PRIVATE std::filesystem)
else()
target_link_libraries(tracking_gr_blocks PRIVATE Boost::filesystem)
endif()
target_link_libraries(tracking_gr_blocks
PUBLIC
Gnuradio::blocks
tracking_libs
PRIVATE
algorithms_libs
Matio::matio
gnss_sdr_flags
Glog::glog

14
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc
View File

@ -38,6 +38,7 @@
#include "galileo_e6_signal_replica.h"
#include "gnss_satellite.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#include "gps_l2c_signal_replica.h"
#include "gps_l5_signal_replica.h"
@ -64,19 +65,6 @@
#include <boost/bind/bind.hpp>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/path.hpp>
namespace fs = boost::filesystem;
#endif
dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(const Dll_Pll_Conf &conf_)
{

13
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking_fpga.cc
View File

@ -30,6 +30,7 @@
#include "fpga_multicorrelator.h"
#include "gnss_satellite.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#include "gps_sdr_signal_replica.h"
#include "lock_detectors.h"
@ -53,18 +54,6 @@
#include <boost/bind/bind.hpp>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/path.hpp>
namespace fs = boost::filesystem;
#endif
dll_pll_veml_tracking_fpga_sptr dll_pll_veml_make_tracking_fpga(const Dll_Pll_Conf_Fpga &conf_)
{

10
src/core/libs/CMakeLists.txt
View File

@ -123,15 +123,7 @@ if(USE_BOOST_BIND_PLACEHOLDERS)
endif()
if(ENABLE_FPGA OR ENABLE_AD9361)
if(FILESYSTEM_FOUND)
target_compile_definitions(core_libs PRIVATE -DHAS_STD_FILESYSTEM=1)
if(find_experimental)
target_compile_definitions(core_libs PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(core_libs PRIVATE std::filesystem)
else()
target_link_libraries(core_libs PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(core_libs PRIVATE algorithms_libs)
endif()
if(ENABLE_CLANG_TIDY)

14
src/core/libs/uio_fpga.cc
View File

@ -16,6 +16,7 @@
*/
#include "uio_fpga.h"
#include "gnss_sdr_filesystem.h"
#include <algorithm> // sort
#include <cstdlib> // atoi, size_t
#include <fstream> // ifstream
@ -24,19 +25,6 @@
#include <sstream> // std::stringstream
#include <vector>
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
#include <boost/filesystem/path.hpp>
namespace fs = boost::filesystem;
#endif
int32_t get_uio_num(std::string uio_name)
{

11
src/main/CMakeLists.txt
View File

@ -12,17 +12,6 @@ else()
add_executable(gnss-sdr main.cc)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(gnss-sdr PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(gnss-sdr PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gnss-sdr PRIVATE std::filesystem)
else()
target_link_libraries(gnss-sdr PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(gnss-sdr
PRIVATE
algorithms_libs

22
src/main/main.cc
View File

@ -28,6 +28,7 @@
#include "concurrent_map.h"
#include "concurrent_queue.h"
#include "control_thread.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_make_unique.h"
#include "gps_acq_assist.h"
#include <boost/exception/diagnostic_information.hpp> // for diagnostic_information
@ -46,27 +47,6 @@
#include <cuda_runtime.h>
#endif
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
#if GFLAGS_OLD_NAMESPACE
namespace gflags
{

97
src/tests/CMakeLists.txt
View File

@ -483,15 +483,6 @@ if(ENABLE_UNIT_TESTING)
else()
add_executable(run_tests ${CMAKE_CURRENT_SOURCE_DIR}/test_main.cc)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(run_tests PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(run_tests PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(run_tests PRIVATE std::filesystem)
else()
target_link_libraries(run_tests PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(run_tests
PRIVATE
@ -615,15 +606,7 @@ if(ENABLE_FPGA)
else()
add_executable(gps_l1_ca_dll_pll_tracking_test_fpga ${GPS_L1_CA_DLL_PLL_TRACKING_TEST_FPGA_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(gps_l1_ca_dll_pll_tracking_test_fpga PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(gps_l1_ca_dll_pll_tracking_test_fpga PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gps_l1_ca_dll_pll_tracking_test_fpga PRIVATE std::filesystem)
else()
target_link_libraries(gps_l1_ca_dll_pll_tracking_test_fpga PRIVATE Boost::filesystem Boost::system)
endif()
if(USE_GENERIC_LAMBDAS)
set(has_generic_lambdas HAS_GENERIC_LAMBDA=1)
set(no_has_generic_lambdas HAS_GENERIC_LAMBDA=0)
@ -697,18 +680,8 @@ function(add_system_test executable)
else()
add_executable(${executable} ${SYSTEM_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(${executable} PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(${executable} PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(${executable} PRIVATE std::filesystem)
else()
target_link_libraries(${executable} PRIVATE Boost::filesystem Boost::system)
endif()
target_include_directories(${executable}
PRIVATE ${OPT_INCLUDES_} ${CMAKE_SOURCE_DIR}/src/algorithms/libs
PRIVATE ${OPT_INCLUDES_}
INTERFACE ${CMAKE_SOURCE_DIR}/src/tests/common-files
)
target_link_libraries(${executable} PRIVATE ${OPT_LIBS_} algorithms_libs)
@ -824,15 +797,7 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(flowgraph_test ${FLOWGRAPH_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(flowgraph_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(flowgraph_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(flowgraph_test PRIVATE std::filesystem)
else()
target_link_libraries(flowgraph_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(flowgraph_test
PRIVATE
Boost::thread
@ -879,15 +844,7 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(gnss_block_test ${GNSS_BLOCK_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(gnss_block_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(gnss_block_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gnss_block_test PRIVATE std::filesystem)
else()
target_link_libraries(gnss_block_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(gnss_block_test
PRIVATE
Boost::thread
@ -935,15 +892,7 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(gnuradio_block_test ${GNURADIO_BLOCK_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(gnuradio_block_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(gnuradio_block_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gnuradio_block_test PRIVATE std::filesystem)
else()
target_link_libraries(gnuradio_block_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(gnuradio_block_test
PRIVATE
Boost::thread
@ -980,18 +929,9 @@ else()
add_executable(matio_test ${MATIO_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(matio_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(matio_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(matio_test PRIVATE std::filesystem)
else()
target_link_libraries(matio_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(matio_test
PRIVATE
algorithms_libs
Gflags::gflags
Glog::glog
GTest::GTest
@ -1022,12 +962,7 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(acq_test ${ACQ_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(acq_test PRIVATE -DHAS_STD_FILESYSTEM=1)
target_link_libraries(acq_test PRIVATE std::filesystem)
else()
target_link_libraries(acq_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(acq_test
PRIVATE
Boost::thread
@ -1101,15 +1036,6 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(trk_test ${TRKTEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(trk_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(trk_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(trk_test PRIVATE std::filesystem)
else()
target_link_libraries(trk_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(trk_test
PRIVATE
@ -1169,15 +1095,6 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(control_thread_test ${CONTROL_THREAD_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(control_thread_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(control_thread_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(control_thread_test PRIVATE std::filesystem)
else()
target_link_libraries(control_thread_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(control_thread_test
PRIVATE

9
src/tests/system-tests/position_test.cc
View File

@ -25,6 +25,7 @@
#include "control_thread.h"
#include "file_configuration.h"
#include "geofunctions.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_flags.h"
#include "gnuplot_i.h"
#include "in_memory_configuration.h"
@ -46,14 +47,6 @@
#include <numeric>
#include <thread>
#if HAS_STD_FILESYSTEM
#include <filesystem>
namespace fs = std::filesystem;
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
#if GFLAGS_OLD_NAMESPACE
namespace gflags
{

13
src/tests/unit-tests/arithmetic/fft_length_test.cc
View File

@ -16,6 +16,7 @@
*/
#include "gnss_sdr_fft.h"
#include "gnss_sdr_filesystem.h"
#include "gnuplot_i.h"
#include "test_flags.h"
#include <algorithm>
@ -23,18 +24,6 @@
#include <functional>
#include <random>
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
DEFINE_int32(fft_iterations_test, 1000, "Number of averaged iterations in FFT length timing test");
DEFINE_bool(plot_fft_length_test, false, "Plots results of FFTLengthTest with gnuplot");

22
src/tests/unit-tests/arithmetic/matio_test.cc
View File

@ -16,32 +16,12 @@
* -----------------------------------------------------------------------------
*/
#include "gnss_sdr_filesystem.h"
#include <gnuradio/gr_complex.h>
#include <gtest/gtest.h>
#include <matio.h>
#include <array>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
TEST(MatioTest, WriteAndReadDoubles)
{
// Write a .mat file

18
src/tests/unit-tests/signal-processing-blocks/acquisition/acq_performance_test.cc
View File

@ -24,6 +24,7 @@
#include "glonass_l1_ca_pcps_acquisition.h"
#include "glonass_l2_ca_pcps_acquisition.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_valve.h"
#include "gnuplot_i.h"
#include "gps_l1_ca_pcps_acquisition.h"
@ -48,23 +49,6 @@
#include <boost/bind/bind.hpp>
#endif
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
DEFINE_string(config_file_ptest, std::string(""), "File containing alternative configuration parameters for the acquisition performance test.");
DEFINE_string(acq_test_input_file, std::string(""), "File containing raw signal data, must be in int8_t format. The signal generator will not be used.");

13
src/tests/unit-tests/signal-processing-blocks/acquisition/beidou_b1i_pcps_acquisition_test.cc
View File

@ -22,6 +22,7 @@
#include "beidou_b1i_pcps_acquisition.h"
#include "concurrent_queue.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gnuplot_i.h"
@ -49,18 +50,6 @@
#include <gnuradio/analog/sig_source_c.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
// ######## GNURADIO BLOCK MESSAGE RECEVER #########
class BeidouB1iPcpsAcquisitionTest_msg_rx;

13
src/tests/unit-tests/signal-processing-blocks/acquisition/beidou_b3i_pcps_acquisition_test.cc
View File

@ -22,6 +22,7 @@
#include "beidou_b3i_pcps_acquisition.h"
#include "concurrent_queue.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gnuplot_i.h"
@ -49,18 +50,6 @@
#include <gnuradio/analog/sig_source_c.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
// ######## GNURADIO BLOCK MESSAGE RECEVER #########
class BeidouB3iPcpsAcquisitionTest_msg_rx;

14
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_test.cc
View File

@ -23,6 +23,7 @@
#include "galileo_e1_pcps_ambiguous_acquisition.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_valve.h"
#include "gnss_signal.h"
#include "gnss_synchro.h"
@ -51,19 +52,6 @@
#include <gnuradio/analog/sig_source_c.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
// ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx;

18
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_test_fpga.cc
View File

@ -1,7 +1,6 @@
/*!
* \file gps_l1_ca_pcps_acquisition_test_fpga.cc
* \brief This class implements an acquisition test for
* GpsL1CaPcpsAcquisitionFpga class based on some input parameters.
* \file galileo_e1_pcps_acquisition_test_fpga.cc
* \brief This class implements an acquisition test Galileo FPFA acquisition
* \authors <ul>
* <li> Marc Majoral, 2019. mmajoral(at)cttc.cat
* <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
@ -24,6 +23,7 @@
#include "fpga_switch.h"
#include "galileo_e1_pcps_ambiguous_acquisition_fpga.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_signal.h"
#include "gnss_synchro.h"
#include "in_memory_configuration.h"
@ -44,18 +44,6 @@
#include <gnuradio/analog/sig_source_c.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
struct DMA_handler_args_galileo_e1_pcps_ambiguous_acq_test
{

14
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test.cc
View File

@ -21,6 +21,7 @@
#include "acquisition_dump_reader.h"
#include "concurrent_queue.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gnuplot_i.h"
@ -48,19 +49,6 @@
#include <gnuradio/analog/sig_source_c.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
// ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GpsL1CaPcpsAcquisitionTest_msg_rx;

13
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test_fpga.cc
View File

@ -23,6 +23,7 @@
#include "concurrent_queue.h"
#include "fpga_switch.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#include "gps_l1_ca_pcps_acquisition_fpga.h"
#include "in_memory_configuration.h"
@ -42,18 +43,6 @@
#include <gnuradio/analog/sig_source_c.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
struct DMA_handler_args_gps_l1_acq_test
{

14
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l2_m_pcps_acquisition_test.cc
View File

@ -21,6 +21,7 @@
#include "acquisition_dump_reader.h"
#include "concurrent_queue.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gnuplot_i.h"
@ -49,19 +50,6 @@
#include <gnuradio/analog/sig_source_c.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
// ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GpsL2MPcpsAcquisitionTest_msg_rx;

21
src/tests/unit-tests/signal-processing-blocks/pvt/nmea_printer_test.cc
View File

@ -15,32 +15,13 @@
*/
#include "gnss_sdr_filesystem.h"
#include "nmea_printer.h"
#include "rtklib_rtkpos.h"
#include "rtklib_solver.h"
#include <fstream>
#include <string>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
class NmeaPrinterTest : public ::testing::Test
{

21
src/tests/unit-tests/signal-processing-blocks/pvt/rinex_printer_test.cc
View File

@ -14,32 +14,13 @@
* -----------------------------------------------------------------------------
*/
#include "gnss_sdr_filesystem.h"
#include "rinex_printer.h"
#include "rtklib_rtkpos.h"
#include "rtklib_solver.h"
#include <fstream>
#include <string>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for create_directories, exists
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
class RinexPrinterTest : public ::testing::Test
{

14
src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc
View File

@ -19,6 +19,7 @@
#include "GPS_L1_CA.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnuplot_i.h"
#include "in_memory_configuration.h"
#include "signal_generator_flags.h"
@ -52,19 +53,6 @@
#include <gnuradio/analog/sig_source_c.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
// ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GpsL1CADllPllTrackingTest_msg_rx;

13
src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_kf_tracking_test.cc
View File

@ -19,6 +19,7 @@
#include "GPS_L1_CA.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_flags.h"
#include "gnuplot_i.h"
#include "in_memory_configuration.h"
@ -51,18 +52,6 @@
#include <gnuradio/analog/sig_source_c.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
DEFINE_bool(plot_gps_l1_kf_tracking_test, false, "Plots results of GpsL1CAKfTrackingTest with gnuplot");

14
src/tests/unit-tests/signal-processing-blocks/tracking/tracking_pull-in_test.cc
View File

@ -28,6 +28,7 @@
#include "galileo_e5a_pcps_acquisition.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_valve.h"
#include "gnuplot_i.h"
#include "gps_l1_ca_pcps_acquisition.h"
@ -67,19 +68,6 @@
#include <gnuradio/filter/fir_filter_ccf.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
// ######## GNURADIO TRACKING BLOCK MESSAGE RECEVER #########
class TrackingPullInTest_msg_rx;

14
src/tests/unit-tests/signal-processing-blocks/tracking/tracking_pull-in_test_fpga.cc
View File

@ -29,6 +29,7 @@
#include "galileo_e5a_pcps_acquisition_fpga.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_filesystem.h"
#include "gnuplot_i.h"
#include "gps_l1_ca_pcps_acquisition_fpga.h"
#include "gps_l5i_pcps_acquisition_fpga.h"
@ -66,19 +67,6 @@
#include <gnuradio/filter/fir_filter_ccf.h>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
// ######## GNURADIO TRACKING BLOCK MESSAGE RECEVER #########
class TrackingPullInTest_msg_rx_Fpga;

11
src/utils/front-end-cal/CMakeLists.txt
View File

@ -52,19 +52,10 @@ else()
add_executable(front-end-cal main.cc)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(front-end-cal PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(front-end-cal PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(front-end-cal PRIVATE std::filesystem)
else()
target_link_libraries(front-end-cal PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(front-end-cal
PRIVATE
core_receiver
algorithms_libs
front_end_cal_lib
gnss_sdr_flags
Boost::headers

9
src/utils/front-end-cal/main.cc
View File

@ -27,6 +27,7 @@
#include "front_end_cal.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h" // for GNSSBlockInte...
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_flags.h"
#include "gnss_synchro.h"
#include "gps_acq_assist.h" // for Gps_Acq_Assist
@ -72,14 +73,6 @@
#include <boost/bind/bind.hpp>
#endif
#if HAS_STD_FILESYSTEM
#include <filesystem>
namespace fs = std::filesystem;
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
#if GFLAGS_OLD_NAMESPACE
namespace gflags
{