mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-04 15:30:01 +00:00
Code Issues Releases Wiki Activity

Soft transition from Gflags and Glog to Abseil. Some CI fixes

Browse Source
This commit is contained in:
Carles Fernandez 2024-04-29 08:27:33 +02:00
parent 4910629a5d
commit 95596b8f91
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
289 changed files with 5930 additions and 952 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.clang-tidy
View File

@ -120,7 +120,6 @@ Checks: '-*,
readability-uppercase-literal-suffix' readability-uppercase-literal-suffix'
WarningsAsErrors: '' WarningsAsErrors: ''
HeaderFilterRegex: '' HeaderFilterRegex: ''
AnalyzeTemporaryDtors: false
FormatStyle: 'file' FormatStyle: 'file'
CheckOptions: CheckOptions:
- key: performance-unnecessary-copy-initialization.ExcludedContainerTypes - key: performance-unnecessary-copy-initialization.ExcludedContainerTypes

31
.github/workflows/main.yml vendored
View File

@ -57,8 +57,7 @@ jobs:
rm /usr/local/bin/python3.1* || true rm /usr/local/bin/python3.1* || true
export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1
brew link --overwrite python@3.12 brew link --overwrite python@3.12
brew install ninja hdf5 automake armadillo lapack libmatio \ brew install ninja hdf5 automake armadillo lapack libmatio gnuradio openssl pugixml protobuf
gflags glog gnuradio log4cpp openssl pugixml protobuf
pip3 install mako pip3 install mako
- name: configure - name: configure
run: cd build && cmake -GNinja .. run: cd build && cmake -GNinja ..
@ -90,8 +89,7 @@ jobs:
rm /usr/local/bin/python3.1* || true rm /usr/local/bin/python3.1* || true
export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1
brew link --overwrite python@3.12 brew link --overwrite python@3.12
brew install ninja pkg-config hdf5 automake armadillo lapack libmatio \ brew install ninja pkg-config hdf5 automake armadillo lapack libmatio gnuradio openssl pugixml protobuf
gflags glog gnuradio log4cpp openssl pugixml protobuf
pip3 install mako pip3 install mako
- name: configure - name: configure
run: cd build && cmake -GXcode .. run: cd build && cmake -GXcode ..
@ -142,16 +140,15 @@ jobs:
rm /usr/local/bin/python3.1* || true rm /usr/local/bin/python3.1* || true
export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1
brew link --overwrite python@3.12 brew link --overwrite python@3.12
brew install ninja pkg-config hdf5 automake armadillo lapack libmatio \ brew install ninja pkg-config hdf5 automake armadillo lapack libmatio gnuradio openssl pugixml protobuf llvm
gflags glog gnuradio log4cpp openssl pugixml protobuf llvm pip3 install mako
pip3 install mako
ln -s $(brew --prefix llvm)/bin/clang-tidy /usr/local/bin ln -s $(brew --prefix llvm)/bin/clang-tidy /usr/local/bin
ln -s $(brew --prefix llvm)/bin/clang-apply-replacements /usr/local/bin ln -s $(brew --prefix llvm)/bin/clang-apply-replacements /usr/local/bin
ln -s $(brew --prefix llvm)/bin/run-clang-tidy.py /usr/local/bin ln -s $(brew --prefix llvm)/bin/run-clang-tidy.py /usr/local/bin
- name: Prepare run - name: Prepare run
run: cd build && cmake .. && make volk_gnsssdr_module gtest-1.14.0 core_monitor core_libs pvt_libs run: cd build && cmake .. && make volk_gnsssdr_module gtest-1.14.0 core_monitor core_libs pvt_libs
- name: run clang-tidy - name: run clang-tidy
run: cd build && /usr/local/opt/llvm/bin/run-clang-tidy -fix run: cd build && /opt/homebrew/opt/llvm/bin/run-clang-tidy -fix
- name: check - name: check
run: | run: |
git diff > clang_tidy.patch git diff > clang_tidy.patch
@ -243,8 +240,13 @@ jobs:
runs-on: macos-latest runs-on: macos-latest
steps: steps:
- uses: actions/checkout@v4 - uses: actions/checkout@v4
- name: install dependencies - uses: actions/setup-python@v5
run: pip3 install mako with:
python-version: '3.12'
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install mako
- name: configure - name: configure
run: cd build && cmake ../src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr run: cd build && cmake ../src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr
- name: build - name: build
@ -256,8 +258,13 @@ jobs:
runs-on: macos-latest runs-on: macos-latest
steps: steps:
- uses: actions/checkout@v4 - uses: actions/checkout@v4
- name: install dependencies - uses: actions/setup-python@v5
run: pip3 install mako with:
python-version: '3.12'
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install mako
- name: configure - name: configure
run: cd build && cmake -GXcode ../src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr run: cd build && cmake -GXcode ../src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr
- name: build - name: build

873
CMakeLists.txt
View File

@ -74,9 +74,20 @@ option(ENABLE_PACKAGING "Enable software packaging" OFF)
option(ENABLE_OWN_GLOG "Download glog and link it to gflags" OFF) option(ENABLE_OWN_GLOG "Download glog and link it to gflags" OFF)
option(ENABLE_GLOG_AND_GFLAGS "Force using Google glog and Gflags instead of Abseil" OFF)
option(ENABLE_OWN_ABSEIL "Forces downloading and building of Abseil" OFF)
if(CMAKE_VERSION VERSION_LESS 3.24)
set(ENABLE_OWN_ABSEIL OFF)
endif()
if(ENABLE_OWN_ABSEIL)
set(ENABLE_OWN_GLOG OFF)
set(ENABLE_GLOG_AND_GFLAGS OFF)
endif()
option(ENABLE_OWN_ARMADILLO "Download and build Armadillo locally" OFF) option(ENABLE_OWN_ARMADILLO "Download and build Armadillo locally" OFF)
option(ENABLE_LOG "Enable logging" ON) option(ENABLE_LOG "Enable internal logging" ON)
option(ENABLE_ARMA_NO_DEBUG OFF) option(ENABLE_ARMA_NO_DEBUG OFF)
@ -329,6 +340,7 @@ set(GNSSSDR_MATIO_MIN_VERSION "1.5.3")
set(GNSSSDR_PROTOBUF_MIN_VERSION "3.0.0") set(GNSSSDR_PROTOBUF_MIN_VERSION "3.0.0")
set(GNSSSDR_PYTHON_MIN_VERSION "2.7") set(GNSSSDR_PYTHON_MIN_VERSION "2.7")
set(GNSSSDR_PYTHON3_MIN_VERSION "3.4") set(GNSSSDR_PYTHON3_MIN_VERSION "3.4")
set(GNSSSDR_ABSEIL_MIN_VERSION "20240116")
@ -1157,7 +1169,7 @@ if(NOT VOLKGNSSSDR_FOUND)
if(CMAKE_GENERATOR STREQUAL Xcode) if(CMAKE_GENERATOR STREQUAL Xcode)
set(VOLK_GNSSSDR_BUILD_COMMAND "xcodebuild" set(VOLK_GNSSSDR_BUILD_COMMAND "xcodebuild"
"-configuration" $<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel> "-configuration" $<$<CONFIG:None>:None>$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:NoOptWithASM>$<$<CONFIG:Coverage>:Coverage>$<$<CONFIG:O2WithASM>:O2WithASM>$<$<CONFIG:O3WithASM>:O3WithASM>$<$<CONFIG:ASAN>:Debug>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
) )
endif() endif()
@ -1392,316 +1404,427 @@ endif()
################################################################################ ################################################################################
# gflags - https://github.com/gflags/gflags # Abseil C++ - https://abseil.io/docs/cpp/
################################################################################ ################################################################################
set(LOCAL_GFLAGS FALSE) if(CMAKE_VERSION VERSION_GREATER 3.13
if(ENABLE_OWN_GLOG) AND NOT (CMAKE_CXX_STANDARD VERSION_LESS 14)
unset(Glog::glog CACHE) AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.3.1)
unset(GLOG_FOUND CACHE) AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0.0)
unset(Gflags::gflags CACHE) AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12)
unset(GLAGS_FOUND CACHE) AND NOT ENABLE_OWN_GLOG
set(GFLAGS_GREATER_20 TRUE) AND NOT ENABLE_GLOG_AND_GFLAGS)
else() # See https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md
unset(Glog::glog CACHE)
unset(GLOG_FOUND CACHE)
find_package(GLOG)
if(GLOG_FOUND)
unset(GFLAGS_GREATER_20 CACHE)
find_package(GFLAGS)
endif()
endif()
set_package_properties(GFLAGS PROPERTIES
PURPOSE "Used for commandline flags management."
TYPE REQUIRED
)
if(NOT GFLAGS_FOUND)
set(ENABLE_OWN_GLOG ON)
if(GFLAGS_VERSION)
message(STATUS " A version of the gflags library equal or higher than v${GNSSSDR_GFLAGS_MIN_VERSION} has not been found.")
else()
message(STATUS " The gflags library has not been found.")
endif()
message(STATUS " gflags v${GNSSSDR_GFLAGS_LOCAL_VERSION} will be downloaded, built, and statically linked automatically")
message(STATUS " when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'.")
set(GFLAGS_BUILD_COMMAND ${CMAKE_COMMAND}
"--build" "${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}"
"--config" $<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
)
if(CMAKE_GENERATOR STREQUAL Xcode)
set(GFLAGS_BUILD_COMMAND "xcodebuild" "-configuration" $<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>)
endif()
if(CMAKE_TOOLCHAIN_FILE)
set(GFLAGS_TOOLCHAIN_FILE -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE})
endif()
if(CMAKE_VERSION VERSION_LESS 3.2) if(ENABLE_OWN_ABSEIL)
ExternalProject_Add(gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} include(FetchContent)
PREFIX ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} set(ABSEIL_BUILD_COMMAND ${CMAKE_COMMAND}
GIT_REPOSITORY https://github.com/gflags/gflags.git "--build" "${GNSSSDR_BINARY_DIR}/abseil-cpp"
GIT_TAG v${GNSSSDR_GFLAGS_LOCAL_VERSION} "--config" $<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/gflags/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} "--target" "install"
BINARY_DIR ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}
CMAKE_ARGS -DBUILD_SHARED_LIBS=OFF
-DBUILD_STATIC_LIBS=ON
-DBUILD_gflags_LIB=ON
-DBUILD_gflags_nothreads_LIB=ON
-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
${GFLAGS_TOOLCHAIN_FILE}
-DGFLAGS_NAMESPACE=google
-DCMAKE_BUILD_TYPE=$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
BUILD_COMMAND ${GFLAGS_BUILD_COMMAND}
UPDATE_COMMAND ""
PATCH_COMMAND ""
INSTALL_COMMAND ""
) )
else() if(CMAKE_GENERATOR STREQUAL Xcode)
set(GFLAGS_BUILD_BYPRODUCTS ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}) set(ABSEIL_BUILD_COMMAND "xcodebuild" "-configuration" $<$<CONFIG:None>:None>$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:NoOptWithASM>$<$<CONFIG:Coverage>:Coverage>$<$<CONFIG:O2WithASM>:O2WithASM>$<$<CONFIG:O3WithASM>:O3WithASM>$<$<CONFIG:ASAN>:Debug>)
if((CMAKE_BUILD_TYPE STREQUAL Debug) OR (CMAKE_BUILD_TYPE STREQUAL NoOptWithASM) OR
(CMAKE_BUILD_TYPE STREQUAL Coverage) OR (CMAKE_BUILD_TYPE STREQUAL ASAN)) # Workaround for Ninja generator
set(GFLAGS_BUILD_BYPRODUCTS ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags_debug${CMAKE_STATIC_LIBRARY_SUFFIX})
endif() endif()
if((CMAKE_VERSION VERSION_GREATER 3.12.0) AND NOT (CMAKE_GENERATOR STREQUAL Xcode)) if(CMAKE_TOOLCHAIN_FILE)
set(PARALLEL_BUILD "--parallel 2") set(ABSEIL_TOOLCHAIN_FILE -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE})
endif() endif()
ExternalProject_Add(gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} set(ABSL_PROPAGATE_CXX_STD ON)
PREFIX ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} FetchContent_Declare(
GIT_REPOSITORY https://github.com/gflags/gflags.git absl
GIT_TAG v${GNSSSDR_GFLAGS_LOCAL_VERSION} GIT_REPOSITORY https://github.com/abseil/abseil-cpp
SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/gflags/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} GIT_TAG master # live at head
BINARY_DIR ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/abseil-cpp
CMAKE_ARGS -DBUILD_SHARED_LIBS=OFF CMAKE_ARGS -DABSL_PROPAGATE_CXX_STD=ON -ABSL_BUILD_TESTING=OFF -DCMAKE_INSTALL_PREFIX=${GNSSSDR_BINARY_DIR}/abseil-cpp ${ABSEIL_TOOLCHAIN_FILE}
-DBUILD_STATIC_LIBS=ON BINARY_DIR ${GNSSSDR_BINARY_DIR}/abseil-cpp
-DBUILD_gflags_LIB=ON BUILD_COMMAND ${ABSEIL_BUILD_COMMAND}
-DBUILD_gflags_nothreads_LIB=ON OVERRIDE_FIND_PACKAGE # Requires CMake 3.24
-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
${GFLAGS_TOOLCHAIN_FILE}
-DCMAKE_BUILD_TYPE=$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
BUILD_COMMAND "${GFLAGS_BUILD_COMMAND} ${PARALLEL_BUILD}"
BUILD_BYPRODUCTS ${GFLAGS_BUILD_BYPRODUCTS}
UPDATE_COMMAND ""
PATCH_COMMAND ""
INSTALL_COMMAND ""
) )
endif() FetchContent_MakeAvailable(absl)
# Note: -DBUILD_gflags_nothreads_LIB=ON is required as a workaround to a bug in gflags 2.2.2. This is fixed in gflags master branch set(absl_FOUND TRUE)
set(ENABLE_GLOG_AND_GFLAGS OFF)
set(GFlags_INCLUDE_DIRS else()
${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/include CACHE PATH "Local Gflags headers" find_package(absl)
) set_package_properties(absl PROPERTIES
URL "https://github.com/abseil/abseil-cpp"
if(CMAKE_VERSION VERSION_LESS "3.0.2") PURPOSE "Making use of Abseil's log and flags libraries."
set(GFlags_LIBS TYPE OPTIONAL
${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}
) )
endif() if(absl_FOUND)
set_package_properties(absl PROPERTIES
if(NOT TARGET Gflags::gflags) DESCRIPTION "A collection of C++ library code designed to augment the C++ standard library (found: v${absl_VERSION})"
file(MAKE_DIRECTORY ${GFlags_INCLUDE_DIRS}) )
add_library(Gflags::gflags STATIC IMPORTED) else()
add_dependencies(Gflags::gflags gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}) set_package_properties(absl PROPERTIES
set_target_properties(Gflags::gflags PROPERTIES DESCRIPTION "A collection of C++ library code designed to augment the C++ standard library"
IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" )
IMPORTED_CONFIGURATIONS "None;Debug;Release;RelWithDebInfo;MinSizeRel" endif()
MAP_IMPORTED_CONFIG_NOOPTWITHASM Debug if("${absl_VERSION}" VERSION_LESS ${GNSSSDR_ABSEIL_MIN_VERSION})
MAP_IMPORTED_CONFIG_COVERAGE Debug unset(absl_FOUND CACHE)
MAP_IMPORTED_CONFIG_O2WITHASM RelWithDebInfo set(absl_FOUND FALSE)
MAP_IMPORTED_CONFIG_O3WITHASM RelWithDebInfo set(ENABLE_GLOG_AND_GFLAGS ON)
MAP_IMPORTED_CONFIG_ASAN Debug set_package_properties(absl PROPERTIES
IMPORTED_LOCATION_NONE ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX} DESCRIPTION "A collection of C++ library code designed to augment the C++ standard library (found: v${absl_VERSION}, but it is too old and it will not be used)"
IMPORTED_LOCATION_DEBUG ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags_debug${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELEASE ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELWITHDEBINFO ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_MINSIZEREL ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}
INTERFACE_INCLUDE_DIRECTORIES ${GFlags_INCLUDE_DIRS}
INTERFACE_LINK_LIBRARIES ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags$<$<CONFIG:Debug>:_debug>${CMAKE_STATIC_LIBRARY_SUFFIX}
)
if((CMAKE_GENERATOR STREQUAL Xcode) OR MSVC)
if(MSVC)
set(MSVC_POSTFIX _static)
endif()
set_target_properties(Gflags::gflags PROPERTIES
IMPORTED_LOCATION_DEBUG ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/Debug/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}_debug${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELEASE ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/Release/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELWITHDEBINFO ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/RelWithDebInfo/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_MINSIZEREL ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/MinSizeRel/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}
INTERFACE_LINK_LIBRARIES ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/$<$<CONFIG:Debug>:Debug/>$<$<CONFIG:Release>:Release/>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo/>$<$<CONFIG:MinSizeRel>:MinSizeRel/>${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}$<$<CONFIG:Debug>:_debug>${CMAKE_STATIC_LIBRARY_SUFFIX}
) )
endif() endif()
endif() endif()
endif()
if(MSVC)
target_link_libraries(Gflags::gflags INTERFACE shlwapi.lib) if(NOT absl_FOUND)
set(ENABLE_GLOG_AND_GFLAGS ON)
################################################################################
# gflags - https://github.com/gflags/gflags
################################################################################
set(LOCAL_GFLAGS FALSE)
if(ENABLE_OWN_GLOG)
unset(Glog::glog CACHE)
unset(GLOG_FOUND CACHE)
unset(Gflags::gflags CACHE)
unset(GLAGS_FOUND CACHE)
set(GFLAGS_GREATER_20 TRUE)
else()
unset(Glog::glog CACHE)
unset(GLOG_FOUND CACHE)
find_package(GLOG)
if(GLOG_FOUND)
unset(GFLAGS_GREATER_20 CACHE)
find_package(GFLAGS)
endif()
endif() endif()
set(LOCAL_GFLAGS TRUE CACHE STRING "GFlags downloaded, built, and statically linked automatically" FORCE)
set_package_properties(GFLAGS PROPERTIES set_package_properties(GFLAGS PROPERTIES
PURPOSE "Gflags v${GNSSSDR_GFLAGS_LOCAL_VERSION} and Glog v${GNSSSDR_GLOG_LOCAL_VERSION} will be downloaded, built, and statically linked when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'." PURPOSE "Used for commandline flags management."
TYPE REQUIRED
) )
if(CMAKE_VERSION VERSION_LESS 3.2)
set_property(TARGET Gflags::gflags APPEND PROPERTY
INTERFACE_COMPILE_DEFINITIONS GFLAGS_OLD_NAMESPACE=1
)
endif()
endif()
################################################################################
# glog - https://github.com/google/glog
################################################################################
set_package_properties(GLOG PROPERTIES
PURPOSE "Used for runtime internal logging."
TYPE REQUIRED
)
if(NOT GLOG_FOUND OR ${LOCAL_GFLAGS})
message(STATUS " glog library has not been found")
if(NOT GFLAGS_FOUND) if(NOT GFLAGS_FOUND)
message(STATUS " or it is likely not linked to gflags.") set(ENABLE_OWN_GLOG ON)
endif() if(GFLAGS_VERSION)
message(STATUS " glog v${GNSSSDR_GLOG_LOCAL_VERSION} will be downloaded, built, and statically linked automatically") message(STATUS " A version of the gflags library equal or higher than v${GNSSSDR_GFLAGS_MIN_VERSION} has not been found.")
message(STATUS " when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'.") else()
find_package(LIBUNWIND) message(STATUS " The gflags library has not been found.")
set_package_properties(LIBUNWIND PROPERTIES
PURPOSE "Needed by glog."
TYPE OPTIONAL
)
if(NOT ${LOCAL_GFLAGS})
if(NOT TARGET gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION})
add_library(gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} UNKNOWN IMPORTED)
endif() endif()
set_property(TARGET gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} PROPERTY IMPORTED_LOCATION "${GFlags_LIBS}") message(STATUS " gflags v${GNSSSDR_GFLAGS_LOCAL_VERSION} will be downloaded, built, and statically linked automatically")
string(REPLACE /include "" GFLAGS_PREFIX_PATH ${GFlags_INCLUDE_DIRS}) message(STATUS " when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'.")
else() set(GFLAGS_BUILD_COMMAND ${CMAKE_COMMAND}
set(GFLAGS_PREFIX_PATH ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}) "--build" "${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}"
endif() "--config" $<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
set(TARGET_GFLAGS gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION})
set(GLOG_MAKE_PROGRAM ${CMAKE_COMMAND}
"--build" "${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}"
"--config" $<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
)
if(CMAKE_GENERATOR STREQUAL Xcode)
set(GLOG_MAKE_PROGRAM "xcodebuild" "-configuration"
$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>
) )
endif() if(CMAKE_GENERATOR STREQUAL Xcode)
if(CMAKE_TOOLCHAIN_FILE) set(GFLAGS_BUILD_COMMAND "xcodebuild" "-configuration" $<$<CONFIG:None>:None>$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:NoOptWithASM>$<$<CONFIG:Coverage>:Coverage>$<$<CONFIG:O2WithASM>:O2WithASM>$<$<CONFIG:O3WithASM>:O3WithASM>$<$<CONFIG:ASAN>:Debug>)
set(GLOG_TOOLCHAIN_FILE -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}) endif()
endif() if(CMAKE_TOOLCHAIN_FILE)
set(GFLAGS_TOOLCHAIN_FILE -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE})
endif()
if(CMAKE_VERSION VERSION_LESS 3.3) if(CMAKE_VERSION VERSION_LESS 3.2)
if(CMAKE_VERSION VERSION_LESS 3.0) ExternalProject_Add(gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}
set(GLOG_MAKE_PROGRAM ${CMAKE_MAKE_PROGRAM}) PREFIX ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}
set(GFLAGS_LIBRARIES_TO_LINK ${GFlags_LIBS}) GIT_REPOSITORY https://github.com/gflags/gflags.git
if(${LOCAL_GFLAGS}) GIT_TAG v${GNSSSDR_GFLAGS_LOCAL_VERSION}
set(GFLAGS_LIBRARY_DIR_TO_LINK ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib) SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/gflags/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}
else() BINARY_DIR ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}
set(GFLAGS_LIBRARY_DIR_TO_LINK ${GFlags_LIBRARY_DIRS}) CMAKE_ARGS -DBUILD_SHARED_LIBS=OFF
endif() -DBUILD_STATIC_LIBS=ON
if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") -DBUILD_gflags_LIB=ON
set(GFLAGS_LIBRARIES_TO_LINK "${GFLAGS_LIBRARIES_TO_LINK} -lc++") -DBUILD_gflags_nothreads_LIB=ON
set(GLOG_EXPORT_CXX_LIBRARIES "export CXXFLAGS=\"-stdlib=libc++\"") -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
endif() ${GFLAGS_TOOLCHAIN_FILE}
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") -DGFLAGS_NAMESPACE=google
set(GLOG_EXPORT_C_COMPILER "export CC=clang") -DCMAKE_BUILD_TYPE=$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
set(GLOG_EXPORT_CXX_COMPILER "export CXX=clang++") BUILD_COMMAND ${GFLAGS_BUILD_COMMAND}
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
set(GLOG_EXPORT_C_COMPILER "export CC=gcc")
set(GLOG_EXPORT_CXX_COMPILER "export CXX=g++")
endif()
file(WRITE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags
"#!/bin/sh
export CPPFLAGS=-I${GFlags_INCLUDE_DIRS}
export LDFLAGS=-L${GFLAGS_LIBRARY_DIR_TO_LINK}
export LIBS=\"${GFLAGS_LIBRARIES_TO_LINK}\"
${GLOG_EXPORT_CXX_LIBRARIES}
${GLOG_EXPORT_C_COMPILER}
${GLOG_EXPORT_CXX_COMPILER}
cd ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/
aclocal
automake --add-missing
autoreconf -vfi
cd ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configure --enable-shared=no"
)
file(COPY ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags
DESTINATION ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ
GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
set(GLOG_CONFIGURE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configure_with_gflags)
# Ensure that aclocal and libtool are present
if(${CMAKE_SYSTEM_NAME} MATCHES "Linux|kFreeBSD|GNU")
if(EXISTS "/usr/bin/libtoolize")
if(EXISTS "/usr/bin/aclocal" OR
EXISTS "/usr/bin/aclocal-1.16" OR
EXISTS "/usr/bin/aclocal-1.15" OR
EXISTS "/usr/bin/aclocal-1.14" OR
EXISTS "/usr/bin/aclocal-1.13" OR
EXISTS "/usr/bin/aclocal-1.11" OR
EXISTS "/usr/bin/aclocal-1.10")
# Everything ok, we can move on
else()
message(" aclocal has not been found.")
message(" You can try to install it by typing:")
if(${LINUX_DISTRIBUTION} MATCHES "Fedora" OR ${LINUX_DISTRIBUTION} MATCHES "Red Hat")
message(" sudo yum groupinstall 'Development Tools'")
elseif(${LINUX_DISTRIBUTION} MATCHES "openSUSE")
message(" sudo zypper install automake")
else()
message(" sudo apt-get install automake")
endif()
message(FATAL_ERROR "aclocal is required to build glog from source")
endif()
else()
message(" libtool has not been found.")
message(" You can try to install it by typing:")
if(${LINUX_DISTRIBUTION} MATCHES "Fedora" OR ${LINUX_DISTRIBUTION} MATCHES "Red Hat")
message(" sudo yum groupinstall 'Development Tools'")
elseif(${LINUX_DISTRIBUTION} MATCHES "openSUSE")
message(" sudo zypper install libtoool")
else()
message(" sudo apt-get install libtool")
endif()
message(FATAL_ERROR "libtool is required to build glog from source")
endif()
endif()
if(GLOG_MAKE_PROGRAM MATCHES "ninja")
find_program(GLOG_MAKE_EXECUTABLE make
PATHS
/usr/bin
/usr/local/bin
)
if(NOT GLOG_MAKE_EXECUTABLE)
message(FATAL_ERROR "make is required to build Glog from source.")
endif()
set(GLOG_MAKE_PROGRAM ${GLOG_MAKE_EXECUTABLE})
endif()
ExternalProject_Add(glog-${GNSSSDR_GLOG_LOCAL_VERSION}
DEPENDS ${TARGET_GFLAGS}
PREFIX ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
GIT_REPOSITORY https://github.com/google/glog/
GIT_TAG v${GNSSSDR_GLOG_LOCAL_VERSION}
SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
BINARY_DIR ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
CONFIGURE_COMMAND ${GLOG_CONFIGURE} --prefix=<INSTALL_DIR>
BUILD_COMMAND "${GLOG_MAKE_PROGRAM}"
UPDATE_COMMAND "" UPDATE_COMMAND ""
PATCH_COMMAND "" PATCH_COMMAND ""
INSTALL_COMMAND "" INSTALL_COMMAND ""
) )
set(GLOG_LIBRARIES else()
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/.libs/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX} set(GFLAGS_BUILD_BYPRODUCTS ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX})
if((CMAKE_BUILD_TYPE STREQUAL Debug) OR (CMAKE_BUILD_TYPE STREQUAL NoOptWithASM) OR
(CMAKE_BUILD_TYPE STREQUAL Coverage) OR (CMAKE_BUILD_TYPE STREQUAL ASAN)) # Workaround for Ninja generator
set(GFLAGS_BUILD_BYPRODUCTS ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags_debug${CMAKE_STATIC_LIBRARY_SUFFIX})
endif()
if((CMAKE_VERSION VERSION_GREATER 3.12.0) AND NOT (CMAKE_GENERATOR STREQUAL Xcode))
set(PARALLEL_BUILD "--parallel 2")
endif()
ExternalProject_Add(gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}
PREFIX ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}
GIT_REPOSITORY https://github.com/gflags/gflags.git
GIT_TAG v${GNSSSDR_GFLAGS_LOCAL_VERSION}
SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/gflags/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}
BINARY_DIR ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}
CMAKE_ARGS -DBUILD_SHARED_LIBS=OFF
-DBUILD_STATIC_LIBS=ON
-DBUILD_gflags_LIB=ON
-DBUILD_gflags_nothreads_LIB=ON
-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
${GFLAGS_TOOLCHAIN_FILE}
-DCMAKE_BUILD_TYPE=$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
BUILD_COMMAND "${GFLAGS_BUILD_COMMAND} ${PARALLEL_BUILD}"
BUILD_BYPRODUCTS ${GFLAGS_BUILD_BYPRODUCTS}
UPDATE_COMMAND ""
PATCH_COMMAND ""
INSTALL_COMMAND ""
) )
set(GLOG_INCLUDE_DIRS endif()
${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/src # Note: -DBUILD_gflags_nothreads_LIB=ON is required as a workaround to a bug in gflags 2.2.2. This is fixed in gflags master branch
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/src
set(GFlags_INCLUDE_DIRS
${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/include CACHE PATH "Local Gflags headers"
)
if(CMAKE_VERSION VERSION_LESS "3.0.2")
set(GFlags_LIBS
${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}
) )
else() # CMake > 3.0 but < 3.3 endif()
if(NOT TARGET Gflags::gflags)
file(MAKE_DIRECTORY ${GFlags_INCLUDE_DIRS})
add_library(Gflags::gflags STATIC IMPORTED)
add_dependencies(Gflags::gflags gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION})
set_target_properties(Gflags::gflags PROPERTIES
IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
IMPORTED_CONFIGURATIONS "None;Debug;Release;RelWithDebInfo;MinSizeRel"
MAP_IMPORTED_CONFIG_NOOPTWITHASM Debug
MAP_IMPORTED_CONFIG_COVERAGE Debug
MAP_IMPORTED_CONFIG_O2WITHASM RelWithDebInfo
MAP_IMPORTED_CONFIG_O3WITHASM RelWithDebInfo
MAP_IMPORTED_CONFIG_ASAN Debug
IMPORTED_LOCATION_NONE ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_DEBUG ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags_debug${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELEASE ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELWITHDEBINFO ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_MINSIZEREL ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${CMAKE_STATIC_LIBRARY_SUFFIX}
INTERFACE_INCLUDE_DIRECTORIES ${GFlags_INCLUDE_DIRS}
INTERFACE_LINK_LIBRARIES ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gflags$<$<CONFIG:Debug>:_debug>${CMAKE_STATIC_LIBRARY_SUFFIX}
)
if((CMAKE_GENERATOR STREQUAL Xcode) OR MSVC)
if(MSVC)
set(MSVC_POSTFIX _static)
endif()
set_target_properties(Gflags::gflags PROPERTIES
IMPORTED_LOCATION_DEBUG ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/Debug/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}_debug${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELEASE ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/Release/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELWITHDEBINFO ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/RelWithDebInfo/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_MINSIZEREL ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/MinSizeRel/${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}
INTERFACE_LINK_LIBRARIES ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib/$<$<CONFIG:Debug>:Debug/>$<$<CONFIG:Release>:Release/>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo/>$<$<CONFIG:MinSizeRel>:MinSizeRel/>${CMAKE_FIND_LIBRARY_PREFIXES}gflags${MSVC_POSTFIX}$<$<CONFIG:Debug>:_debug>${CMAKE_STATIC_LIBRARY_SUFFIX}
)
endif()
endif()
if(MSVC)
target_link_libraries(Gflags::gflags INTERFACE shlwapi.lib)
endif()
set(LOCAL_GFLAGS TRUE CACHE STRING "GFlags downloaded, built, and statically linked automatically" FORCE)
set_package_properties(GFLAGS PROPERTIES
PURPOSE "Gflags v${GNSSSDR_GFLAGS_LOCAL_VERSION} and Glog v${GNSSSDR_GLOG_LOCAL_VERSION} will be downloaded, built, and statically linked when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'."
)
if(CMAKE_VERSION VERSION_LESS 3.2)
set_property(TARGET Gflags::gflags APPEND PROPERTY
INTERFACE_COMPILE_DEFINITIONS GFLAGS_OLD_NAMESPACE=1
)
endif()
endif()
################################################################################
# glog - https://github.com/google/glog
################################################################################
set_package_properties(GLOG PROPERTIES
PURPOSE "Used for runtime internal logging."
TYPE REQUIRED
)
if(NOT GLOG_FOUND OR ${LOCAL_GFLAGS})
message(STATUS " glog library has not been found")
if(NOT GFLAGS_FOUND)
message(STATUS " or it is likely not linked to gflags.")
endif()
message(STATUS " glog v${GNSSSDR_GLOG_LOCAL_VERSION} will be downloaded, built, and statically linked automatically")
message(STATUS " when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'.")
find_package(LIBUNWIND)
set_package_properties(LIBUNWIND PROPERTIES
PURPOSE "Needed by glog."
TYPE OPTIONAL
)
if(NOT ${LOCAL_GFLAGS})
if(NOT TARGET gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION})
add_library(gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} UNKNOWN IMPORTED)
endif()
set_property(TARGET gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION} PROPERTY IMPORTED_LOCATION "${GFlags_LIBS}")
string(REPLACE /include "" GFLAGS_PREFIX_PATH ${GFlags_INCLUDE_DIRS})
else()
set(GFLAGS_PREFIX_PATH ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION})
endif()
set(TARGET_GFLAGS gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION})
set(GLOG_MAKE_PROGRAM ${CMAKE_COMMAND}
"--build" "${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}"
"--config" $<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
)
if(CMAKE_GENERATOR STREQUAL Xcode)
set(GLOG_MAKE_PROGRAM "xcodebuild" "-configuration"
$<$<CONFIG:None>:None>$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:NoOptWithASM>$<$<CONFIG:Coverage>:Coverage>$<$<CONFIG:O2WithASM>:O2WithASM>$<$<CONFIG:O3WithASM>:O3WithASM>$<$<CONFIG:ASAN>:Debug>
)
endif()
if(CMAKE_TOOLCHAIN_FILE)
set(GLOG_TOOLCHAIN_FILE -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE})
endif()
if(CMAKE_VERSION VERSION_LESS 3.3)
if(CMAKE_VERSION VERSION_LESS 3.0)
set(GLOG_MAKE_PROGRAM ${CMAKE_MAKE_PROGRAM})
set(GFLAGS_LIBRARIES_TO_LINK ${GFlags_LIBS})
if(${LOCAL_GFLAGS})
set(GFLAGS_LIBRARY_DIR_TO_LINK ${GNSSSDR_BINARY_DIR}/gflags-${GNSSSDR_GFLAGS_LOCAL_VERSION}/lib)
else()
set(GFLAGS_LIBRARY_DIR_TO_LINK ${GFlags_LIBRARY_DIRS})
endif()
if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
set(GFLAGS_LIBRARIES_TO_LINK "${GFLAGS_LIBRARIES_TO_LINK} -lc++")
set(GLOG_EXPORT_CXX_LIBRARIES "export CXXFLAGS=\"-stdlib=libc++\"")
endif()
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
set(GLOG_EXPORT_C_COMPILER "export CC=clang")
set(GLOG_EXPORT_CXX_COMPILER "export CXX=clang++")
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
set(GLOG_EXPORT_C_COMPILER "export CC=gcc")
set(GLOG_EXPORT_CXX_COMPILER "export CXX=g++")
endif()
file(WRITE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags
"#!/bin/sh
export CPPFLAGS=-I${GFlags_INCLUDE_DIRS}
export LDFLAGS=-L${GFLAGS_LIBRARY_DIR_TO_LINK}
export LIBS=\"${GFLAGS_LIBRARIES_TO_LINK}\"
${GLOG_EXPORT_CXX_LIBRARIES}
${GLOG_EXPORT_C_COMPILER}
${GLOG_EXPORT_CXX_COMPILER}
cd ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/
aclocal
automake --add-missing
autoreconf -vfi
cd ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configure --enable-shared=no"
)
file(COPY ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags
DESTINATION ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ
GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
set(GLOG_CONFIGURE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configure_with_gflags)
# Ensure that aclocal and libtool are present
if(${CMAKE_SYSTEM_NAME} MATCHES "Linux|kFreeBSD|GNU")
if(EXISTS "/usr/bin/libtoolize")
if(EXISTS "/usr/bin/aclocal" OR
EXISTS "/usr/bin/aclocal-1.16" OR
EXISTS "/usr/bin/aclocal-1.15" OR
EXISTS "/usr/bin/aclocal-1.14" OR
EXISTS "/usr/bin/aclocal-1.13" OR
EXISTS "/usr/bin/aclocal-1.11" OR
EXISTS "/usr/bin/aclocal-1.10")
# Everything ok, we can move on
else()
message(" aclocal has not been found.")
message(" You can try to install it by typing:")
if(${LINUX_DISTRIBUTION} MATCHES "Fedora" OR ${LINUX_DISTRIBUTION} MATCHES "Red Hat")
message(" sudo yum groupinstall 'Development Tools'")
elseif(${LINUX_DISTRIBUTION} MATCHES "openSUSE")
message(" sudo zypper install automake")
else()
message(" sudo apt-get install automake")
endif()
message(FATAL_ERROR "aclocal is required to build glog from source")
endif()
else()
message(" libtool has not been found.")
message(" You can try to install it by typing:")
if(${LINUX_DISTRIBUTION} MATCHES "Fedora" OR ${LINUX_DISTRIBUTION} MATCHES "Red Hat")
message(" sudo yum groupinstall 'Development Tools'")
elseif(${LINUX_DISTRIBUTION} MATCHES "openSUSE")
message(" sudo zypper install libtoool")
else()
message(" sudo apt-get install libtool")
endif()
message(FATAL_ERROR "libtool is required to build glog from source")
endif()
endif()
if(GLOG_MAKE_PROGRAM MATCHES "ninja")
find_program(GLOG_MAKE_EXECUTABLE make
PATHS
/usr/bin
/usr/local/bin
)
if(NOT GLOG_MAKE_EXECUTABLE)
message(FATAL_ERROR "make is required to build Glog from source.")
endif()
set(GLOG_MAKE_PROGRAM ${GLOG_MAKE_EXECUTABLE})
endif()
ExternalProject_Add(glog-${GNSSSDR_GLOG_LOCAL_VERSION}
DEPENDS ${TARGET_GFLAGS}
PREFIX ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
GIT_REPOSITORY https://github.com/google/glog/
GIT_TAG v${GNSSSDR_GLOG_LOCAL_VERSION}
SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
BINARY_DIR ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
CONFIGURE_COMMAND ${GLOG_CONFIGURE} --prefix=<INSTALL_DIR>
BUILD_COMMAND "${GLOG_MAKE_PROGRAM}"
UPDATE_COMMAND ""
PATCH_COMMAND ""
INSTALL_COMMAND ""
)
set(GLOG_LIBRARIES
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/.libs/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
)
set(GLOG_INCLUDE_DIRS
${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/src
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/src
)
else() # CMake > 3.0 but < 3.3
ExternalProject_Add(glog-${GNSSSDR_GLOG_LOCAL_VERSION}
DEPENDS ${TARGET_GFLAGS}
PREFIX ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
GIT_REPOSITORY https://github.com/google/glog/
GIT_TAG v${GNSSSDR_GLOG_LOCAL_VERSION}
SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
BINARY_DIR ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
-DCMAKE_PREFIX_PATH=${GFLAGS_PREFIX_PATH}
${GLOG_TOOLCHAIN_FILE}
-DCMAKE_BUILD_TYPE=$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
BUILD_COMMAND ${GLOG_MAKE_PROGRAM}
UPDATE_COMMAND ""
PATCH_COMMAND ""
INSTALL_COMMAND ""
)
set(GLOG_INCLUDE_DIRS
${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/src
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
${GFlags_INCLUDE_DIRS}
)
endif()
else() # CMake > 3.3
set(GLOG_BUILD_BYPRODUCTS
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
)
if((CMAKE_BUILD_TYPE STREQUAL Debug) OR (CMAKE_BUILD_TYPE STREQUAL NoOptWithASM) OR
(CMAKE_BUILD_TYPE STREQUAL Coverage) OR (CMAKE_BUILD_TYPE STREQUAL ASAN)) # Workaround for Ninja generator
set(GLOG_BUILD_BYPRODUCTS
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glogd${CMAKE_STATIC_LIBRARY_SUFFIX}
)
endif()
if((CMAKE_VERSION VERSION_GREATER 3.12.0) AND NOT (CMAKE_GENERATOR STREQUAL Xcode) AND NOT CMAKE_CROSSCOMPILING)
set(PARALLEL_BUILD "--parallel 2")
endif()
if(GNSSSDR_GLOG_LOCAL_VERSION VERSION_GREATER 0.5.0)
set(GLOG_GTEST -DWITH_GTEST=FALSE)
endif()
if(NOT (CMAKE_VERSION VERSION_LESS "3.22"))
set(GNSSSDR_GLOG_LOCAL_GFLAGS -DCMAKE_REQUIRED_INCLUDES=${GFlags_INCLUDE_DIRS})
endif()
ExternalProject_Add(glog-${GNSSSDR_GLOG_LOCAL_VERSION} ExternalProject_Add(glog-${GNSSSDR_GLOG_LOCAL_VERSION}
DEPENDS ${TARGET_GFLAGS} DEPENDS ${TARGET_GFLAGS}
PREFIX ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION} PREFIX ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
@ -1710,11 +1833,15 @@ ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configu
SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION} SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
BINARY_DIR ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION} BINARY_DIR ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
-DCMAKE_PREFIX_PATH=${GFLAGS_PREFIX_PATH} -DCMAKE_PREFIX_PATH=${GFLAGS_PREFIX_PATH}
${GLOG_TOOLCHAIN_FILE} ${GLOG_TOOLCHAIN_FILE}
-DCMAKE_BUILD_TYPE=$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug> -DCMAKE_BUILD_TYPE=$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
BUILD_COMMAND ${GLOG_MAKE_PROGRAM} -DBUILD_SHARED_LIBS=OFF
${GLOG_GTEST}
-DBUILD_TESTING=OFF
"${GNSSSDR_GLOG_LOCAL_GFLAGS}"
BUILD_COMMAND "${GLOG_MAKE_PROGRAM} ${PARALLEL_BUILD}"
BUILD_BYPRODUCTS ${GLOG_BUILD_BYPRODUCTS}
UPDATE_COMMAND "" UPDATE_COMMAND ""
PATCH_COMMAND "" PATCH_COMMAND ""
INSTALL_COMMAND "" INSTALL_COMMAND ""
@ -1725,120 +1852,64 @@ ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configu
${GFlags_INCLUDE_DIRS} ${GFlags_INCLUDE_DIRS}
) )
endif() endif()
else() # CMake > 3.3
set(GLOG_BUILD_BYPRODUCTS
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
)
if((CMAKE_BUILD_TYPE STREQUAL Debug) OR (CMAKE_BUILD_TYPE STREQUAL NoOptWithASM) OR
(CMAKE_BUILD_TYPE STREQUAL Coverage) OR (CMAKE_BUILD_TYPE STREQUAL ASAN)) # Workaround for Ninja generator
set(GLOG_BUILD_BYPRODUCTS
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glogd${CMAKE_STATIC_LIBRARY_SUFFIX}
)
endif()
if((CMAKE_VERSION VERSION_GREATER 3.12.0) AND NOT (CMAKE_GENERATOR STREQUAL Xcode) AND NOT CMAKE_CROSSCOMPILING)
set(PARALLEL_BUILD "--parallel 2")
endif()
if(GNSSSDR_GLOG_LOCAL_VERSION VERSION_GREATER 0.5.0)
set(GLOG_GTEST -DWITH_GTEST=FALSE)
endif()
if(NOT (CMAKE_VERSION VERSION_LESS "3.22"))
set(GNSSSDR_GLOG_LOCAL_GFLAGS -DCMAKE_REQUIRED_INCLUDES=${GFlags_INCLUDE_DIRS})
endif()
ExternalProject_Add(glog-${GNSSSDR_GLOG_LOCAL_VERSION}
DEPENDS ${TARGET_GFLAGS}
PREFIX ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
GIT_REPOSITORY https://github.com/google/glog/
GIT_TAG v${GNSSSDR_GLOG_LOCAL_VERSION}
SOURCE_DIR ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
BINARY_DIR ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
-DCMAKE_PREFIX_PATH=${GFLAGS_PREFIX_PATH}
${GLOG_TOOLCHAIN_FILE}
-DCMAKE_BUILD_TYPE=$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo>$<$<CONFIG:MinSizeRel>:MinSizeRel>$<$<CONFIG:NoOptWithASM>:Debug>$<$<CONFIG:Coverage>:Debug>$<$<CONFIG:O2WithASM>:RelWithDebInfo>$<$<CONFIG:O3WithASM>:RelWithDebInfo>$<$<CONFIG:ASAN>:Debug>
-DBUILD_SHARED_LIBS=OFF
${GLOG_GTEST}
-DBUILD_TESTING=OFF
"${GNSSSDR_GLOG_LOCAL_GFLAGS}"
BUILD_COMMAND "${GLOG_MAKE_PROGRAM} ${PARALLEL_BUILD}"
BUILD_BYPRODUCTS ${GLOG_BUILD_BYPRODUCTS}
UPDATE_COMMAND ""
PATCH_COMMAND ""
INSTALL_COMMAND ""
)
set(GLOG_INCLUDE_DIRS
${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/src
${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
${GFlags_INCLUDE_DIRS}
)
endif()
add_dependencies(glog-${GNSSSDR_GLOG_LOCAL_VERSION} Gflags::gflags) add_dependencies(glog-${GNSSSDR_GLOG_LOCAL_VERSION} Gflags::gflags)
# Create Glog::glog target # Create Glog::glog target
if(NOT TARGET Glog::glog) if(NOT TARGET Glog::glog)
file(MAKE_DIRECTORY ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/src) file(MAKE_DIRECTORY ${GNSSSDR_BINARY_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/src)
file(MAKE_DIRECTORY ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}) file(MAKE_DIRECTORY ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION})
add_library(Glog::glog STATIC IMPORTED) add_library(Glog::glog STATIC IMPORTED)
add_dependencies(Glog::glog glog-${GNSSSDR_GLOG_LOCAL_VERSION}) add_dependencies(Glog::glog glog-${GNSSSDR_GLOG_LOCAL_VERSION})
if(CMAKE_VERSION VERSION_LESS 3.0) if(CMAKE_VERSION VERSION_LESS 3.0)
set_target_properties(Glog::glog PROPERTIES
IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
IMPORTED_LOCATION "${GLOG_LIBRARIES}"
INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIRS}"
INTERFACE_INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES "${GLOG_LIBRARIES}"
)
else()
set_target_properties(Glog::glog PROPERTIES
IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
IMPORTED_CONFIGURATIONS "None;Debug;Release;RelWithDebInfo;MinSizeRel"
MAP_IMPORTED_CONFIG_NOOPTWITHASM Debug
MAP_IMPORTED_CONFIG_COVERAGE Debug
MAP_IMPORTED_CONFIG_O2WITHASM RelWithDebInfo
MAP_IMPORTED_CONFIG_O3WITHASM RelWithDebInfo
MAP_IMPORTED_CONFIG_ASAN Debug
IMPORTED_LOCATION_NONE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_DEBUG ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glogd${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELEASE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELWITHDEBINFO ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_MINSIZEREL ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
INTERFACE_INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog$<$<CONFIG:Debug>:d>${CMAKE_STATIC_LIBRARY_SUFFIX}
)
if((CMAKE_GENERATOR STREQUAL Xcode) OR MSVC)
set_target_properties(Glog::glog PROPERTIES set_target_properties(Glog::glog PROPERTIES
IMPORTED_LOCATION_DEBUG ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/Debug/${CMAKE_FIND_LIBRARY_PREFIXES}glogd${CMAKE_STATIC_LIBRARY_SUFFIX} IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
IMPORTED_LOCATION_RELEASE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/Release/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX} IMPORTED_LOCATION "${GLOG_LIBRARIES}"
IMPORTED_LOCATION_RELWITHDEBINFO ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/RelWithDebInfo/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX} INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIRS}"
IMPORTED_LOCATION_MINSIZEREL ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/MinSizeRel/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX} INTERFACE_INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/$<$<CONFIG:Debug>:Debug/>$<$<CONFIG:Release>:Release/>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo/>$<$<CONFIG:MinSizeRel>:MinSizeRel/>${CMAKE_FIND_LIBRARY_PREFIXES}glog$<$<CONFIG:Debug>:d>${CMAKE_STATIC_LIBRARY_SUFFIX} INTERFACE_LINK_LIBRARIES "${GLOG_LIBRARIES}"
) )
else()
set_target_properties(Glog::glog PROPERTIES
IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
IMPORTED_CONFIGURATIONS "None;Debug;Release;RelWithDebInfo;MinSizeRel"
MAP_IMPORTED_CONFIG_NOOPTWITHASM Debug
MAP_IMPORTED_CONFIG_COVERAGE Debug
MAP_IMPORTED_CONFIG_O2WITHASM RelWithDebInfo
MAP_IMPORTED_CONFIG_O3WITHASM RelWithDebInfo
MAP_IMPORTED_CONFIG_ASAN Debug
IMPORTED_LOCATION_NONE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_DEBUG ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glogd${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELEASE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELWITHDEBINFO ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_MINSIZEREL ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
INTERFACE_INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/${CMAKE_FIND_LIBRARY_PREFIXES}glog$<$<CONFIG:Debug>:d>${CMAKE_STATIC_LIBRARY_SUFFIX}
)
if((CMAKE_GENERATOR STREQUAL Xcode) OR MSVC)
set_target_properties(Glog::glog PROPERTIES
IMPORTED_LOCATION_DEBUG ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/Debug/${CMAKE_FIND_LIBRARY_PREFIXES}glogd${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELEASE ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/Release/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_RELWITHDEBINFO ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/RelWithDebInfo/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
IMPORTED_LOCATION_MINSIZEREL ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/MinSizeRel/${CMAKE_FIND_LIBRARY_PREFIXES}glog${CMAKE_STATIC_LIBRARY_SUFFIX}
INTERFACE_LINK_LIBRARIES ${GNSSSDR_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/$<$<CONFIG:Debug>:Debug/>$<$<CONFIG:Release>:Release/>$<$<CONFIG:RelWithDebInfo>:RelWithDebInfo/>$<$<CONFIG:MinSizeRel>:MinSizeRel/>${CMAKE_FIND_LIBRARY_PREFIXES}glog$<$<CONFIG:Debug>:d>${CMAKE_STATIC_LIBRARY_SUFFIX}
)
endif()
endif() endif()
endif() endif()
endif() if(NOT (CMAKE_VERSION VERSION_LESS "3.22"))
if(NOT (CMAKE_VERSION VERSION_LESS "3.22")) set_target_properties(Glog::glog PROPERTIES
set_target_properties(Glog::glog PROPERTIES INTERFACE_COMPILE_DEFINITIONS "GLOG_USE_GLOG_EXPORT;GLOG_USE_GFLAGS"
INTERFACE_COMPILE_DEFINITIONS "GLOG_USE_GLOG_EXPORT;GLOG_USE_GFLAGS" INTERFACE_COMPILE_FEATURES "cxx_std_14")
INTERFACE_COMPILE_FEATURES "cxx_std_14") endif()
endif()
if(LIBUNWIND_FOUND) if(LIBUNWIND_FOUND)
target_link_libraries(Glog::glog INTERFACE Libunwind::libunwind) target_link_libraries(Glog::glog INTERFACE Libunwind::libunwind)
endif() endif()
set(LOCAL_GLOG TRUE CACHE STRING "Glog downloaded, built, and statically linked automatically" FORCE) set(LOCAL_GLOG TRUE CACHE STRING "Glog downloaded, built, and statically linked automatically" FORCE)
set_package_properties(GLOG PROPERTIES set_package_properties(GLOG PROPERTIES
PURPOSE "Glog v${GNSSSDR_GLOG_LOCAL_VERSION} will be downloaded, built, and statically linked when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'." PURPOSE "Glog v${GNSSSDR_GLOG_LOCAL_VERSION} will be downloaded, built, and statically linked when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'."
)
endif()
if(NOT ENABLE_LOG)
message(STATUS "Internal logging is not enabled")
if(CMAKE_VERSION VERSION_GREATER 3.11.0)
target_compile_definitions(Glog::glog INTERFACE -DGOOGLE_STRIP_LOG=1)
else()
set_property(TARGET Glog::glog APPEND PROPERTY
INTERFACE_COMPILE_DEFINITIONS GOOGLE_STRIP_LOG=1
) )
endif() endif()
endif() endif()
@ -2656,12 +2727,6 @@ if((NOT Protobuf_FOUND) OR (NOT Protobuf_PROTOC_EXECUTABLE) OR (${Protobuf_VERSI
endif() endif()
else() else()
if(CMAKE_VERSION VERSION_GREATER "3.13") if(CMAKE_VERSION VERSION_GREATER "3.13")
find_package(absl)
set_package_properties(absl PROPERTIES
URL "https://github.com/abseil/abseil-cpp"
PURPOSE "Abseil-cpp >= 20230117 required to be installed before building Protocol Buffers >22.x on the fly."
TYPE OPTIONAL
)
if(absl_FOUND) if(absl_FOUND)
if(absl_VERSION) if(absl_VERSION)
if(${absl_VERSION} VERSION_LESS "20230117") if(${absl_VERSION} VERSION_LESS "20230117")
@ -3481,8 +3546,10 @@ add_feature_info(ENABLE_FPGA ENABLE_FPGA "Enables building of processing blocks
add_feature_info(ENABLE_ARMA_NO_DEBUG ENABLE_ARMA_NO_DEBUG "Enables passing the ARMA_NO_DEBUG macro to Armadillo, hence disabling bound checking.") add_feature_info(ENABLE_ARMA_NO_DEBUG ENABLE_ARMA_NO_DEBUG "Enables passing the ARMA_NO_DEBUG macro to Armadillo, hence disabling bound checking.")
add_feature_info(ENABLE_PACKAGING ENABLE_PACKAGING "Enables software packaging.") add_feature_info(ENABLE_PACKAGING ENABLE_PACKAGING "Enables software packaging.")
add_feature_info(ENABLE_OWN_GLOG ENABLE_OWN_GLOG "Forces the downloading and building of Google glog.") add_feature_info(ENABLE_OWN_GLOG ENABLE_OWN_GLOG "Forces the downloading and building of Google glog.")
add_feature_info(ENABLE_GLOG_AND_GFLAGS ENABLE_GLOG_AND_GFLAGS "Forces the usage of Google glog and Gflags instead of Abseil")
add_feature_info(ENABLE_OWN_ABSEIL ENABLE_OWN_ABSEIL "Forces downloading and building Abseil. Supersedes ENABLE_OWN_GLOG")
add_feature_info(ENABLE_OWN_ARMADILLO ENABLE_OWN_ARMADILLO "Forces the downloading and building of Armadillo.") add_feature_info(ENABLE_OWN_ARMADILLO ENABLE_OWN_ARMADILLO "Forces the downloading and building of Armadillo.")
add_feature_info(ENABLE_LOG ENABLE_LOG "Enables runtime internal logging with Google glog.") add_feature_info(ENABLE_LOG ENABLE_LOG "Enables runtime internal logging.")
add_feature_info(ENABLE_ORC ENABLE_ORC "Use the Optimized Inner Loop Runtime Compiler (ORC) for building volk_gnsssdr.") add_feature_info(ENABLE_ORC ENABLE_ORC "Use the Optimized Inner Loop Runtime Compiler (ORC) for building volk_gnsssdr.")
add_feature_info(ENABLE_STRIP ENABLE_STRIP "Enables the generation of stripped binaries (without debugging symbols).") add_feature_info(ENABLE_STRIP ENABLE_STRIP "Enables the generation of stripped binaries (without debugging symbols).")
add_feature_info(ENABLE_UNIT_TESTING ENABLE_UNIT_TESTING "Enables building of Unit Tests.") add_feature_info(ENABLE_UNIT_TESTING ENABLE_UNIT_TESTING "Enables building of Unit Tests.")

19
README.md
View File

@ -222,9 +222,9 @@ Once you have installed these packages, you can jump directly to
If you are using Arch Linux: If you are using Arch Linux:
``` ```
$ pacman -S gcc make cmake pkgconf git boost boost-libs log4cpp libvolk gnuradio \ $ pacman -S gcc make cmake pkgconf git boost boost-libs libvolk gnuradio \
blas lapack gflags google-glog openssl pugixml libmatio protobuf \ blas lapack hdf5 openssl pugixml libmatio protobuf libpcap gtest \
python-mako libpcap gtest python-mako
``` ```
Once you have installed these packages, you can jump directly to Once you have installed these packages, you can jump directly to
@ -430,6 +430,10 @@ $ sudo make install
$ sudo ldconfig $ sudo ldconfig
``` ```
Please note that GFlags is replaced by the
[Abseil Flags Library](https://abseil.io/docs/cpp/guides/flags) if Abseil >=
v20240116 is available in your system.
#### Install [Glog](https://github.com/google/glog "Glog's Homepage"), a library that implements application-level logging #### Install [Glog](https://github.com/google/glog "Glog's Homepage"), a library that implements application-level logging
``` ```
@ -443,6 +447,10 @@ $ sudo make install
$ sudo ldconfig $ sudo ldconfig
``` ```
Please note that Glog is replaced by the
[Abseil Logging Library](https://abseil.io/docs/cpp/guides/logging) if Abseil >=
v20240116 is available in your system.
#### Install the GnuTLS or OpenSSL libraries #### Install the GnuTLS or OpenSSL libraries
``` ```
@ -832,7 +840,7 @@ $ sudo port selfupdate
$ sudo port upgrade outdated $ sudo port upgrade outdated
$ sudo port install armadillo cmake pkgconfig protobuf3-cpp pugixml gnutls $ sudo port install armadillo cmake pkgconfig protobuf3-cpp pugixml gnutls
$ sudo port install gnuradio +uhd +grc +zeromq $ sudo port install gnuradio +uhd +grc +zeromq
$ sudo port install boost matio libad9361-iio libiio google-glog +gflags $ sudo port install boost matio libad9361-iio libiio
$ sudo port install py311-mako $ sudo port install py311-mako
$ sudo port install doxygen +docs $ sudo port install doxygen +docs
``` ```
@ -871,8 +879,7 @@ Install the required dependencies:
``` ```
$ brew update && brew upgrade $ brew update && brew upgrade
$ brew install armadillo cmake hdf5 gflags glog gnuradio libmatio log4cpp \ $ brew install armadillo cmake hdf5 gnuradio libmatio openssl pkg-config protobuf pugixml
openssl pkg-config protobuf pugixml
$ brew install --cask mactex # when completed, restart Terminal $ brew install --cask mactex # when completed, restart Terminal
$ brew install graphviz doxygen $ brew install graphviz doxygen
¢ pip3 install mako ¢ pip3 install mako

31
docs/CHANGELOG.md
View File

@ -16,8 +16,37 @@ All notable changes to GNSS-SDR will be documented in this file.
### Improvements in Portability: ### Improvements in Portability:
- Fix building against google-glog 0.7.0 - Fix building against google-glog 0.7.0.
- Find dependencies in the loongarch64 architecture. - Find dependencies in the loongarch64 architecture.
- Soft transition from [GFlags](https://github.com/gflags/gflags) and
[Google Logging (glog)](https://github.com/google/glog) to Abseil
[Logging](https://abseil.io/docs/cpp/guides/logging) and
[Flags](https://abseil.io/docs/cpp/guides/flags) libraries. While gflags and
glog have dutifully served GNSS-SDR for over a decade, they are now showing
signs of aging. The latest version of gflags dates back six years now, with
its last commit in the master branch occurring two years ago. Glog remains
well maintained, with its latest version v0.7.0 released in February 2024, but
with no active development of new features and stuck at C++14. Abseil, on the
other hand, represents a contemporary evolution in software development,
supports C++17 and C++20, and has absorbed the functionalities of flags and
logging from its predecessors. Furthermore, as Abseil has become a
prerequisite for the latest versions of Protocol Buffers, its eventual
inclusion in GNSS-SDR's indirect dependencies is inevitable. Leveraging Abseil
allows for eliminating the need for gflags and glog, thereby reducing the
number of mandatory dependencies for GNSS-SDR in forthcoming GNU/Linux
distributions. For seamless integration, GNSS-SDR requires a quite recent
minimum version of Abseil, v20240116. If an older version is detected, the
library will not be utilized, and GNSS-SDR will fall back to using gflags and
glog, which still can be used and are fully supported. A new CMake
configuration option `-DENABLE_GLOG_AND_GFLAGS=ON` is available to force the
usage of glog and gflags instead of Abseil, even if a valid version of that
library is present. If the Abseil version installed in your system is too old
but you still want to try it, you can also force the downloading and building
of a recent version with the new CMake configuration flag
`-DENABLE_OWN_ABSEIL=ON` (requires CMake >= 3.24, otherwise it has no effect).
This change has a downside in maintainability, since the source code becomes
plagued with preprocessor directives required to maintain compatibility both
with gflags and glog, and with Abseil.
### Improvements in Usability: ### Improvements in Usability:

8
src/algorithms/PVT/adapters/CMakeLists.txt
View File

@ -23,10 +23,16 @@ target_link_libraries(pvt_adapters
pvt_gr_blocks pvt_gr_blocks
PRIVATE PRIVATE
gnss_sdr_flags gnss_sdr_flags
Glog::glog
pvt_libs pvt_libs
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(pvt_adapters PRIVATE Glog::glog)
target_compile_definitions(pvt_adapters PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(pvt_adapters PRIVATE absl::flags absl::log)
endif()
target_include_directories(pvt_adapters target_include_directories(pvt_adapters
PUBLIC PUBLIC
${GNSSSDR_SOURCE_DIR}/src/core/interfaces ${GNSSSDR_SOURCE_DIR}/src/core/interfaces

25
src/algorithms/PVT/adapters/rtklib_pvt.cc
View File

@ -26,8 +26,12 @@
#include "gps_ephemeris.h" // for Gps_Ephemeris #include "gps_ephemeris.h" // for Gps_Ephemeris
#include "pvt_conf.h" // for Pvt_Conf #include "pvt_conf.h" // for Pvt_Conf
#include "rtklib_rtkpos.h" // for rtkfree, rtkinit #include "rtklib_rtkpos.h" // for rtkfree, rtkinit
#include <glog/logging.h> // for LOG
#include <iostream> // for std::cout #include <iostream> // for std::cout
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if USE_STD_COMMON_FACTOR #if USE_STD_COMMON_FACTOR
#include <numeric> #include <numeric>
namespace bc = std; namespace bc = std;
@ -88,6 +92,7 @@ Rtklib_Pvt::Rtklib_Pvt(const ConfigurationInterface* configuration,
// RINEX version // RINEX version
pvt_output_parameters.rinex_version = configuration->property(role + ".rinex_version", 3); pvt_output_parameters.rinex_version = configuration->property(role + ".rinex_version", 3);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_RINEX_version == "3.01" || FLAGS_RINEX_version == "3.02" || FLAGS_RINEX_version == "3") if (FLAGS_RINEX_version == "3.01" || FLAGS_RINEX_version == "3.02" || FLAGS_RINEX_version == "3")
{ {
pvt_output_parameters.rinex_version = 3; pvt_output_parameters.rinex_version = 3;
@ -96,13 +101,29 @@ Rtklib_Pvt::Rtklib_Pvt(const ConfigurationInterface* configuration,
{ {
pvt_output_parameters.rinex_version = 2; pvt_output_parameters.rinex_version = 2;
} }
#else
if (absl::GetFlag(FLAGS_RINEX_version) == "3.01" || absl::GetFlag(FLAGS_RINEX_version) == "3.02" || absl::GetFlag(FLAGS_RINEX_version) == "3")
{
pvt_output_parameters.rinex_version = 3;
}
else if (absl::GetFlag(FLAGS_RINEX_version) == "2.10" || absl::GetFlag(FLAGS_RINEX_version) == "2.11" || absl::GetFlag(FLAGS_RINEX_version) == "2")
{
pvt_output_parameters.rinex_version = 2;
}
#endif
pvt_output_parameters.rinexobs_rate_ms = bc::lcm(configuration->property(role + ".rinexobs_rate_ms", 1000), pvt_output_parameters.output_rate_ms); pvt_output_parameters.rinexobs_rate_ms = bc::lcm(configuration->property(role + ".rinexobs_rate_ms", 1000), pvt_output_parameters.output_rate_ms);
pvt_output_parameters.rinex_name = configuration->property(role + ".rinex_name", std::string("-")); pvt_output_parameters.rinex_name = configuration->property(role + ".rinex_name", std::string("-"));
#if USE_GLOG_AND_GFLAGS
if (FLAGS_RINEX_name != "-") if (FLAGS_RINEX_name != "-")
{ {
pvt_output_parameters.rinex_name = FLAGS_RINEX_name; pvt_output_parameters.rinex_name = FLAGS_RINEX_name;
} }
#else
if (absl::GetFlag(FLAGS_RINEX_name) != "-")
{
pvt_output_parameters.rinex_name = absl::GetFlag(FLAGS_RINEX_name);
}
#endif
// RTCM Printer settings // RTCM Printer settings
pvt_output_parameters.flag_rtcm_tty_port = configuration->property(role + ".flag_rtcm_tty_port", false); pvt_output_parameters.flag_rtcm_tty_port = configuration->property(role + ".flag_rtcm_tty_port", false);
pvt_output_parameters.rtcm_dump_devname = configuration->property(role + ".rtcm_dump_devname", default_rtcm_dump_devname); pvt_output_parameters.rtcm_dump_devname = configuration->property(role + ".rtcm_dump_devname", default_rtcm_dump_devname);

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

@ -27,11 +27,16 @@ target_link_libraries(pvt_gr_blocks
PRIVATE PRIVATE
algorithms_libs algorithms_libs
pvt_libs pvt_libs
Gflags::gflags
Glog::glog
Boost::serialization Boost::serialization
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(pvt_gr_blocks PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(pvt_gr_blocks PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(pvt_gr_blocks PRIVATE absl::log)
endif()
if(GNURADIO_USES_STD_POINTERS) if(GNURADIO_USES_STD_POINTERS)
target_compile_definitions(pvt_gr_blocks target_compile_definitions(pvt_gr_blocks
PUBLIC -DGNURADIO_USES_STD_POINTERS=1 PUBLIC -DGNURADIO_USES_STD_POINTERS=1

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

@ -64,7 +64,6 @@
#include <boost/exception/exception.hpp> #include <boost/exception/exception.hpp>
#include <boost/serialization/map.hpp> #include <boost/serialization/map.hpp>
#include <boost/serialization/nvp.hpp> // for nvp, make_nvp #include <boost/serialization/nvp.hpp> // for nvp, make_nvp
#include <glog/logging.h> // for LOG
#include <gnuradio/io_signature.h> // for io_signature #include <gnuradio/io_signature.h> // for io_signature
#include <pmt/pmt_sugar.h> // for mp #include <pmt/pmt_sugar.h> // for mp
#include <algorithm> // for sort, unique #include <algorithm> // for sort, unique
@ -82,6 +81,12 @@
#include <typeinfo> // for std::type_info, typeid #include <typeinfo> // for std::type_info, typeid
#include <utility> // for pair #include <utility> // for pair
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_GENERIC_LAMBDA #if HAS_GENERIC_LAMBDA
#else #else
#include <boost/bind/bind.hpp> #include <boost/bind/bind.hpp>

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

@ -92,11 +92,18 @@ target_link_libraries(pvt_libs
algorithms_libs_rtklib algorithms_libs_rtklib
PRIVATE PRIVATE
algorithms_libs algorithms_libs
Gflags::gflags gnss_sdr_flags
Glog::glog
Matio::matio Matio::matio
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(pvt_libs PUBLIC Glog::glog)
target_compile_definitions(pvt_libs PUBLIC -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(pvt_libs PUBLIC absl::log)
endif()
get_filename_component(PROTO_INCLUDE_HEADERS_DIR ${PROTO_HDRS} DIRECTORY) get_filename_component(PROTO_INCLUDE_HEADERS_DIR ${PROTO_HDRS} DIRECTORY)
# for concurrent_queue.h # for concurrent_queue.h

7
src/algorithms/PVT/libs/an_packet_printer.cc
View File

@ -20,7 +20,6 @@
#include "an_packet_printer.h" #include "an_packet_printer.h"
#include "rtklib_solver.h" // for Rtklib_Solver #include "rtklib_solver.h" // for Rtklib_Solver
#include <glog/logging.h> // for DLOG
#include <cmath> // for M_PI #include <cmath> // for M_PI
#include <cstring> // for memcpy #include <cstring> // for memcpy
#include <fcntl.h> // for fcntl #include <fcntl.h> // for fcntl
@ -29,6 +28,12 @@
#include <termios.h> // values for termios #include <termios.h> // values for termios
#include <unistd.h> // for write(), read(), close() #include <unistd.h> // for write(), read(), close()
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
An_Packet_Printer::An_Packet_Printer(const std::string& an_dump_devname) An_Packet_Printer::An_Packet_Printer(const std::string& an_dump_devname)
: d_start(std::chrono::system_clock::now()), : d_start(std::chrono::system_clock::now()),

2
src/algorithms/PVT/libs/geohash.cc
View File

@ -135,7 +135,7 @@ std::array<double, 2> Geohash::decode(std::string geohash) const
std::array<double, 4> Geohash::bounds(std::string geohash) const std::array<double, 4> Geohash::bounds(std::string geohash) const
{ {
if (geohash.length() == 0) if (geohash.empty())
{ {
throw std::runtime_error("Invalid geohash"); throw std::runtime_error("Invalid geohash");
} }

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

@ -20,13 +20,18 @@
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include "pvt_solution.h" #include "pvt_solution.h"
#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
#include <ctime> // for tm #include <ctime> // for tm
#include <exception> // for exception #include <exception> // for exception
#include <iomanip> // for operator<< #include <iomanip> // for operator<<
#include <iostream> // for cout, cerr #include <iostream> // for cout, cerr
#include <sstream> // for stringstream #include <sstream> // for stringstream
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GeoJSON_Printer::GeoJSON_Printer(const std::string& base_path) : geojson_base_path(base_path), GeoJSON_Printer::GeoJSON_Printer(const std::string& base_path) : geojson_base_path(base_path),
first_pos(true) first_pos(true)

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

@ -20,13 +20,17 @@
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include "pvt_solution.h" #include "pvt_solution.h"
#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
#include <ctime> // for tm #include <ctime> // for tm
#include <exception> // for exception #include <exception> // for exception
#include <iomanip> // for operator<< #include <iomanip> // for operator<<
#include <iostream> // for cout, cerr #include <iostream> // for cout, cerr
#include <sstream> // for stringstream #include <sstream> // for stringstream
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
Gpx_Printer::Gpx_Printer(const std::string& base_path) : indent(" "), Gpx_Printer::Gpx_Printer(const std::string& base_path) : indent(" "),
gpx_base_path(base_path), gpx_base_path(base_path),

7
src/algorithms/PVT/libs/has_simple_printer.cc
View File

@ -21,7 +21,6 @@
#include "galileo_has_data.h" #include "galileo_has_data.h"
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
#include <algorithm> // for std::find, std::count #include <algorithm> // for std::find, std::count
#include <bitset> // for std::bitset #include <bitset> // for std::bitset
#include <cstdint> // for uint8_t, ... #include <cstdint> // for uint8_t, ...
@ -32,6 +31,12 @@
#include <iostream> // for std::cout, std::cerr #include <iostream> // for std::cout, std::cerr
#include <sstream> // for std::stringstream #include <sstream> // for std::stringstream
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
Has_Simple_Printer::Has_Simple_Printer(const std::string& base_path, Has_Simple_Printer::Has_Simple_Printer(const std::string& base_path,
const std::string& filename, const std::string& filename,

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

@ -20,7 +20,6 @@
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include "pvt_solution.h" #include "pvt_solution.h"
#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
#include <cstdlib> // for mkstemp #include <cstdlib> // for mkstemp
#include <ctime> // for tm #include <ctime> // for tm
#include <exception> // for exception #include <exception> // for exception
@ -30,6 +29,11 @@
#include <sys/stat.h> // for S_IXUSR | S_IRWXG | S_IRWXO #include <sys/stat.h> // for S_IXUSR | S_IRWXG | S_IRWXO
#include <sys/types.h> // for mode_t #include <sys/types.h> // for mode_t
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
Kml_Printer::Kml_Printer(const std::string& base_path) : kml_base_path(base_path), Kml_Printer::Kml_Printer(const std::string& base_path) : kml_base_path(base_path),
indent(" "), indent(" "),

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

@ -23,7 +23,6 @@
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include "rtklib_solution.h" #include "rtklib_solution.h"
#include "rtklib_solver.h" #include "rtklib_solver.h"
#include <glog/logging.h>
#include <array> #include <array>
#include <cstdint> #include <cstdint>
#include <exception> #include <exception>
@ -32,6 +31,12 @@
#include <termios.h> #include <termios.h>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
Nmea_Printer::Nmea_Printer(const std::string& filename, Nmea_Printer::Nmea_Printer(const std::string& filename,
bool flag_nmea_output_file, bool flag_nmea_output_file,

6
src/algorithms/PVT/libs/pvt_kf.cc
View File

@ -16,8 +16,12 @@
*/ */
#include "pvt_kf.h" #include "pvt_kf.h"
#include <glog/logging.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
void Pvt_Kf::init_Kf(const arma::vec& p, void Pvt_Kf::init_Kf(const arma::vec& p,
const arma::vec& v, const arma::vec& v,

6
src/algorithms/PVT/libs/pvt_solution.cc
View File

@ -17,10 +17,14 @@
#include "pvt_solution.h" #include "pvt_solution.h"
#include "MATH_CONSTANTS.h" #include "MATH_CONSTANTS.h"
#include <glog/logging.h>
#include <cmath> #include <cmath>
#include <cstddef> #include <cstddef>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
int Pvt_Solution::cart2geo(double X, double Y, double Z, int elipsoid_selection) int Pvt_Solution::cart2geo(double X, double Y, double Z, int elipsoid_selection)
{ {

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

@ -42,7 +42,6 @@
#include <boost/date_time/gregorian/gregorian.hpp> #include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/local_time/local_time.hpp> #include <boost/date_time/local_time/local_time.hpp>
#include <boost/date_time/time_zone_base.hpp> #include <boost/date_time/time_zone_base.hpp>
#include <glog/logging.h>
#include <algorithm> // for min and max #include <algorithm> // for min and max
#include <array> #include <array>
#include <cmath> // for floor #include <cmath> // for floor
@ -55,6 +54,11 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
Rinex_Printer::Rinex_Printer(int32_t conf_version, Rinex_Printer::Rinex_Printer(int32_t conf_version,
const std::string& base_path, const std::string& base_path,

7
src/algorithms/PVT/libs/rtcm.h
View File

@ -29,7 +29,6 @@
#include "gps_ephemeris.h" #include "gps_ephemeris.h"
#include <boost/asio.hpp> #include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
#include <algorithm> // for std::max, std::min, std::copy_n #include <algorithm> // for std::max, std::min, std::copy_n
#include <array> #include <array>
#include <bitset> #include <bitset>
@ -47,6 +46,12 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
/** \addtogroup PVT /** \addtogroup PVT
* \{ */ * \{ */
/** \addtogroup PVT_libs /** \addtogroup PVT_libs

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

@ -30,7 +30,6 @@
#include "rtcm.h" #include "rtcm.h"
#include "rtklib_solver.h" #include "rtklib_solver.h"
#include <boost/exception/diagnostic_information.hpp> #include <boost/exception/diagnostic_information.hpp>
#include <glog/logging.h>
#include <ctime> // for tm #include <ctime> // for tm
#include <exception> // for exception #include <exception> // for exception
#include <fcntl.h> // for O_RDWR #include <fcntl.h> // for O_RDWR
@ -39,6 +38,11 @@
#include <unistd.h> // for close, write #include <unistd.h> // for close, write
#include <vector> // for std::vector #include <vector> // for std::vector
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
Rtcm_Printer::Rtcm_Printer(const std::string& filename, Rtcm_Printer::Rtcm_Printer(const std::string& filename,
bool flag_rtcm_file_dump, bool flag_rtcm_file_dump,

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

@ -35,7 +35,6 @@
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include "rtklib_rtkpos.h" #include "rtklib_rtkpos.h"
#include "rtklib_solution.h" #include "rtklib_solution.h"
#include <glog/logging.h>
#include <matio.h> #include <matio.h>
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
@ -43,6 +42,11 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
Rtklib_Solver::Rtklib_Solver(const rtk_t &rtk, Rtklib_Solver::Rtklib_Solver(const rtk_t &rtk,
const Pvt_Conf &conf, const Pvt_Conf &conf,

8
src/algorithms/acquisition/adapters/CMakeLists.txt
View File

@ -104,9 +104,15 @@ target_link_libraries(acquisition_adapters
PRIVATE PRIVATE
gnss_sdr_flags gnss_sdr_flags
Boost::headers Boost::headers
Glog::glog
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(acquisition_adapters PRIVATE Glog::glog)
target_compile_definitions(acquisition_adapters PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(acquisition_adapters PRIVATE absl::flags absl::log)
endif()
if(GNURADIO_USES_STD_POINTERS) if(GNURADIO_USES_STD_POINTERS)
target_compile_definitions(acquisition_adapters target_compile_definitions(acquisition_adapters
PUBLIC -DGNURADIO_USES_STD_POINTERS=1 PUBLIC -DGNURADIO_USES_STD_POINTERS=1

14
src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.cc
View File

@ -23,10 +23,15 @@
#include "beidou_b1i_signal_replica.h" #include "beidou_b1i_signal_replica.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#include <memory> #include <memory>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -52,10 +57,17 @@ BeidouB1iPcpsAcquisition::BeidouB1iPcpsAcquisition(
LOG(INFO) << "role " << role; LOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
fs_in_ = acq_parameters_.fs_in; fs_in_ = acq_parameters_.fs_in;

14
src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.cc
View File

@ -21,9 +21,14 @@
#include "beidou_b3i_signal_replica.h" #include "beidou_b3i_signal_replica.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -48,10 +53,17 @@ BeidouB3iPcpsAcquisition::BeidouB3iPcpsAcquisition(
LOG(INFO) << "role " << role; LOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
item_type_ = acq_parameters_.item_type; item_type_ = acq_parameters_.item_type;

14
src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc
View File

@ -21,9 +21,14 @@
#include "galileo_e1_signal_replica.h" #include "galileo_e1_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <boost/math/distributions/exponential.hpp> #include <boost/math/distributions/exponential.hpp>
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -58,10 +63,17 @@ GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition(
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
dump_filename_ = configuration_->property(role_ + ".dump_filename", default_dump_filename); dump_filename_ = configuration_->property(role_ + ".dump_filename", default_dump_filename);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
if (sampled_ms_ % 4 != 0) if (sampled_ms_ % 4 != 0)
{ {

14
src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc
View File

@ -22,9 +22,14 @@
#include "galileo_e1_signal_replica.h" #include "galileo_e1_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <boost/math/distributions/exponential.hpp> #include <boost/math/distributions/exponential.hpp>
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -51,10 +56,17 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition(
acq_parameters_.ms_per_code = 4; acq_parameters_.ms_per_code = 4;
acq_parameters_.SetFromConfiguration(configuration_, role_, GALILEO_E1_CODE_CHIP_RATE_CPS, GALILEO_E1_OPT_ACQ_FS_SPS); acq_parameters_.SetFromConfiguration(configuration_, role_, GALILEO_E1_CODE_CHIP_RATE_CPS, GALILEO_E1_OPT_ACQ_FS_SPS);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
item_type_ = acq_parameters_.item_type; item_type_ = acq_parameters_.item_type;

14
src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition_fpga.cc
View File

@ -21,7 +21,6 @@
#include "galileo_e1_signal_replica.h" #include "galileo_e1_signal_replica.h"
#include "gnss_sdr_fft.h" #include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <gnuradio/fft/fft.h> // for fft_complex #include <gnuradio/fft/fft.h> // for fft_complex
#include <gnuradio/gr_complex.h> // for gr_complex #include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc #include <volk/volk.h> // for volk_32fc_conjugate_32fc
@ -30,6 +29,12 @@
#include <cmath> // for abs, pow, floor #include <cmath> // for abs, pow, floor
#include <complex> // for complex #include <complex> // for complex
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GalileoE1PcpsAmbiguousAcquisitionFpga::GalileoE1PcpsAmbiguousAcquisitionFpga( GalileoE1PcpsAmbiguousAcquisitionFpga::GalileoE1PcpsAmbiguousAcquisitionFpga(
const ConfigurationInterface* configuration, const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,
@ -46,10 +51,17 @@ GalileoE1PcpsAmbiguousAcquisitionFpga::GalileoE1PcpsAmbiguousAcquisitionFpga(
{ {
acq_parameters_.SetFromConfiguration(configuration, role_, fpga_buff_num, fpga_blk_exp, downsampling_factor_default, GALILEO_E1_CODE_CHIP_RATE_CPS, GALILEO_E1_B_CODE_LENGTH_CHIPS); acq_parameters_.SetFromConfiguration(configuration, role_, fpga_buff_num, fpga_blk_exp, downsampling_factor_default, GALILEO_E1_CODE_CHIP_RATE_CPS, GALILEO_E1_B_CODE_LENGTH_CHIPS);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
fs_in_ = acq_parameters_.fs_in; fs_in_ = acq_parameters_.fs_in;

13
src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc
View File

@ -21,8 +21,12 @@
#include "galileo_e1_signal_replica.h" #include "galileo_e1_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <boost/math/distributions/exponential.hpp> #include <boost/math/distributions/exponential.hpp>
#include <glog/logging.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition( GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition(
const ConfigurationInterface* configuration, const ConfigurationInterface* configuration,
@ -50,10 +54,17 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
dump_filename_ = configuration_->property(role_ + ".dump_filename", default_dump_filename); dump_filename_ = configuration_->property(role_ + ".dump_filename", default_dump_filename);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
if (sampled_ms_ % 4 != 0) if (sampled_ms_ % 4 != 0)
{ {

14
src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc
View File

@ -21,9 +21,14 @@
#include "galileo_e1_signal_replica.h" #include "galileo_e1_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <boost/math/distributions/exponential.hpp> #include <boost/math/distributions/exponential.hpp>
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -58,10 +63,17 @@ GalileoE1PcpsQuickSyncAmbiguousAcquisition::GalileoE1PcpsQuickSyncAmbiguousAcqui
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename); dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
/* --- Find number of samples per spreading code (4 ms) -----------------*/ /* --- Find number of samples per spreading code (4 ms) -----------------*/
code_length_ = static_cast<unsigned int>(round( code_length_ = static_cast<unsigned int>(round(

14
src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc
View File

@ -21,9 +21,14 @@
#include "galileo_e1_signal_replica.h" #include "galileo_e1_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <boost/math/distributions/exponential.hpp> #include <boost/math/distributions/exponential.hpp>
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -71,10 +76,17 @@ GalileoE1PcpsTongAmbiguousAcquisition::GalileoE1PcpsTongAmbiguousAcquisition(
<< sampled_ms_ << " ms will be used."; << sampled_ms_ << " ms will be used.";
} }
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
bool enable_monitor_output = configuration_->property("AcquisitionMonitor.enable_monitor", false); bool enable_monitor_output = configuration_->property("AcquisitionMonitor.enable_monitor", false);

14
src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc
View File

@ -27,9 +27,14 @@
#include "galileo_e5_signal_replica.h" #include "galileo_e5_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <boost/math/distributions/exponential.hpp> #include <boost/math/distributions/exponential.hpp>
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -67,10 +72,17 @@ GalileoE5aNoncoherentIQAcquisitionCaf::GalileoE5aNoncoherentIQAcquisitionCaf(
int64_t fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 32000000); int64_t fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 32000000);
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
DLOG(INFO) << "role " << role_; DLOG(INFO) << "role " << role_;
if (sampled_ms_ > 3) if (sampled_ms_ > 3)

14
src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc
View File

@ -21,10 +21,15 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "galileo_e5_signal_replica.h" #include "galileo_e5_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <volk_gnsssdr/volk_gnsssdr_complex.h> #include <volk_gnsssdr/volk_gnsssdr_complex.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -51,10 +56,17 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(
acq_parameters_.ms_per_code = 1; acq_parameters_.ms_per_code = 1;
acq_parameters_.SetFromConfiguration(configuration, role_, GALILEO_E5A_CODE_CHIP_RATE_CPS, GALILEO_E5A_OPT_ACQ_FS_SPS); acq_parameters_.SetFromConfiguration(configuration, role_, GALILEO_E5A_CODE_CHIP_RATE_CPS, GALILEO_E5A_OPT_ACQ_FS_SPS);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
item_type_ = acq_parameters_.item_type; item_type_ = acq_parameters_.item_type;

14
src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition_fpga.cc
View File

@ -21,7 +21,6 @@
#include "galileo_e5_signal_replica.h" #include "galileo_e5_signal_replica.h"
#include "gnss_sdr_fft.h" #include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <gnuradio/gr_complex.h> // for gr_complex #include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc #include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <volk_gnsssdr/volk_gnsssdr_alloc.h> #include <volk_gnsssdr/volk_gnsssdr_alloc.h>
@ -29,6 +28,12 @@
#include <cmath> // for abs, pow, floor #include <cmath> // for abs, pow, floor
#include <complex> // for complex #include <complex> // for complex
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GalileoE5aPcpsAcquisitionFpga::GalileoE5aPcpsAcquisitionFpga( GalileoE5aPcpsAcquisitionFpga::GalileoE5aPcpsAcquisitionFpga(
const ConfigurationInterface* configuration, const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,
@ -45,10 +50,17 @@ GalileoE5aPcpsAcquisitionFpga::GalileoE5aPcpsAcquisitionFpga(
{ {
acq_parameters_.SetFromConfiguration(configuration, role_, fpga_buff_num, fpga_blk_exp, downsampling_factor_default, GALILEO_E5A_CODE_CHIP_RATE_CPS, GALILEO_E5A_CODE_LENGTH_CHIPS); acq_parameters_.SetFromConfiguration(configuration, role_, fpga_buff_num, fpga_blk_exp, downsampling_factor_default, GALILEO_E5A_CODE_CHIP_RATE_CPS, GALILEO_E5A_CODE_LENGTH_CHIPS);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
fs_in_ = acq_parameters_.fs_in; fs_in_ = acq_parameters_.fs_in;

14
src/algorithms/acquisition/adapters/galileo_e5b_pcps_acquisition.cc
View File

@ -22,10 +22,15 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "galileo_e5_signal_replica.h" #include "galileo_e5_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <volk_gnsssdr/volk_gnsssdr_complex.h> #include <volk_gnsssdr/volk_gnsssdr_complex.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -51,10 +56,17 @@ GalileoE5bPcpsAcquisition::GalileoE5bPcpsAcquisition(const ConfigurationInterfac
acq_parameters_.ms_per_code = 1; acq_parameters_.ms_per_code = 1;
acq_parameters_.SetFromConfiguration(configuration, role_, GALILEO_E5B_CODE_CHIP_RATE_CPS, GALILEO_E5B_OPT_ACQ_FS_SPS); acq_parameters_.SetFromConfiguration(configuration, role_, GALILEO_E5B_CODE_CHIP_RATE_CPS, GALILEO_E5B_OPT_ACQ_FS_SPS);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
item_type_ = acq_parameters_.item_type; item_type_ = acq_parameters_.item_type;

14
src/algorithms/acquisition/adapters/galileo_e5b_pcps_acquisition_fpga.cc
View File

@ -22,13 +22,18 @@
#include "galileo_e5_signal_replica.h" #include "galileo_e5_signal_replica.h"
#include "gnss_sdr_fft.h" #include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <gnuradio/gr_complex.h> // for gr_complex #include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc #include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <algorithm> // for copy_n #include <algorithm> // for copy_n
#include <cmath> // for abs, pow, floor #include <cmath> // for abs, pow, floor
#include <complex> // for complex #include <complex> // for complex
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GalileoE5bPcpsAcquisitionFpga::GalileoE5bPcpsAcquisitionFpga(const ConfigurationInterface* configuration, GalileoE5bPcpsAcquisitionFpga::GalileoE5bPcpsAcquisitionFpga(const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,
unsigned int in_streams, unsigned int in_streams,
@ -44,10 +49,17 @@ GalileoE5bPcpsAcquisitionFpga::GalileoE5bPcpsAcquisitionFpga(const Configuration
acq_iq_(configuration->property(role + ".acquire_iq", false)) acq_iq_(configuration->property(role + ".acquire_iq", false))
{ {
acq_parameters_.SetFromConfiguration(configuration, role_, fpga_buff_num, fpga_blk_exp, downsampling_factor_default, GALILEO_E5B_CODE_CHIP_RATE_CPS, GALILEO_E5B_CODE_LENGTH_CHIPS); acq_parameters_.SetFromConfiguration(configuration, role_, fpga_buff_num, fpga_blk_exp, downsampling_factor_default, GALILEO_E5B_CODE_CHIP_RATE_CPS, GALILEO_E5B_CODE_LENGTH_CHIPS);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
fs_in_ = acq_parameters_.fs_in; fs_in_ = acq_parameters_.fs_in;

14
src/algorithms/acquisition/adapters/galileo_e6_pcps_acquisition.cc
View File

@ -21,9 +21,14 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "galileo_e6_signal_replica.h" #include "galileo_e6_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -51,10 +56,17 @@ GalileoE6PcpsAcquisition::GalileoE6PcpsAcquisition(
DLOG(INFO) << "role " << role; DLOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
item_type_ = acq_parameters_.item_type; item_type_ = acq_parameters_.item_type;

14
src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc
View File

@ -23,9 +23,14 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "glonass_l1_signal_replica.h" #include "glonass_l1_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -51,10 +56,17 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition(
DLOG(INFO) << "role " << role; DLOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
item_type_ = acq_parameters_.item_type; item_type_ = acq_parameters_.item_type;

14
src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc
View File

@ -22,9 +22,14 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "glonass_l2_signal_replica.h" #include "glonass_l2_signal_replica.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -50,10 +55,17 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition(
DLOG(INFO) << "role " << role; DLOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
item_type_ = acq_parameters_.item_type; item_type_ = acq_parameters_.item_type;

14
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc
View File

@ -25,9 +25,14 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_sdr_signal_replica.h" #include "gps_sdr_signal_replica.h"
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -54,10 +59,17 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition(
DLOG(INFO) << "role " << role; DLOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);

13
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fine_doppler.cc
View File

@ -24,8 +24,12 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_sdr_signal_replica.h" #include "gps_sdr_signal_replica.h"
#include <glog/logging.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GpsL1CaPcpsAcquisitionFineDoppler::GpsL1CaPcpsAcquisitionFineDoppler( GpsL1CaPcpsAcquisitionFineDoppler::GpsL1CaPcpsAcquisitionFineDoppler(
const ConfigurationInterface* configuration, const ConfigurationInterface* configuration,
@ -57,10 +61,17 @@ GpsL1CaPcpsAcquisitionFineDoppler::GpsL1CaPcpsAcquisitionFineDoppler(
acq_parameters.dump = dump_; acq_parameters.dump = dump_;
dump_filename_ = configuration->property(role_ + ".dump_filename", std::move(default_dump_filename)); dump_filename_ = configuration->property(role_ + ".dump_filename", std::move(default_dump_filename));
acq_parameters.dump_filename = dump_filename_; acq_parameters.dump_filename = dump_filename_;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
acq_parameters.doppler_max = doppler_max_; acq_parameters.doppler_max = doppler_max_;
acq_parameters.sampled_ms = sampled_ms_; acq_parameters.sampled_ms = sampled_ms_;
acq_parameters.max_dwells = max_dwells_; acq_parameters.max_dwells = max_dwells_;

14
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fpga.cc
View File

@ -24,13 +24,18 @@
#include "gnss_sdr_fft.h" #include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_sdr_signal_replica.h" #include "gps_sdr_signal_replica.h"
#include <glog/logging.h>
#include <gnuradio/gr_complex.h> // for gr_complex #include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc #include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <algorithm> // for copy_n #include <algorithm> // for copy_n
#include <cmath> // for abs, pow, floor #include <cmath> // for abs, pow, floor
#include <complex> // for complex #include <complex> // for complex
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GpsL1CaPcpsAcquisitionFpga::GpsL1CaPcpsAcquisitionFpga( GpsL1CaPcpsAcquisitionFpga::GpsL1CaPcpsAcquisitionFpga(
const ConfigurationInterface* configuration, const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,
@ -47,10 +52,17 @@ GpsL1CaPcpsAcquisitionFpga::GpsL1CaPcpsAcquisitionFpga(
DLOG(INFO) << "role " << role; DLOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
fs_in_ = acq_parameters_.fs_in; fs_in_ = acq_parameters_.fs_in;

13
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_assisted_acquisition.cc
View File

@ -23,8 +23,12 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_sdr_signal_replica.h" #include "gps_sdr_signal_replica.h"
#include <glog/logging.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GpsL1CaPcpsAssistedAcquisition::GpsL1CaPcpsAssistedAcquisition( GpsL1CaPcpsAssistedAcquisition::GpsL1CaPcpsAssistedAcquisition(
const ConfigurationInterface* configuration, const ConfigurationInterface* configuration,
@ -51,10 +55,17 @@ GpsL1CaPcpsAssistedAcquisition::GpsL1CaPcpsAssistedAcquisition(
int64_t fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000); int64_t fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
fs_in_ = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in_ = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_min_ = configuration->property(role_ + ".doppler_min", -doppler_max_); doppler_min_ = configuration->property(role_ + ".doppler_min", -doppler_max_);
bool enable_monitor_output = configuration->property("AcquisitionMonitor.enable_monitor", false); bool enable_monitor_output = configuration->property("AcquisitionMonitor.enable_monitor", false);

14
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.cc
View File

@ -21,9 +21,14 @@
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_sdr_signal_replica.h" #include "gps_sdr_signal_replica.h"
#include <boost/math/distributions/exponential.hpp> #include <boost/math/distributions/exponential.hpp>
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -58,10 +63,17 @@ GpsL1CaPcpsOpenClAcquisition::GpsL1CaPcpsOpenClAcquisition(
fs_in_ = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in_ = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
dump_ = configuration->property(role + ".dump", false); dump_ = configuration->property(role + ".dump", false);
doppler_max_ = configuration->property(role + ".doppler_max", 5000); doppler_max_ = configuration->property(role + ".doppler_max", 5000);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
sampled_ms_ = configuration->property(role + ".coherent_integration_time_ms", 1); sampled_ms_ = configuration->property(role + ".coherent_integration_time_ms", 1);
bit_transition_flag_ = configuration->property("Acquisition.bit_transition_flag", false); bit_transition_flag_ = configuration->property("Acquisition.bit_transition_flag", false);

14
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc
View File

@ -22,9 +22,14 @@
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_sdr_signal_replica.h" #include "gps_sdr_signal_replica.h"
#include <boost/math/distributions/exponential.hpp> #include <boost/math/distributions/exponential.hpp>
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -58,10 +63,17 @@ GpsL1CaPcpsQuickSyncAcquisition::GpsL1CaPcpsQuickSyncAcquisition(
int64_t fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000); int64_t fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000);
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
// -- Find number of samples per spreading code ------------------------- // -- Find number of samples per spreading code -------------------------
code_length_ = static_cast<unsigned int>(round(fs_in_ / (GPS_L1_CA_CODE_RATE_CPS / GPS_L1_CA_CODE_LENGTH_CHIPS))); code_length_ = static_cast<unsigned int>(round(fs_in_ / (GPS_L1_CA_CODE_RATE_CPS / GPS_L1_CA_CODE_LENGTH_CHIPS)));

14
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc
View File

@ -21,9 +21,14 @@
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_sdr_signal_replica.h" #include "gps_sdr_signal_replica.h"
#include <boost/math/distributions/exponential.hpp> #include <boost/math/distributions/exponential.hpp>
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -63,10 +68,17 @@ GpsL1CaPcpsTongAcquisition::GpsL1CaPcpsTongAcquisition(
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
dump_filename_ = configuration_->property(role_ + ".dump_filename", std::move(default_dump_filename)); dump_filename_ = configuration_->property(role_ + ".dump_filename", std::move(default_dump_filename));
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
doppler_max_ = FLAGS_doppler_max; doppler_max_ = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
doppler_max_ = absl::GetFlag(FLAGS_doppler_max);
}
#endif
bool enable_monitor_output = configuration_->property("AcquisitionMonitor.enable_monitor", false); bool enable_monitor_output = configuration_->property("AcquisitionMonitor.enable_monitor", false);
// -- Find number of samples per spreading code ------------------------- // -- Find number of samples per spreading code -------------------------

14
src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc
View File

@ -23,9 +23,14 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_l2c_signal_replica.h" #include "gps_l2c_signal_replica.h"
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -52,10 +57,17 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition(
DLOG(INFO) << "Role " << role; DLOG(INFO) << "Role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
item_type_ = acq_parameters_.item_type; item_type_ = acq_parameters_.item_type;

14
src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition_fpga.cc
View File

@ -23,7 +23,6 @@
#include "gnss_sdr_fft.h" #include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_l2c_signal_replica.h" #include "gps_l2c_signal_replica.h"
#include <glog/logging.h>
#include <gnuradio/gr_complex.h> // for gr_complex #include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc #include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <volk_gnsssdr/volk_gnsssdr_alloc.h> #include <volk_gnsssdr/volk_gnsssdr_alloc.h>
@ -31,6 +30,12 @@
#include <cmath> // for abs, pow, floor #include <cmath> // for abs, pow, floor
#include <complex> // for complex #include <complex> // for complex
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GpsL2MPcpsAcquisitionFpga::GpsL2MPcpsAcquisitionFpga( GpsL2MPcpsAcquisitionFpga::GpsL2MPcpsAcquisitionFpga(
const ConfigurationInterface* configuration, const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,
@ -47,10 +52,17 @@ GpsL2MPcpsAcquisitionFpga::GpsL2MPcpsAcquisitionFpga(
LOG(INFO) << "role " << role; LOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
fs_in_ = acq_parameters_.fs_in; fs_in_ = acq_parameters_.fs_in;

15
src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc
View File

@ -23,8 +23,14 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_l5_signal_replica.h" #include "gps_l5_signal_replica.h"
#include <glog/logging.h>
#include <algorithm> #include <algorithm>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -51,10 +57,17 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition(
DLOG(INFO) << "role " << role; DLOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);

14
src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition_fpga.cc
View File

@ -24,7 +24,6 @@
#include "gnss_sdr_fft.h" #include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gps_l5_signal_replica.h" #include "gps_l5_signal_replica.h"
#include <glog/logging.h>
#include <gnuradio/gr_complex.h> // for gr_complex #include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc #include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <volk_gnsssdr/volk_gnsssdr_alloc.h> #include <volk_gnsssdr/volk_gnsssdr_alloc.h>
@ -32,6 +31,12 @@
#include <cmath> // for abs, pow, floor #include <cmath> // for abs, pow, floor
#include <complex> // for complex #include <complex> // for complex
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
GpsL5iPcpsAcquisitionFpga::GpsL5iPcpsAcquisitionFpga( GpsL5iPcpsAcquisitionFpga::GpsL5iPcpsAcquisitionFpga(
const ConfigurationInterface* configuration, const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,
@ -48,10 +53,17 @@ GpsL5iPcpsAcquisitionFpga::GpsL5iPcpsAcquisitionFpga(
LOG(INFO) << "role " << role; LOG(INFO) << "role " << role;
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_max != 0) if (FLAGS_doppler_max != 0)
{ {
acq_parameters_.doppler_max = FLAGS_doppler_max; acq_parameters_.doppler_max = FLAGS_doppler_max;
} }
#else
if (absl::GetFlag(FLAGS_doppler_max) != 0)
{
acq_parameters_.doppler_max = absl::GetFlag(FLAGS_doppler_max);
}
#endif
doppler_max_ = acq_parameters_.doppler_max; doppler_max_ = acq_parameters_.doppler_max;
doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step); doppler_step_ = static_cast<unsigned int>(acq_parameters_.doppler_step);
fs_in_ = acq_parameters_.fs_in; fs_in_ = acq_parameters_.fs_in;

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

@ -65,11 +65,16 @@ target_link_libraries(acquisition_gr_blocks
Volk::volk Volk::volk
Volkgnsssdr::volkgnsssdr Volkgnsssdr::volkgnsssdr
PRIVATE PRIVATE
Gflags::gflags
Glog::glog
Matio::matio Matio::matio
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(acquisition_gr_blocks PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(acquisition_gr_blocks PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(acquisition_gr_blocks PRIVATE absl::flags absl::log)
endif()
target_include_directories(acquisition_gr_blocks target_include_directories(acquisition_gr_blocks
PRIVATE PRIVATE
${GNSSSDR_SOURCE_DIR}/src/core/receiver ${GNSSSDR_SOURCE_DIR}/src/core/receiver

7
src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc
View File

@ -23,7 +23,6 @@
#include "galileo_e5a_noncoherent_iq_acquisition_caf_cc.h" #include "galileo_e5a_noncoherent_iq_acquisition_caf_cc.h"
#include "MATH_CONSTANTS.h" #include "MATH_CONSTANTS.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <volk/volk.h> #include <volk/volk.h>
#include <volk_gnsssdr/volk_gnsssdr.h> #include <volk_gnsssdr/volk_gnsssdr.h>
@ -32,6 +31,12 @@
#include <exception> #include <exception>
#include <sstream> #include <sstream>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr galileo_e5a_noncoherentIQ_make_acquisition_caf_cc( galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr galileo_e5a_noncoherentIQ_make_acquisition_caf_cc(
unsigned int sampled_ms, unsigned int sampled_ms,

6
src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.cc
View File

@ -17,7 +17,6 @@
#include "galileo_pcps_8ms_acquisition_cc.h" #include "galileo_pcps_8ms_acquisition_cc.h"
#include "MATH_CONSTANTS.h" #include "MATH_CONSTANTS.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <volk/volk.h> #include <volk/volk.h>
#include <volk_gnsssdr/volk_gnsssdr.h> #include <volk_gnsssdr/volk_gnsssdr.h>
@ -26,6 +25,11 @@
#include <exception> #include <exception>
#include <sstream> #include <sstream>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
galileo_pcps_8ms_acquisition_cc_sptr galileo_pcps_8ms_make_acquisition_cc( galileo_pcps_8ms_acquisition_cc_sptr galileo_pcps_8ms_make_acquisition_cc(
uint32_t sampled_ms, uint32_t sampled_ms,

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

@ -39,6 +39,12 @@
#include <iostream> #include <iostream>
#include <map> #include <map>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
pcps_acquisition_sptr pcps_make_acquisition(const Acq_Conf& conf_) pcps_acquisition_sptr pcps_make_acquisition(const Acq_Conf& conf_)
{ {
@ -896,6 +902,18 @@ void pcps_acquisition::calculate_threshold()
} }
void pcps_acquisition::set_doppler_center(int32_t doppler_center)
{
gr::thread::scoped_lock lock(d_setlock); // require mutex with work function called by the scheduler
if (doppler_center != d_doppler_center)
{
DLOG(INFO) << " Doppler assistance for Channel: " << d_channel << " => Doppler: " << doppler_center << "[Hz]";
d_doppler_center = doppler_center;
update_grid_doppler_wipeoffs();
}
}
int pcps_acquisition::general_work(int noutput_items __attribute__((unused)), int pcps_acquisition::general_work(int noutput_items __attribute__((unused)),
gr_vector_int& ninput_items, gr_vector_int& ninput_items,
gr_vector_const_void_star& input_items, gr_vector_const_void_star& input_items,

13
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h
View File

@ -46,7 +46,6 @@
#include "channel_fsm.h" #include "channel_fsm.h"
#include "gnss_sdr_fft.h" #include "gnss_sdr_fft.h"
#include <armadillo> #include <armadillo>
#include <glog/logging.h>
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <gnuradio/gr_complex.h> // for gr_complex #include <gnuradio/gr_complex.h> // for gr_complex
#include <gnuradio/thread/thread.h> // for scoped_lock #include <gnuradio/thread/thread.h> // for scoped_lock
@ -60,6 +59,7 @@
#include <string> #include <string>
#include <utility> #include <utility>
#if HAS_STD_SPAN #if HAS_STD_SPAN
#include <span> #include <span>
namespace own = std; namespace own = std;
@ -196,16 +196,7 @@ public:
* \brief Set Doppler center frequency for the grid search. It will refresh the Doppler grid. * \brief Set Doppler center frequency for the grid search. It will refresh the Doppler grid.
* \param doppler_center - Frequency center of the search grid [Hz]. * \param doppler_center - Frequency center of the search grid [Hz].
*/ */
inline void set_doppler_center(int32_t doppler_center) void set_doppler_center(int32_t doppler_center);
{
gr::thread::scoped_lock lock(d_setlock); // require mutex with work function called by the scheduler
if (doppler_center != d_doppler_center)
{
DLOG(INFO) << " Doppler assistance for Channel: " << d_channel << " => Doppler: " << doppler_center << "[Hz]";
d_doppler_center = doppler_center;
update_grid_doppler_wipeoffs();
}
}
/*! /*!
* \brief Parallel Code Phase Search Acquisition signal processing. * \brief Parallel Code Phase Search Acquisition signal processing.

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

@ -21,7 +21,6 @@
#include "gnss_sdr_create_directory.h" #include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include "gps_sdr_signal_replica.h" #include "gps_sdr_signal_replica.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <matio.h> #include <matio.h>
#include <volk/volk.h> #include <volk/volk.h>
@ -30,6 +29,12 @@
#include <sstream> #include <sstream>
#include <vector> #include <vector>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
pcps_acquisition_fine_doppler_cc_sptr pcps_make_acquisition_fine_doppler_cc(const Acq_Conf &conf_) pcps_acquisition_fine_doppler_cc_sptr pcps_make_acquisition_fine_doppler_cc(const Acq_Conf &conf_)
{ {

17
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.cc
View File

@ -21,12 +21,17 @@
#include "pcps_acquisition_fpga.h" #include "pcps_acquisition_fpga.h"
#include "gnss_sdr_make_unique.h" // for std::make_unique in C++11 #include "gnss_sdr_make_unique.h" // for std::make_unique in C++11
#include "gnss_synchro.h" #include "gnss_synchro.h"
#include <glog/logging.h>
#include <cmath> // for ceil #include <cmath> // for ceil
#include <iostream> // for operator<< #include <iostream> // for operator<<
#include <utility> // for move #include <utility> // for move
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
pcps_acquisition_fpga_sptr pcps_make_acquisition_fpga(Acq_Conf_Fpga& conf_) pcps_acquisition_fpga_sptr pcps_make_acquisition_fpga(Acq_Conf_Fpga& conf_)
{ {
return pcps_acquisition_fpga_sptr(new pcps_acquisition_fpga(conf_)); return pcps_acquisition_fpga_sptr(new pcps_acquisition_fpga(conf_));
@ -288,6 +293,16 @@ void pcps_acquisition_fpga::set_active(bool active)
} }
void pcps_acquisition_fpga::set_doppler_center(int32_t doppler_center)
{
if (doppler_center != d_doppler_center)
{
DLOG(INFO) << " Doppler assistance for Channel: " << d_channel << " => Doppler: " << doppler_center << "[Hz]";
d_doppler_center = doppler_center;
}
}
void pcps_acquisition_fpga::reset_acquisition() void pcps_acquisition_fpga::reset_acquisition()
{ {
// this function triggers a HW reset of the FPGA PL. // this function triggers a HW reset of the FPGA PL.

10
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.h
View File

@ -29,7 +29,6 @@
#include "acq_conf_fpga.h" #include "acq_conf_fpga.h"
#include "channel_fsm.h" #include "channel_fsm.h"
#include "fpga_acquisition.h" #include "fpga_acquisition.h"
#include <glog/logging.h>
#include <cstdint> // for uint32_t #include <cstdint> // for uint32_t
#include <memory> // for shared_ptr #include <memory> // for shared_ptr
#include <string> // for string #include <string> // for string
@ -156,14 +155,7 @@ public:
* \brief Set Doppler center frequency for the grid search. It will refresh the Doppler grid. * \brief Set Doppler center frequency for the grid search. It will refresh the Doppler grid.
* \param doppler_center - Frequency center of the search grid [Hz]. * \param doppler_center - Frequency center of the search grid [Hz].
*/ */
inline void set_doppler_center(int32_t doppler_center) void set_doppler_center(int32_t doppler_center);
{
if (doppler_center != d_doppler_center)
{
DLOG(INFO) << " Doppler assistance for Channel: " << d_channel << " => Doppler: " << doppler_center << "[Hz]";
d_doppler_center = doppler_center;
}
}
/*! /*!
* \brief This function triggers a HW reset of the FPGA PL. * \brief This function triggers a HW reset of the FPGA PL.

6
src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.cc
View File

@ -20,7 +20,6 @@
#include "MATH_CONSTANTS.h" #include "MATH_CONSTANTS.h"
#include "concurrent_map.h" #include "concurrent_map.h"
#include "gps_acq_assist.h" #include "gps_acq_assist.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <volk/volk.h> #include <volk/volk.h>
#include <volk_gnsssdr/volk_gnsssdr.h> #include <volk_gnsssdr/volk_gnsssdr.h>
@ -30,6 +29,11 @@
#include <sstream> #include <sstream>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
extern Concurrent_Map<Gps_Acq_Assist> global_gps_acq_assist_map; extern Concurrent_Map<Gps_Acq_Assist> global_gps_acq_assist_map;

7
src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.cc
View File

@ -22,7 +22,6 @@
#include "pcps_cccwsr_acquisition_cc.h" #include "pcps_cccwsr_acquisition_cc.h"
#include "MATH_CONSTANTS.h" // TWO_PI #include "MATH_CONSTANTS.h" // TWO_PI
#include <glog/logging.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <volk/volk.h> #include <volk/volk.h>
#include <volk_gnsssdr/volk_gnsssdr.h> #include <volk_gnsssdr/volk_gnsssdr.h>
@ -32,6 +31,12 @@
#include <sstream> #include <sstream>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
pcps_cccwsr_acquisition_cc_sptr pcps_cccwsr_make_acquisition_cc( pcps_cccwsr_acquisition_cc_sptr pcps_cccwsr_make_acquisition_cc(
uint32_t sampled_ms, uint32_t sampled_ms,

7
src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.cc
View File

@ -38,7 +38,6 @@
#include "MATH_CONSTANTS.h" // TWO_PI #include "MATH_CONSTANTS.h" // TWO_PI
#include "opencl/fft_base_kernels.h" #include "opencl/fft_base_kernels.h"
#include "opencl/fft_internal.h" #include "opencl/fft_internal.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <volk/volk.h> #include <volk/volk.h>
#include <volk_gnsssdr/volk_gnsssdr.h> #include <volk_gnsssdr/volk_gnsssdr.h>
@ -50,6 +49,12 @@
#include <sstream> #include <sstream>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
pcps_opencl_acquisition_cc_sptr pcps_make_opencl_acquisition_cc( pcps_opencl_acquisition_cc_sptr pcps_make_opencl_acquisition_cc(
uint32_t sampled_ms, uint32_t max_dwells, uint32_t sampled_ms, uint32_t max_dwells,

7
src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.cc
View File

@ -16,7 +16,6 @@
#include "pcps_quicksync_acquisition_cc.h" #include "pcps_quicksync_acquisition_cc.h"
#include "MATH_CONSTANTS.h" #include "MATH_CONSTANTS.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <volk/volk.h> #include <volk/volk.h>
#include <volk_gnsssdr/volk_gnsssdr.h> #include <volk_gnsssdr/volk_gnsssdr.h>
@ -25,6 +24,12 @@
#include <exception> #include <exception>
#include <sstream> #include <sstream>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
pcps_quicksync_acquisition_cc_sptr pcps_quicksync_make_acquisition_cc( pcps_quicksync_acquisition_cc_sptr pcps_quicksync_make_acquisition_cc(
uint32_t folding_factor, uint32_t folding_factor,

7
src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.cc
View File

@ -36,7 +36,6 @@
#include "pcps_tong_acquisition_cc.h" #include "pcps_tong_acquisition_cc.h"
#include "MATH_CONSTANTS.h" // for TWO_PI #include "MATH_CONSTANTS.h" // for TWO_PI
#include <glog/logging.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <volk/volk.h> #include <volk/volk.h>
#include <volk_gnsssdr/volk_gnsssdr.h> #include <volk_gnsssdr/volk_gnsssdr.h>
@ -45,6 +44,12 @@
#include <exception> #include <exception>
#include <sstream> #include <sstream>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
pcps_tong_acquisition_cc_sptr pcps_tong_make_acquisition_cc( pcps_tong_acquisition_cc_sptr pcps_tong_make_acquisition_cc(
uint32_t sampled_ms, uint32_t sampled_ms,

9
src/algorithms/acquisition/libs/CMakeLists.txt
View File

@ -38,12 +38,17 @@ target_link_libraries(acquisition_libs
INTERFACE INTERFACE
Gnuradio::runtime Gnuradio::runtime
PRIVATE PRIVATE
Gflags::gflags
Glog::glog
algorithms_libs algorithms_libs
core_system_parameters core_system_parameters
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(acquisition_libs PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(acquisition_libs PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(acquisition_libs PRIVATE absl::flags absl::log)
endif()
if(ENABLE_CLANG_TIDY) if(ENABLE_CLANG_TIDY)
if(CLANG_TIDY_EXE) if(CLANG_TIDY_EXE)
set_target_properties(acquisition_libs set_target_properties(acquisition_libs

7
src/algorithms/acquisition/libs/acq_conf.cc
View File

@ -17,9 +17,14 @@
#include "acq_conf.h" #include "acq_conf.h"
#include "item_type_helpers.h" #include "item_type_helpers.h"
#include <glog/logging.h>
#include <cmath> #include <cmath>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
void Acq_Conf::SetFromConfiguration(const ConfigurationInterface *configuration, void Acq_Conf::SetFromConfiguration(const ConfigurationInterface *configuration,
const std::string &role, double chip_rate, double opt_freq) const std::string &role, double chip_rate, double opt_freq)

7
src/algorithms/acquisition/libs/acq_conf_fpga.cc
View File

@ -18,11 +18,16 @@
#include "acq_conf_fpga.h" #include "acq_conf_fpga.h"
#include "item_type_helpers.h" #include "item_type_helpers.h"
#include "uio_fpga.h" #include "uio_fpga.h"
#include <glog/logging.h>
#include <cmath> #include <cmath>
#include <iostream> #include <iostream>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
void Acq_Conf_Fpga::SetFromConfiguration(const ConfigurationInterface *configuration, void Acq_Conf_Fpga::SetFromConfiguration(const ConfigurationInterface *configuration,
const std::string &role, uint32_t sel_queue_fpga, uint32_t blk_exp, uint32_t downsampling_factor_default, double chip_rate, double code_length_chips) const std::string &role, uint32_t sel_queue_fpga, uint32_t blk_exp, uint32_t downsampling_factor_default, double chip_rate, double code_length_chips)
{ {

6
src/algorithms/acquisition/libs/fpga_acquisition.cc
View File

@ -21,7 +21,6 @@
#include "fpga_acquisition.h" #include "fpga_acquisition.h"
#include "MATH_CONSTANTS.h" // for TWO_PI #include "MATH_CONSTANTS.h" // for TWO_PI
#include <glog/logging.h> // for LOG
#include <cmath> // for log2 #include <cmath> // for log2
#include <fcntl.h> // libraries used by the GIPO #include <fcntl.h> // libraries used by the GIPO
#include <iostream> // for operator<< #include <iostream> // for operator<<
@ -29,6 +28,11 @@
#include <unistd.h> // for write, close, read, ssize_t #include <unistd.h> // for write, close, read, ssize_t
#include <utility> // for move #include <utility> // for move
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#ifndef TEMP_FAILURE_RETRY #ifndef TEMP_FAILURE_RETRY
#define TEMP_FAILURE_RETRY(exp) \ #define TEMP_FAILURE_RETRY(exp) \

8
src/algorithms/channel/adapters/CMakeLists.txt
View File

@ -26,9 +26,15 @@ target_link_libraries(channel_adapters
channel_libs channel_libs
PRIVATE PRIVATE
gnss_sdr_flags gnss_sdr_flags
Glog::glog
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(channel_adapters PRIVATE Glog::glog)
target_compile_definitions(channel_adapters PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(channel_adapters PRIVATE absl::flags absl::log)
endif()
target_include_directories(channel_adapters target_include_directories(channel_adapters
PUBLIC PUBLIC
${GNSSSDR_SOURCE_DIR}/src/core/interfaces ${GNSSSDR_SOURCE_DIR}/src/core/interfaces

13
src/algorithms/channel/adapters/channel.cc
View File

@ -22,10 +22,14 @@
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "telemetry_decoder_interface.h" #include "telemetry_decoder_interface.h"
#include "tracking_interface.h" #include "tracking_interface.h"
#include <glog/logging.h>
#include <stdexcept> // for std::invalid_argument #include <stdexcept> // for std::invalid_argument
#include <utility> // for std::move #include <utility> // for std::move
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
Channel::Channel(const ConfigurationInterface* configuration, Channel::Channel(const ConfigurationInterface* configuration,
uint32_t channel, uint32_t channel,
@ -77,10 +81,17 @@ Channel::Channel(const ConfigurationInterface* configuration,
{ {
doppler_step = configuration->property("Acquisition_" + signal_str + ".doppler_step", 500); doppler_step = configuration->property("Acquisition_" + signal_str + ".doppler_step", 500);
} }
#if USE_GLOG_AND_GFLAGS
if (FLAGS_doppler_step != 0) if (FLAGS_doppler_step != 0)
{ {
doppler_step = static_cast<uint32_t>(FLAGS_doppler_step); doppler_step = static_cast<uint32_t>(FLAGS_doppler_step);
} }
#else
if (absl::GetFlag(FLAGS_doppler_step) != 0)
{
doppler_step = static_cast<uint32_t>(absl::GetFlag(FLAGS_doppler_step));
}
#endif
DLOG(INFO) << "Channel " << channel_ << " Doppler_step = " << doppler_step; DLOG(INFO) << "Channel " << channel_ << " Doppler_step = " << doppler_step;
acq_->set_doppler_step(doppler_step); acq_->set_doppler_step(doppler_step);

9
src/algorithms/channel/libs/CMakeLists.txt
View File

@ -39,10 +39,15 @@ target_link_libraries(channel_libs
PRIVATE PRIVATE
core_libs core_libs
Boost::headers Boost::headers
Gflags::gflags
Glog::glog
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(channel_libs PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(channel_libs PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(channel_libs PRIVATE absl::flags absl::log)
endif()
target_include_directories(channel_libs target_include_directories(channel_libs
PUBLIC PUBLIC
${GNSSSDR_SOURCE_DIR}/src/core/receiver ${GNSSSDR_SOURCE_DIR}/src/core/receiver

7
src/algorithms/channel/libs/channel_fsm.cc
View File

@ -18,9 +18,14 @@
#include "channel_fsm.h" #include "channel_fsm.h"
#include "channel_event.h" #include "channel_event.h"
#include <glog/logging.h>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
ChannelFsm::ChannelFsm() ChannelFsm::ChannelFsm()
: queue_(nullptr), : queue_(nullptr),
channel_(0U), channel_(0U),

7
src/algorithms/channel/libs/channel_msg_receiver_cc.cc
View File

@ -17,12 +17,17 @@
#include "channel_msg_receiver_cc.h" #include "channel_msg_receiver_cc.h"
#include <glog/logging.h>
#include <gnuradio/gr_complex.h> #include <gnuradio/gr_complex.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <cstdint> #include <cstdint>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if PMT_USES_BOOST_ANY #if PMT_USES_BOOST_ANY
#include <boost/any.hpp> #include <boost/any.hpp>
namespace wht = boost; namespace wht = boost;

10
src/algorithms/conditioner/adapters/CMakeLists.txt
View File

@ -37,11 +37,15 @@ endif()
target_link_libraries(conditioner_adapters target_link_libraries(conditioner_adapters
PUBLIC PUBLIC
Gnuradio::runtime Gnuradio::runtime
PRIVATE
Gflags::gflags
Glog::glog
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(conditioner_adapters PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(conditioner_adapters PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(conditioner_adapters PRIVATE absl::flags absl::log)
endif()
target_include_directories(conditioner_adapters target_include_directories(conditioner_adapters
PUBLIC PUBLIC
${GNSSSDR_SOURCE_DIR}/src/core/interfaces ${GNSSSDR_SOURCE_DIR}/src/core/interfaces

6
src/algorithms/conditioner/adapters/array_signal_conditioner.cc
View File

@ -17,9 +17,13 @@
#include "array_signal_conditioner.h" #include "array_signal_conditioner.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
// Constructor // Constructor
ArraySignalConditioner::ArraySignalConditioner(std::shared_ptr<GNSSBlockInterface> data_type_adapt, ArraySignalConditioner::ArraySignalConditioner(std::shared_ptr<GNSSBlockInterface> data_type_adapt,

6
src/algorithms/conditioner/adapters/signal_conditioner.cc
View File

@ -16,10 +16,14 @@
*/ */
#include "signal_conditioner.h" #include "signal_conditioner.h"
#include <glog/logging.h>
#include <stdexcept> #include <stdexcept>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
// Constructor // Constructor
SignalConditioner::SignalConditioner(std::shared_ptr<GNSSBlockInterface> data_type_adapt, SignalConditioner::SignalConditioner(std::shared_ptr<GNSSBlockInterface> data_type_adapt,

9
src/algorithms/data_type_adapter/adapters/CMakeLists.txt
View File

@ -53,11 +53,16 @@ target_link_libraries(data_type_adapters
Gnuradio::blocks Gnuradio::blocks
data_type_gr_blocks data_type_gr_blocks
PRIVATE PRIVATE
Gflags::gflags
Glog::glog
Volk::volk Volk::volk
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(data_type_adapters PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(data_type_adapters PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(data_type_adapters PRIVATE absl::flags absl::log)
endif()
if(ENABLE_CLANG_TIDY) if(ENABLE_CLANG_TIDY)
if(CLANG_TIDY_EXE) if(CLANG_TIDY_EXE)
set_target_properties(data_type_adapters set_target_properties(data_type_adapters

7
src/algorithms/data_type_adapter/adapters/byte_to_short.cc
View File

@ -16,9 +16,14 @@
#include "byte_to_short.h" #include "byte_to_short.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
ByteToShort::ByteToShort(const ConfigurationInterface* configuration, ByteToShort::ByteToShort(const ConfigurationInterface* configuration,
std::string role, std::string role,

7
src/algorithms/data_type_adapter/adapters/ibyte_to_cbyte.cc
View File

@ -17,9 +17,14 @@
#include "ibyte_to_cbyte.h" #include "ibyte_to_cbyte.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#include <volk/volk.h> #include <volk/volk.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
IbyteToCbyte::IbyteToCbyte(const ConfigurationInterface* configuration, IbyteToCbyte::IbyteToCbyte(const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,

5
src/algorithms/data_type_adapter/adapters/ibyte_to_complex.cc
View File

@ -16,7 +16,12 @@
#include "ibyte_to_complex.h" #include "ibyte_to_complex.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h> #include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
IbyteToComplex::IbyteToComplex(const ConfigurationInterface* configuration, const std::string& role, IbyteToComplex::IbyteToComplex(const ConfigurationInterface* configuration, const std::string& role,

6
src/algorithms/data_type_adapter/adapters/ibyte_to_cshort.cc
View File

@ -17,9 +17,13 @@
#include "ibyte_to_cshort.h" #include "ibyte_to_cshort.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#include <volk/volk.h> #include <volk/volk.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
IbyteToCshort::IbyteToCshort(const ConfigurationInterface* configuration, IbyteToCshort::IbyteToCshort(const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,

6
src/algorithms/data_type_adapter/adapters/ishort_to_complex.cc
View File

@ -16,8 +16,12 @@
#include "ishort_to_complex.h" #include "ishort_to_complex.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
IshortToComplex::IshortToComplex(const ConfigurationInterface* configuration, IshortToComplex::IshortToComplex(const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,

6
src/algorithms/data_type_adapter/adapters/ishort_to_cshort.cc
View File

@ -17,9 +17,13 @@
#include "ishort_to_cshort.h" #include "ishort_to_cshort.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#include <volk/volk.h> #include <volk/volk.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
IshortToCshort::IshortToCshort(const ConfigurationInterface* configuration, IshortToCshort::IshortToCshort(const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,

9
src/algorithms/input_filter/adapters/CMakeLists.txt
View File

@ -47,11 +47,16 @@ target_link_libraries(input_filter_adapters
algorithms_libs algorithms_libs
input_filter_gr_blocks input_filter_gr_blocks
PRIVATE PRIVATE
Gflags::gflags
Glog::glog
Volk::volk Volk::volk
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(input_filter_adapters PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(input_filter_adapters PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(input_filter_adapters PRIVATE absl::flags absl::log)
endif()
if(GNURADIO_IS_38_OR_GREATER) if(GNURADIO_IS_38_OR_GREATER)
target_compile_definitions(input_filter_adapters PUBLIC -DGR_GREATER_38=1) target_compile_definitions(input_filter_adapters PUBLIC -DGR_GREATER_38=1)
endif() endif()

6
src/algorithms/input_filter/adapters/beamformer_filter.cc
View File

@ -17,9 +17,13 @@
#include "beamformer_filter.h" #include "beamformer_filter.h"
#include "beamformer.h" #include "beamformer.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#include <gnuradio/blocks/file_sink.h> #include <gnuradio/blocks/file_sink.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
BeamformerFilter::BeamformerFilter( BeamformerFilter::BeamformerFilter(
const ConfigurationInterface* configuration, const std::string& role, const ConfigurationInterface* configuration, const std::string& role,

6
src/algorithms/input_filter/adapters/fir_filter.cc
View File

@ -17,11 +17,15 @@
#include "fir_filter.h" #include "fir_filter.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#include <gnuradio/filter/pm_remez.h> #include <gnuradio/filter/pm_remez.h>
#include <volk/volk.h> #include <volk/volk.h>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
FirFilter::FirFilter(const ConfigurationInterface* configuration, FirFilter::FirFilter(const ConfigurationInterface* configuration,
std::string role, std::string role,

6
src/algorithms/input_filter/adapters/freq_xlating_fir_filter.cc
View File

@ -17,13 +17,17 @@
#include "freq_xlating_fir_filter.h" #include "freq_xlating_fir_filter.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#include <gnuradio/blocks/file_sink.h> #include <gnuradio/blocks/file_sink.h>
#include <gnuradio/filter/firdes.h> #include <gnuradio/filter/firdes.h>
#include <gnuradio/filter/pm_remez.h> #include <gnuradio/filter/pm_remez.h>
#include <volk/volk.h> #include <volk/volk.h>
#include <utility> #include <utility>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
FreqXlatingFirFilter::FreqXlatingFirFilter(const ConfigurationInterface* configuration, FreqXlatingFirFilter::FreqXlatingFirFilter(const ConfigurationInterface* configuration,
std::string role, std::string role,

6
src/algorithms/input_filter/adapters/notch_filter.cc
View File

@ -19,8 +19,12 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "notch_cc.h" #include "notch_cc.h"
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <glog/logging.h>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
NotchFilter::NotchFilter(const ConfigurationInterface* configuration, NotchFilter::NotchFilter(const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,

6
src/algorithms/input_filter/adapters/notch_filter_lite.cc
View File

@ -19,9 +19,13 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "notch_lite_cc.h" #include "notch_lite_cc.h"
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <glog/logging.h>
#include <algorithm> // for max #include <algorithm> // for max
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
NotchFilterLite::NotchFilterLite(const ConfigurationInterface* configuration, NotchFilterLite::NotchFilterLite(const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,

6
src/algorithms/input_filter/adapters/pulse_blanking_filter.cc
View File

@ -19,12 +19,16 @@
#include "pulse_blanking_filter.h" #include "pulse_blanking_filter.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <glog/logging.h>
#include <gnuradio/filter/firdes.h> #include <gnuradio/filter/firdes.h>
#include <cmath> #include <cmath>
#include <utility> #include <utility>
#include <vector> #include <vector>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
PulseBlankingFilter::PulseBlankingFilter(const ConfigurationInterface* configuration, PulseBlankingFilter::PulseBlankingFilter(const ConfigurationInterface* configuration,
std::string role, std::string role,

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

@ -109,10 +109,15 @@ target_link_libraries(algorithms_libs
core_system_parameters core_system_parameters
Volk::volk Volk::volk
Volkgnsssdr::volkgnsssdr Volkgnsssdr::volkgnsssdr
Gflags::gflags
Glog::glog
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(algorithms_libs PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(algorithms_libs PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(algorithms_libs PRIVATE absl::flags absl::log)
endif()
if(GNURADIO_USES_STD_POINTERS) if(GNURADIO_USES_STD_POINTERS)
target_compile_definitions(algorithms_libs target_compile_definitions(algorithms_libs
PUBLIC -DGNURADIO_USES_STD_POINTERS=1 PUBLIC -DGNURADIO_USES_STD_POINTERS=1
@ -208,13 +213,14 @@ else()
target_link_libraries(gnss_sdr_flags PRIVATE Boost::filesystem Boost::system) target_link_libraries(gnss_sdr_flags PRIVATE Boost::filesystem Boost::system)
endif() endif()
target_link_libraries(gnss_sdr_flags if(ENABLE_GLOG_AND_GFLAGS)
PUBLIC target_link_libraries(gnss_sdr_flags PUBLIC Gflags::gflags)
Gflags::gflags target_compile_definitions(gnss_sdr_flags PUBLIC -DUSE_GLOG_AND_GFLAGS=1)
) if(GFLAGS_GREATER_20 OR "${LOCAL_GFLAGS}")
target_compile_definitions(gnss_sdr_flags PRIVATE -DGFLAGS_GREATER_2_0=1)
if(GFLAGS_GREATER_20 OR ${LOCAL_GFLAGS}) endif()
target_compile_definitions(gnss_sdr_flags PRIVATE -DGFLAGS_GREATER_2_0=1) else()
target_link_libraries(gnss_sdr_flags PUBLIC absl::flags)
endif() endif()
target_compile_definitions(gnss_sdr_flags target_compile_definitions(gnss_sdr_flags

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

@ -1,7 +1,7 @@
/*! /*!
* \file gnss_sdr_flags.cc * \file gnss_sdr_flags.cc
* \brief Helper file for gnss-sdr commandline flags * \brief Helper file for gnss-sdr commandline flags
* \author Carles Fernandez-Prades, 2018. cfernandez(at)cttc.es * \author Carles Fernandez-Prades, 2018-2024. cfernandez(at)cttc.es
* *
* *
* ----------------------------------------------------------------------------- * -----------------------------------------------------------------------------
@ -9,7 +9,7 @@
* GNSS-SDR is a Global Navigation Satellite System software-defined receiver. * GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
* This file is part of GNSS-SDR. * This file is part of GNSS-SDR.
* *
* Copyright (C) 2010-2020 (see AUTHORS file for a list of contributors) * Copyright (C) 2010-2024 (see AUTHORS file for a list of contributors)
* SPDX-License-Identifier: GPL-3.0-or-later * SPDX-License-Identifier: GPL-3.0-or-later
* *
* ----------------------------------------------------------------------------- * -----------------------------------------------------------------------------
@ -19,9 +19,8 @@
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include <iostream> #include <iostream>
#include <string>
#if USE_GLOG_AND_GFLAGS
DEFINE_string(c, "-", "Path to the configuration file (if set, overrides --config_file)."); DEFINE_string(c, "-", "Path to the configuration file (if set, overrides --config_file).");
DEFINE_string(config_file, std::string(GNSSSDR_INSTALL_DIR "/share/gnss-sdr/conf/default.conf"), DEFINE_string(config_file, std::string(GNSSSDR_INSTALL_DIR "/share/gnss-sdr/conf/default.conf"),
@ -235,3 +234,26 @@ DEFINE_validator(pll_bw_hz, &ValidatePllBw);
DEFINE_validator(carrier_smoothing_factor, &ValidateCarrierSmoothingFactor); DEFINE_validator(carrier_smoothing_factor, &ValidateCarrierSmoothingFactor);
#endif #endif
#else
ABSL_FLAG(std::string, c, "-", "Path to the configuration file (if set, overrides --config_file).");
ABSL_FLAG(std::string, config_file, std::string(GNSSSDR_INSTALL_DIR "/share/gnss-sdr/conf/default.conf"), "Path to the configuration file.");
ABSL_FLAG(std::string, log_dir, "", "Directory for log files");
ABSL_FLAG(std::string, s, "-", "If defined, path to the file containing the signal samples (overrides the configuration file and --signal_source).");
ABSL_FLAG(std::string, signal_source, "-", "If defined, path to the file containing the signal samples (overrides the configuration file).");
ABSL_FLAG(std::string, timestamp_source, "-", "If defined, path to the file containing the signal timestamp data (overrides the configuration file).");
ABSL_FLAG(bool, rf_shutdown, true, "If set to false, AD9361 RF channels are not shut down when exiting the program. Useful to leave the AD9361 configured and running.");
ABSL_FLAG(int32_t, doppler_max, 0, "If defined, sets the maximum Doppler value in the search grid, in Hz (overrides the configuration file).");
ABSL_FLAG(int32_t, doppler_step, 0, "If defined, sets the frequency step in the search grid, in Hz (overrides the configuration file).");
ABSL_FLAG(int32_t, cn0_samples, 20, "Number of correlator outputs used for CN0 estimation.");
ABSL_FLAG(int32_t, cn0_min, 25, "Minimum valid CN0 (in dB-Hz).");
ABSL_FLAG(int32_t, max_carrier_lock_fail, 5000, "Maximum number of carrier lock failures before dropping a satellite.");
ABSL_FLAG(int32_t, max_lock_fail, 50, "Maximum number of code lock failures before dropping a satellite.");
ABSL_FLAG(double, carrier_lock_th, 0.7, "Carrier lock threshold (in rad).");
ABSL_FLAG(double, dll_bw_hz, 0.0, "If defined, bandwidth of the DLL low pass filter, in Hz (overrides the configuration file).");
ABSL_FLAG(double, pll_bw_hz, 0.0, "If defined, bandwidth of the PLL low pass filter, in Hz (overrides the configuration file).");
ABSL_FLAG(int32_t, carrier_smoothing_factor, DEFAULT_CARRIER_SMOOTHING_FACTOR, "Sets carrier smoothing factor M (overrides the configuration file)");
ABSL_FLAG(std::string, RINEX_version, "-", "If defined, specifies the RINEX version (2.11 or 3.02). Overrides the configuration file.");
ABSL_FLAG(std::string, RINEX_name, "-", "If defined, specifies the RINEX files base name");
ABSL_FLAG(bool, keyboard, true, "If set to false, it disables the keyboard listener (so the receiver cannot be stopped with q+[Enter])");
#endif

128
src/algorithms/libs/gnss_sdr_flags.h
View File

@ -1,7 +1,7 @@
/*! /*!
* \file gnss_sdr_flags.h * \file gnss_sdr_flags.h
* \brief Helper file for gnss-sdr commandline flags * \brief Helper file for gnss-sdr commandline flags
* \author Carles Fernandez-Prades, 2018. cfernandez(at)cttc.es * \author Carles Fernandez-Prades, 2018-2024. cfernandez(at)cttc.es
* *
* *
* ----------------------------------------------------------------------------- * -----------------------------------------------------------------------------
@ -9,7 +9,7 @@
* GNSS-SDR is a Global Navigation Satellite System software-defined receiver. * GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
* This file is part of GNSS-SDR. * This file is part of GNSS-SDR.
* *
* Copyright (C) 2010-2020 (see AUTHORS file for a list of contributors) * Copyright (C) 2010-2024 (see AUTHORS file for a list of contributors)
* SPDX-License-Identifier: GPL-3.0-or-later * SPDX-License-Identifier: GPL-3.0-or-later
* *
* ----------------------------------------------------------------------------- * -----------------------------------------------------------------------------
@ -18,9 +18,20 @@
#ifndef GNSS_SDR_GNSS_SDR_FLAGS_H #ifndef GNSS_SDR_GNSS_SDR_FLAGS_H
#define GNSS_SDR_GNSS_SDR_FLAGS_H #define GNSS_SDR_GNSS_SDR_FLAGS_H
#include <gflags/gflags.h>
#include <cstdint> #include <cstdint>
#include <string>
#if USE_GLOG_AND_GFLAGS
#include <gflags/gflags.h>
#else
#include <absl/flags/declare.h>
#include <absl/flags/flag.h>
#include <cstdlib>
#include <iostream>
#include <sys/stat.h>
#include <vector>
#endif
/** \addtogroup Algorithms_Library /** \addtogroup Algorithms_Library
* \{ */ * \{ */
@ -28,7 +39,7 @@
* Library for command-line handling. * Library for command-line handling.
* \{ */ * \{ */
#if USE_GLOG_AND_GFLAGS
DECLARE_string(c); //!< Path to the configuration file. DECLARE_string(c); //!< Path to the configuration file.
DECLARE_string(config_file); //!< Path to the configuration file. DECLARE_string(config_file); //!< Path to the configuration file.
@ -62,6 +73,113 @@ DECLARE_string(RINEX_version); //!< If defined, specifies the RINEX version (2.
DECLARE_string(RINEX_name); //!< If defined, specifies the RINEX files base name DECLARE_string(RINEX_name); //!< If defined, specifies the RINEX files base name
DECLARE_bool(keyboard); //!< If set to false, disables the keyboard listener. Only for debug purposes (e.g. ASAN mode termination) DECLARE_bool(keyboard); //!< If set to false, disables the keyboard listener. Only for debug purposes (e.g. ASAN mode termination)
#else
ABSL_DECLARE_FLAG(std::string, c); //!< Path to the configuration file.
ABSL_DECLARE_FLAG(std::string, config_file); //!< Path to the configuration file.
ABSL_DECLARE_FLAG(std::string, log_dir); //!< Path to the folder in which logging will be stored.
// Declare flags for signal sources
ABSL_DECLARE_FLAG(std::string, s); //!< Path to the file containing the signal samples.
ABSL_DECLARE_FLAG(std::string, signal_source); //!< Path to the file containing the signal samples.
ABSL_DECLARE_FLAG(std::string, timestamp_source); //!< Path to the file containing the signal samples.
ABSL_DECLARE_FLAG(bool, rf_shutdown); //!< Shutdown RF when program exits.
// Declare flags for acquisition blocks
ABSL_DECLARE_FLAG(int32_t, doppler_max); //!< If defined, maximum Doppler value in the search grid, in Hz (overrides the configuration file).
ABSL_DECLARE_FLAG(int32_t, doppler_step); //!< If defined, sets the frequency step in the search grid, in Hz, in Hz (overrides the configuration file).
// Declare flags for tracking blocks
ABSL_DECLARE_FLAG(int32_t, cn0_samples); //!< Number of correlator outputs used for CN0 estimation.
ABSL_DECLARE_FLAG(int32_t, cn0_min); //!< Minimum valid CN0 (in dB-Hz).
ABSL_DECLARE_FLAG(int32_t, max_lock_fail); //!< Maximum number of code lock failures before dropping a satellite.
ABSL_DECLARE_FLAG(int32_t, max_carrier_lock_fail); //!< Maximum number of carrier lock failures before dropping a satellite.
ABSL_DECLARE_FLAG(double, carrier_lock_th); //!< Carrier lock threshold (in rad).
ABSL_DECLARE_FLAG(double, dll_bw_hz); //!< Bandwidth of the DLL low pass filter, in Hz (overrides the configuration file).
ABSL_DECLARE_FLAG(double, pll_bw_hz); //!< Bandwidth of the PLL low pass filter, in Hz (overrides the configuration file).
// Declare flags for observables block
ABSL_DECLARE_FLAG(int32_t, carrier_smoothing_factor); //!< Sets carrier smoothing factor M (overrides the configuration file).
const int32_t DEFAULT_CARRIER_SMOOTHING_FACTOR = 200;
// Declare flags for PVT
ABSL_DECLARE_FLAG(std::string, RINEX_version); //!< If defined, specifies the RINEX version (2.11 or 3.02). Overrides the configuration file.
ABSL_DECLARE_FLAG(std::string, RINEX_name); //!< If defined, specifies the RINEX files base name
ABSL_DECLARE_FLAG(bool, keyboard); //!< If set to false, disables the keyboard listener. Only for debug purposes (e.g. ASAN mode termination)
static inline void GetTempDirectories(std::vector<std::string>& list)
{
list.clear();
// Directories, in order of preference. If we find a dir that
// exists, we stop adding other less-preferred dirs
const char* candidates[] = {
// Non-null only during unittest/regtest
std::getenv("TEST_TMPDIR"),
// Explicitly-supplied temp dirs
std::getenv("TMPDIR"),
std::getenv("TMP"),
// If all else fails
"/tmp",
};
for (auto d : candidates)
{
if (!d) continue; // Empty env var
// Make sure we don't surprise anyone who's expecting a '/'
std::string dstr = d;
if (dstr[dstr.size() - 1] != '/')
{
dstr += "/";
}
list.push_back(dstr);
struct stat statbuf;
if (!stat(d, &statbuf) && S_ISDIR(statbuf.st_mode))
{
// We found a dir that exists - we're done.
return;
}
}
}
static inline void GetExistingTempDirectories(std::vector<std::string>& list)
{
GetTempDirectories(list);
auto i_dir = list.begin();
while (i_dir != list.end())
{
if (access(i_dir->c_str(), 0))
{
i_dir = list.erase(i_dir);
}
else
{
++i_dir;
}
};
}
static inline std::string GetTempDir()
{
std::vector<std::string> temp_directories_list;
GetExistingTempDirectories(temp_directories_list);
if (temp_directories_list.empty())
{
std::cerr << "No temporary directory found\n";
exit(EXIT_FAILURE);
}
// Use first directory from list of existing temporary directories.
return temp_directories_list.front();
}
#endif
/** \} */ /** \} */
/** \} */ /** \} */
#endif // GNSS_SDR_GNSS_SDR_FLAGS_H #endif // GNSS_SDR_GNSS_SDR_FLAGS_H

6
src/algorithms/libs/pass_through.cc
View File

@ -18,12 +18,16 @@
#include "pass_through.h" #include "pass_through.h"
#include "configuration_interface.h" #include "configuration_interface.h"
#include <glog/logging.h>
#include <gnuradio/gr_complex.h> #include <gnuradio/gr_complex.h>
#include <volk/volk_complex.h> #include <volk/volk_complex.h>
#include <cstdint> // for int8_t #include <cstdint> // for int8_t
#include <ostream> // for operator<< #include <ostream> // for operator<<
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
Pass_Through::Pass_Through(const ConfigurationInterface* configuration, Pass_Through::Pass_Through(const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,

9
src/algorithms/libs/rtklib/CMakeLists.txt
View File

@ -70,12 +70,17 @@ target_link_libraries(algorithms_libs_rtklib
core_system_parameters core_system_parameters
algorithms_libs algorithms_libs
Armadillo::armadillo Armadillo::armadillo
Gflags::gflags
Glog::glog
LAPACK::LAPACK LAPACK::LAPACK
BLAS::BLAS BLAS::BLAS
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(algorithms_libs_rtklib PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(algorithms_libs_rtklib PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(algorithms_libs_rtklib PRIVATE absl::flags absl::log)
endif()
if(ENABLE_ARMA_NO_DEBUG) if(ENABLE_ARMA_NO_DEBUG)
target_compile_definitions(algorithms_libs_rtklib target_compile_definitions(algorithms_libs_rtklib
PRIVATE -DARMA_NO_BOUND_CHECKING=1 PRIVATE -DARMA_NO_BOUND_CHECKING=1

7
src/algorithms/libs/rtklib/rtklib_rtkcmn.cc
View File

@ -30,7 +30,6 @@
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
#include "rtklib_rtkcmn.h" #include "rtklib_rtkcmn.h"
#include <glog/logging.h>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <cstring> #include <cstring>
@ -43,6 +42,12 @@
#include <sys/types.h> #include <sys/types.h>
#include <vector> #include <vector>
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
const double GPST0[] = {1980, 1, 6, 0, 0, 0}; /* gps time reference */ const double GPST0[] = {1980, 1, 6, 0, 0, 0}; /* gps time reference */
const double GST0[] = {1999, 8, 22, 0, 0, 0}; /* galileo system time reference */ const double GST0[] = {1999, 8, 22, 0, 0, 0}; /* galileo system time reference */
const double BDT0[] = {2006, 1, 1, 0, 0, 0}; /* beidou time reference */ const double BDT0[] = {2006, 1, 1, 0, 0, 0}; /* beidou time reference */

8
src/algorithms/observables/adapters/CMakeLists.txt
View File

@ -29,9 +29,15 @@ target_link_libraries(obs_adapters
core_system_parameters core_system_parameters
PRIVATE PRIVATE
gnss_sdr_flags gnss_sdr_flags
Glog::glog
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(obs_adapters PRIVATE Glog::glog)
target_compile_definitions(obs_adapters PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(obs_adapters PRIVATE absl::flags absl::log)
endif()
if(ENABLE_CLANG_TIDY) if(ENABLE_CLANG_TIDY)
if(CLANG_TIDY_EXE) if(CLANG_TIDY_EXE)
set_target_properties(obs_adapters set_target_properties(obs_adapters

11
src/algorithms/observables/adapters/hybrid_observables.cc
View File

@ -19,9 +19,14 @@
#include "configuration_interface.h" #include "configuration_interface.h"
#include "gnss_sdr_flags.h" #include "gnss_sdr_flags.h"
#include "obs_conf.h" #include "obs_conf.h"
#include <glog/logging.h>
#include <ostream> // for operator<< #include <ostream> // for operator<<
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
HybridObservables::HybridObservables(const ConfigurationInterface* configuration, HybridObservables::HybridObservables(const ConfigurationInterface* configuration,
const std::string& role, const std::string& role,
unsigned int in_streams, unsigned int in_streams,
@ -45,7 +50,11 @@ HybridObservables::HybridObservables(const ConfigurationInterface* configuration
conf.always_output_gs = configuration->property("PVT.an_output_enabled", conf.always_output_gs) || configuration->property(role + ".always_output_gs", conf.always_output_gs); conf.always_output_gs = configuration->property("PVT.an_output_enabled", conf.always_output_gs) || configuration->property(role + ".always_output_gs", conf.always_output_gs);
conf.enable_E6 = configuration->property("PVT.use_e6_for_pvt", conf.enable_E6); conf.enable_E6 = configuration->property("PVT.use_e6_for_pvt", conf.enable_E6);
#if USE_GLOG_AND_GFLAGS
if (FLAGS_carrier_smoothing_factor == DEFAULT_CARRIER_SMOOTHING_FACTOR) if (FLAGS_carrier_smoothing_factor == DEFAULT_CARRIER_SMOOTHING_FACTOR)
#else
if (absl::GetFlag(FLAGS_carrier_smoothing_factor) == DEFAULT_CARRIER_SMOOTHING_FACTOR)
#endif
{ {
conf.smoothing_factor = configuration->property(role + ".smoothing_factor", conf.smoothing_factor); conf.smoothing_factor = configuration->property(role + ".smoothing_factor", conf.smoothing_factor);
} }

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

@ -31,12 +31,17 @@ target_link_libraries(obs_gr_blocks
PRIVATE PRIVATE
algorithms_libs algorithms_libs
core_system_parameters core_system_parameters
Gflags::gflags
Glog::glog
Matio::matio Matio::matio
Gnuradio::pmt Gnuradio::pmt
) )
if(ENABLE_GLOG_AND_GFLAGS)
target_link_libraries(obs_gr_blocks PRIVATE Gflags::gflags Glog::glog)
target_compile_definitions(obs_gr_blocks PRIVATE -DUSE_GLOG_AND_GFLAGS=1)
else()
target_link_libraries(obs_gr_blocks PRIVATE absl::flags absl::log)
endif()
target_include_directories(obs_gr_blocks target_include_directories(obs_gr_blocks
PUBLIC PUBLIC
${GNSSSDR_SOURCE_DIR}/src/core/interfaces ${GNSSSDR_SOURCE_DIR}/src/core/interfaces

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

@ -23,7 +23,6 @@
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include "gnss_sdr_make_unique.h" #include "gnss_sdr_make_unique.h"
#include "gnss_synchro.h" #include "gnss_synchro.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <matio.h> #include <matio.h>
#include <pmt/pmt.h> #include <pmt/pmt.h>
@ -36,6 +35,12 @@
#include <limits> // for numeric_limits #include <limits> // for numeric_limits
#include <utility> // for move #include <utility> // for move
#if USE_GLOG_AND_GFLAGS
#include <glog/logging.h>
#else
#include <absl/log/log.h>
#endif
#if PMT_USES_BOOST_ANY #if PMT_USES_BOOST_ANY
#include <boost/any.hpp> #include <boost/any.hpp>
namespace wht = boost; namespace wht = boost;

Some files were not shown because too many files have changed in this diff Show More