Replace boost::filesystem with std (#6432)

.github/workflows/osrm-backend.yml

@@ -152,7 +152,6 @@ jobs:
             >&2 echo "No berlin-latest.geojson found"
             exit 1
           fi
-
           # removing `.osrm.nbg` to check that whole pipeline works without it
           rm -rf "${PWD}/berlin-latest.osrm.nbg"
 
@@ -740,3 +739,4 @@ jobs:
     needs: [build-test-publish, docker-image-matrix, windows-release-node, benchmarks]
     steps:
     - run: echo "CI complete"
+

CHANGELOG.md

@@ -44,6 +44,7 @@
       - CHANGED: Avoid copy of std::function-based callback in path unpacking [#6895](https://github.com/Project-OSRM/osrm-backend/pull/6895)
       - CHANGED: Replace boost::hash by std::hash [#6892](https://github.com/Project-OSRM/osrm-backend/pull/6892)
       - CHANGED: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551)
+      - CHANGED: Replace boost::filesystem with std::filesystem [#6432](https://github.com/Project-OSRM/osrm-backend/pull/6432)
       - CHANGED: Update Conan Boost version to 1.85.0. [#6868](https://github.com/Project-OSRM/osrm-backend/pull/6868)
       - FIXED: Fix an error in a RouteParameters AnnotationsType operator overload. [#6646](https://github.com/Project-OSRM/osrm-backend/pull/6646)
       - ADDED: Add support for "unlimited" to be passed as a value for the default-radius and max-matching-radius flags. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)

features/support/env.js

@@ -42,7 +42,7 @@ module.exports = function () {
         this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
         this.OSRM_IP = process.env.OSRM_IP || '127.0.0.1';
         this.OSRM_CONNECTION_RETRIES = process.env.OSRM_CONNECTION_RETRIES && parseInt(process.env.OSRM_CONNECTION_RETRIES) || 10;
-        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.0;
+        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.1;
 
         this.HOST = `http://${this.OSRM_IP}:${this.OSRM_PORT}`;
 

include/contractor/contractor_config.hpp

@@ -31,8 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/io_config.hpp"
 #include "updater/updater_config.hpp"
 
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
-
 #include <string>
 
 namespace osrm::contractor
@@ -47,7 +46,7 @@ struct ContractorConfig final : storage::IOConfig
     }
 
     // Infer the output names from the path of the .osrm file
-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
     {
         IOConfig::UseDefaultOutputNames(base);
         updater_config.UseDefaultOutputNames(base);

include/contractor/files.hpp

@@ -9,7 +9,7 @@ namespace osrm::contractor::files
 {
 // reads .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void readGraph(const boost::filesystem::path &path,
+inline void readGraph(const std::filesystem::path &path,
                       std::unordered_map<std::string, ContractedMetricT> &metrics,
                       std::uint32_t &connectivity_checksum)
 {
@@ -30,7 +30,7 @@ inline void readGraph(const boost::filesystem::path &path,
 
 // writes .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void writeGraph(const boost::filesystem::path &path,
+inline void writeGraph(const std::filesystem::path &path,
                        const std::unordered_map<std::string, ContractedMetricT> &metrics,
                        const std::uint32_t connectivity_checksum)
 {

include/customizer/customizer_config.hpp

@@ -1,9 +1,8 @@
 #ifndef OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
 #define OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
 
-#include <boost/filesystem/path.hpp>
-
 #include <array>
+#include <filesystem>
 #include <string>
 
 #include "storage/io_config.hpp"
@@ -27,7 +26,7 @@ struct CustomizationConfig final : storage::IOConfig
     {
     }
 
-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
     {
         IOConfig::UseDefaultOutputNames(base);
         updater_config.UseDefaultOutputNames(base);

include/customizer/edge_based_graph.hpp

@@ -9,7 +9,7 @@
 
 #include "storage/shared_memory_ownership.hpp"
 
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
 
 namespace osrm::customizer
 {

include/customizer/files.hpp

@@ -14,7 +14,7 @@ namespace osrm::customizer::files
 
 // reads .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void readCellMetrics(const boost::filesystem::path &path,
+inline void readCellMetrics(const std::filesystem::path &path,
                             std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
     static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@@ -44,7 +44,7 @@ inline void readCellMetrics(const boost::filesystem::path &path,
 // writes .osrm.cell_metrics file
 template <typename CellMetricT>
 inline void
-writeCellMetrics(const boost::filesystem::path &path,
+writeCellMetrics(const std::filesystem::path &path,
                  const std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
     static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@@ -72,7 +72,7 @@ writeCellMetrics(const boost::filesystem::path &path,
 
 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const boost::filesystem::path &path,
+inline void readGraph(const std::filesystem::path &path,
                       MultiLevelGraphT &graph,
                       std::uint32_t &connectivity_checksum)
 {
@@ -88,7 +88,7 @@ inline void readGraph(const boost::filesystem::path &path,
 
 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const boost::filesystem::path &path,
+inline void writeGraph(const std::filesystem::path &path,
                        const MultiLevelGraphT &graph,
                        const std::uint32_t connectivity_checksum)
 {

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -177,7 +177,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     SharedRTree m_static_rtree;
     std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
-    boost::filesystem::path file_index_path;
+    std::filesystem::path file_index_path;
 
     std::optional<extractor::IntersectionBearingsView> intersection_bearings_view;
 

include/engine/engine_config.hpp

@@ -31,8 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/storage_config.hpp"
 #include "osrm/datasets.hpp"
 
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
-
 #include <set>
 #include <string>
 
@@ -83,7 +82,7 @@ struct EngineConfig final
     boost::optional<double> default_radius = -1.0;
     int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
     bool use_shared_memory = true;
-    boost::filesystem::path memory_file;
+    std::filesystem::path memory_file;
     bool use_mmap = true;
     Algorithm algorithm = Algorithm::CH;
     std::vector<storage::FeatureDataset> disable_feature_dataset;

include/extractor/extractor_config.hpp

@@ -28,13 +28,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTOR_CONFIG_HPP
 #define EXTRACTOR_CONFIG_HPP
 
-#include <boost/filesystem/path.hpp>
+#include "storage/io_config.hpp"
 
 #include <array>
+#include <filesystem>
 #include <string>
 
-#include "storage/io_config.hpp"
-
 namespace osrm::extractor
 {
 
@@ -71,14 +70,14 @@ struct ExtractorConfig final : storage::IOConfig
     {
     }
 
-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
     {
         IOConfig::UseDefaultOutputNames(base);
     }
 
-    boost::filesystem::path input_path;
+    std::filesystem::path input_path;
-    boost::filesystem::path profile_path;
+    std::filesystem::path profile_path;
-    std::vector<boost::filesystem::path> location_dependent_data_paths;
+    std::vector<std::filesystem::path> location_dependent_data_paths;
     std::string data_version;
 
     unsigned requested_num_threads = 0;

include/extractor/files.hpp

@@ -23,9 +23,9 @@ namespace osrm::extractor::files
 
 // writes the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-inline void writeIntersections(const boost::filesystem::path &path,
+void writeIntersections(const std::filesystem::path &path,
-                               const IntersectionBearingsT &intersection_bearings,
+                        const IntersectionBearingsT &intersection_bearings,
-                               const EntryClassVectorT &entry_classes)
+                        const EntryClassVectorT &entry_classes)
 {
     static_assert(std::is_same<IntersectionBearingsContainer, IntersectionBearingsT>::value ||
                       std::is_same<IntersectionBearingsView, IntersectionBearingsT>::value,
@@ -39,9 +39,9 @@ inline void writeIntersections(const boost::filesystem::path &path,
 
 // read the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-inline void readIntersections(const boost::filesystem::path &path,
+void readIntersections(const std::filesystem::path &path,
-                              IntersectionBearingsT &intersection_bearings,
+                       IntersectionBearingsT &intersection_bearings,
-                              EntryClassVectorT &entry_classes)
+                       EntryClassVectorT &entry_classes)
 {
     static_assert(std::is_same<IntersectionBearingsContainer, IntersectionBearingsT>::value ||
                       std::is_same<IntersectionBearingsView, IntersectionBearingsT>::value,
@@ -54,8 +54,7 @@ inline void readIntersections(const boost::filesystem::path &path,
 }
 
 // reads .osrm.properties
-inline void readProfileProperties(const boost::filesystem::path &path,
+inline void readProfileProperties(const std::filesystem::path &path, ProfileProperties &properties)
-                                  ProfileProperties &properties)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -64,7 +63,7 @@ inline void readProfileProperties(const boost::filesystem::path &path,
 }
 
 // writes .osrm.properties
-inline void writeProfileProperties(const boost::filesystem::path &path,
+inline void writeProfileProperties(const std::filesystem::path &path,
                                    const ProfileProperties &properties)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -74,7 +73,7 @@ inline void writeProfileProperties(const boost::filesystem::path &path,
 }
 
 template <typename EdgeBasedEdgeVector>
-void writeEdgeBasedGraph(const boost::filesystem::path &path,
+void writeEdgeBasedGraph(const std::filesystem::path &path,
                          EdgeID const number_of_edge_based_nodes,
                          const EdgeBasedEdgeVector &edge_based_edge_list,
                          const std::uint32_t connectivity_checksum)
@@ -92,7 +91,7 @@ void writeEdgeBasedGraph(const boost::filesystem::path &path,
 
 // reads .osrm.ebg file
 template <typename EdgeBasedEdgeVector>
-void readEdgeBasedGraph(const boost::filesystem::path &path,
+void readEdgeBasedGraph(const std::filesystem::path &path,
                         EdgeID &number_of_edge_based_nodes,
                         EdgeBasedEdgeVector &edge_based_edge_list,
                         std::uint32_t &connectivity_checksum)
@@ -108,9 +107,9 @@ void readEdgeBasedGraph(const boost::filesystem::path &path,
 
 // reads .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-inline void readNodes(const boost::filesystem::path &path,
+void readNodes(const std::filesystem::path &path,
-                      CoordinatesT &coordinates,
+               CoordinatesT &coordinates,
-                      PackedOSMIDsT &osm_node_ids)
+               PackedOSMIDsT &osm_node_ids)
 {
     static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
     static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
@@ -124,7 +123,7 @@ inline void readNodes(const boost::filesystem::path &path,
 
 // reads only coordinates from .osrm.nbg_nodes
 template <typename CoordinatesT>
-inline void readNodeCoordinates(const boost::filesystem::path &path, CoordinatesT &coordinates)
+void readNodeCoordinates(const std::filesystem::path &path, CoordinatesT &coordinates)
 {
     static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
 
@@ -136,9 +135,9 @@ inline void readNodeCoordinates(const boost::filesystem::path &path, Coordinates
 
 // writes .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-inline void writeNodes(const boost::filesystem::path &path,
+void writeNodes(const std::filesystem::path &path,
-                       const CoordinatesT &coordinates,
+                const CoordinatesT &coordinates,
-                       const PackedOSMIDsT &osm_node_ids)
+                const PackedOSMIDsT &osm_node_ids)
 {
     static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
     static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
@@ -151,7 +150,7 @@ inline void writeNodes(const boost::filesystem::path &path,
 }
 
 // reads .osrm.cnbg_to_ebg
-inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGToEBG> &mapping)
+inline void readNBGMapping(const std::filesystem::path &path, std::vector<NBGToEBG> &mapping)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -160,8 +159,7 @@ inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGT
 }
 
 // writes .osrm.cnbg_to_ebg
-inline void writeNBGMapping(const boost::filesystem::path &path,
+inline void writeNBGMapping(const std::filesystem::path &path, const std::vector<NBGToEBG> &mapping)
-                            const std::vector<NBGToEBG> &mapping)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -170,7 +168,7 @@ inline void writeNBGMapping(const boost::filesystem::path &path,
 }
 
 // reads .osrm.datasource_names
-inline void readDatasources(const boost::filesystem::path &path, Datasources &sources)
+inline void readDatasources(const std::filesystem::path &path, Datasources &sources)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -179,7 +177,7 @@ inline void readDatasources(const boost::filesystem::path &path, Datasources &so
 }
 
 // writes .osrm.datasource_names
-inline void writeDatasources(const boost::filesystem::path &path, Datasources &sources)
+inline void writeDatasources(const std::filesystem::path &path, Datasources &sources)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -189,7 +187,7 @@ inline void writeDatasources(const boost::filesystem::path &path, Datasources &s
 
 // reads .osrm.geometry
 template <typename SegmentDataT>
-inline void readSegmentData(const boost::filesystem::path &path, SegmentDataT &segment_data)
+void readSegmentData(const std::filesystem::path &path, SegmentDataT &segment_data)
 {
     static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                       std::is_same<SegmentDataView, SegmentDataT>::value,
@@ -202,7 +200,7 @@ inline void readSegmentData(const boost::filesystem::path &path, SegmentDataT &s
 
 // writes .osrm.geometry
 template <typename SegmentDataT>
-inline void writeSegmentData(const boost::filesystem::path &path, const SegmentDataT &segment_data)
+void writeSegmentData(const std::filesystem::path &path, const SegmentDataT &segment_data)
 {
     static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                       std::is_same<SegmentDataView, SegmentDataT>::value,
@@ -215,7 +213,7 @@ inline void writeSegmentData(const boost::filesystem::path &path, const SegmentD
 
 // reads .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_data)
+inline void readNodeData(const std::filesystem::path &path, NodeDataT &node_data)
 {
     static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                       std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@@ -229,7 +227,7 @@ inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_da
 
 // writes .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &node_data)
+inline void writeNodeData(const std::filesystem::path &path, const NodeDataT &node_data)
 {
     static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                       std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@@ -243,7 +241,7 @@ inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &
 
 // reads .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void readTurnLaneDescriptions(const boost::filesystem::path &path,
+inline void readTurnLaneDescriptions(const std::filesystem::path &path,
                                      OffsetsT &turn_offsets,
                                      MaskT &turn_masks)
 {
@@ -260,7 +258,7 @@ inline void readTurnLaneDescriptions(const boost::filesystem::path &path,
 
 // writes .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
+inline void writeTurnLaneDescriptions(const std::filesystem::path &path,
                                       const OffsetsT &turn_offsets,
                                       const MaskT &turn_masks)
 {
@@ -277,7 +275,7 @@ inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
 
 // reads .osrm.tld
 template <typename TurnLaneDataT>
-inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT &turn_lane_data)
+inline void readTurnLaneData(const std::filesystem::path &path, TurnLaneDataT &turn_lane_data)
 {
     static_assert(
         std::is_same<typename TurnLaneDataT::value_type, util::guidance::LaneTupleIdPair>::value,
@@ -291,7 +289,7 @@ inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT
 
 // writes .osrm.tld
 template <typename TurnLaneDataT>
-inline void writeTurnLaneData(const boost::filesystem::path &path,
+inline void writeTurnLaneData(const std::filesystem::path &path,
                               const TurnLaneDataT &turn_lane_data)
 {
     static_assert(
@@ -306,7 +304,7 @@ inline void writeTurnLaneData(const boost::filesystem::path &path,
 
 // reads .osrm.timestamp
 template <typename TimestampDataT>
-inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &timestamp)
+inline void readTimestamp(const std::filesystem::path &path, TimestampDataT &timestamp)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -316,7 +314,7 @@ inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &t
 
 // writes .osrm.timestamp
 template <typename TimestampDataT>
-inline void writeTimestamp(const boost::filesystem::path &path, const TimestampDataT &timestamp)
+inline void writeTimestamp(const std::filesystem::path &path, const TimestampDataT &timestamp)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -326,7 +324,7 @@ inline void writeTimestamp(const boost::filesystem::path &path, const TimestampD
 
 // reads .osrm.maneuver_overrides
 template <typename StorageManeuverOverrideT, typename NodeSequencesT>
-inline void readManeuverOverrides(const boost::filesystem::path &path,
+inline void readManeuverOverrides(const std::filesystem::path &path,
                                   StorageManeuverOverrideT &maneuver_overrides,
                                   NodeSequencesT &node_sequences)
 {
@@ -340,7 +338,7 @@ inline void readManeuverOverrides(const boost::filesystem::path &path,
 }
 
 // writes .osrm.maneuver_overrides
-inline void writeManeuverOverrides(const boost::filesystem::path &path,
+inline void writeManeuverOverrides(const std::filesystem::path &path,
                                    const std::vector<StorageManeuverOverride> &maneuver_overrides,
                                    const std::vector<NodeID> &node_sequences)
 {
@@ -355,7 +353,7 @@ inline void writeManeuverOverrides(const boost::filesystem::path &path,
 
 // writes .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnWeightPenalty(const boost::filesystem::path &path,
+inline void writeTurnWeightPenalty(const std::filesystem::path &path,
                                    const TurnPenaltyT &turn_penalty)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -366,7 +364,7 @@ inline void writeTurnWeightPenalty(const boost::filesystem::path &path,
 
 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnWeightPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnWeightPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -376,7 +374,7 @@ inline void readTurnWeightPenalty(const boost::filesystem::path &path, TurnPenal
 
 // writes .osrm.turn_duration_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnDurationPenalty(const boost::filesystem::path &path,
+inline void writeTurnDurationPenalty(const std::filesystem::path &path,
                                      const TurnPenaltyT &turn_penalty)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -387,7 +385,7 @@ inline void writeTurnDurationPenalty(const boost::filesystem::path &path,
 
 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnDurationPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -397,7 +395,7 @@ inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPen
 
 // writes .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void writeTurnPenaltiesIndex(const boost::filesystem::path &path,
+inline void writeTurnPenaltiesIndex(const std::filesystem::path &path,
                                     const TurnIndexT &turn_penalties_index)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -408,7 +406,7 @@ inline void writeTurnPenaltiesIndex(const boost::filesystem::path &path,
 
 // read .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void readTurnPenaltiesIndex(const boost::filesystem::path &path,
+inline void readTurnPenaltiesIndex(const std::filesystem::path &path,
                                    TurnIndexT &turn_penalties_index)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -419,7 +417,7 @@ inline void readTurnPenaltiesIndex(const boost::filesystem::path &path,
 
 // writes .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void writeConditionalRestrictions(const boost::filesystem::path &path,
+inline void writeConditionalRestrictions(const std::filesystem::path &path,
                                          const ConditionalRestrictionsT &conditional_restrictions)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -430,7 +428,7 @@ inline void writeConditionalRestrictions(const boost::filesystem::path &path,
 
 // read .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void readConditionalRestrictions(const boost::filesystem::path &path,
+inline void readConditionalRestrictions(const std::filesystem::path &path,
                                         ConditionalRestrictionsT &conditional_restrictions)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -441,7 +439,7 @@ inline void readConditionalRestrictions(const boost::filesystem::path &path,
 
 // reads .osrm file which is a temporary file of osrm-extract
 template <typename PackedOSMIDsT>
-void readRawNBGraph(const boost::filesystem::path &path,
+void readRawNBGraph(const std::filesystem::path &path,
                     std::vector<util::Coordinate> &coordinates,
                     PackedOSMIDsT &osm_node_ids,
                     std::vector<extractor::NodeBasedEdge> &edge_list)
@@ -466,8 +464,7 @@ void readRawNBGraph(const boost::filesystem::path &path,
     storage::serialization::read(reader, "/extractor/edges", edge_list);
 }
 
-template <typename NameTableT>
+template <typename NameTableT> void readNames(const std::filesystem::path &path, NameTableT &table)
-void readNames(const boost::filesystem::path &path, NameTableT &table)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -476,7 +473,7 @@ void readNames(const boost::filesystem::path &path, NameTableT &table)
 }
 
 template <typename NameTableT>
-void writeNames(const boost::filesystem::path &path, const NameTableT &table)
+void writeNames(const std::filesystem::path &path, const NameTableT &table)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -485,7 +482,7 @@ void writeNames(const boost::filesystem::path &path, const NameTableT &table)
 }
 
 template <typename NodeWeightsVectorT>
-void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVectorT &weights)
+void readEdgeBasedNodeWeights(const std::filesystem::path &path, NodeWeightsVectorT &weights)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -494,8 +491,7 @@ void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVe
 }
 
 template <typename NodeDistancesVectorT>
-void readEdgeBasedNodeDistances(const boost::filesystem::path &path,
+void readEdgeBasedNodeDistances(const std::filesystem::path &path, NodeDistancesVectorT &distances)
-                                NodeDistancesVectorT &distances)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -504,7 +500,7 @@ void readEdgeBasedNodeDistances(const boost::filesystem::path &path,
 }
 
 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT, typename NodeDistancesVectorT>
-void writeEdgeBasedNodeWeightsDurationsDistances(const boost::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurationsDistances(const std::filesystem::path &path,
                                                  const NodeWeightsVectorT &weights,
                                                  const NodeDurationsVectorT &durations,
                                                  const NodeDistancesVectorT &distances)
@@ -518,7 +514,7 @@ void writeEdgeBasedNodeWeightsDurationsDistances(const boost::filesystem::path &
 }
 
 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
+void readEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
                                        NodeWeightsVectorT &weights,
                                        NodeDurationsVectorT &durations)
 {
@@ -530,7 +526,7 @@ void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
 }
 
 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
                                         const NodeWeightsVectorT &weights,
                                         const NodeDurationsVectorT &durations)
 {
@@ -542,7 +538,7 @@ void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
 }
 
 template <typename RTreeT>
-void writeRamIndex(const boost::filesystem::path &path, const RTreeT &rtree)
+void writeRamIndex(const std::filesystem::path &path, const RTreeT &rtree)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -550,7 +546,7 @@ void writeRamIndex(const boost::filesystem::path &path, const RTreeT &rtree)
     util::serialization::write(writer, "/common/rtree", rtree);
 }
 
-template <typename RTreeT> void readRamIndex(const boost::filesystem::path &path, RTreeT &rtree)
+template <typename RTreeT> void readRamIndex(const std::filesystem::path &path, RTreeT &rtree)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -559,7 +555,7 @@ template <typename RTreeT> void readRamIndex(const boost::filesystem::path &path
 }
 
 template <typename EdgeListT>
-void writeCompressedNodeBasedGraph(const boost::filesystem::path &path, const EdgeListT &edge_list)
+void writeCompressedNodeBasedGraph(const std::filesystem::path &path, const EdgeListT &edge_list)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -568,7 +564,7 @@ void writeCompressedNodeBasedGraph(const boost::filesystem::path &path, const Ed
 }
 
 template <typename EdgeListT>
-void readCompressedNodeBasedGraph(const boost::filesystem::path &path, EdgeListT &edge_list)
+void readCompressedNodeBasedGraph(const std::filesystem::path &path, EdgeListT &edge_list)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};

include/extractor/location_dependent_data.hpp

@@ -1,13 +1,13 @@
 #ifndef OSRM_LOCATION_DEPENDENT_DATA_HPP
 #define OSRM_LOCATION_DEPENDENT_DATA_HPP
 
-#include <boost/filesystem/path.hpp>
 #include <boost/geometry.hpp>
 #include <boost/geometry/geometries/point_xy.hpp>
 #include <boost/geometry/index/rtree.hpp>
 
 #include <osmium/osm/way.hpp>
 
+#include <filesystem>
 #include <string>
 #include <unordered_map>
 
@@ -30,7 +30,7 @@ struct LocationDependentData
     using property_t = boost::variant<boost::blank, double, std::string, bool>;
     using properties_t = std::unordered_map<std::string, property_t>;
 
-    LocationDependentData(const std::vector<boost::filesystem::path> &file_paths);
+    LocationDependentData(const std::vector<std::filesystem::path> &file_paths);
 
     bool empty() const { return rtree.empty(); }
 
@@ -39,7 +39,7 @@ struct LocationDependentData
     property_t FindByKey(const std::vector<std::size_t> &property_indexes, const char *key) const;
 
   private:
-    void loadLocationDependentData(const boost::filesystem::path &file_path,
+    void loadLocationDependentData(const std::filesystem::path &file_path,
                                    std::vector<rtree_t::value_type> &bounding_boxes);
 
     rtree_t rtree;

include/extractor/node_based_graph_factory.hpp

@@ -12,8 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"
 
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
-
 #include <memory>
 #include <string>
 #include <unordered_set>

include/extractor/raster_source.hpp

@@ -7,14 +7,13 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/assert.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/foreach.hpp>
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/qi_int.hpp>
 
 #include <storage/io.hpp>
 
+#include <filesystem>
 #include <iterator>
 #include <string>
 #include <unordered_map>
@@ -40,7 +39,7 @@ struct RasterDatum
 class RasterGrid
 {
   public:
-    RasterGrid(const boost::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
+    RasterGrid(const std::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
     {
         xdim = _xdim;
         ydim = _ydim;

include/extractor/scripting_environment_lua.hpp

@@ -70,7 +70,7 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment
 
     explicit Sol2ScriptingEnvironment(
         const std::string &file_name,
-        const std::vector<boost::filesystem::path> &location_dependent_data_paths);
+        const std::vector<std::filesystem::path> &location_dependent_data_paths);
     ~Sol2ScriptingEnvironment() override = default;
 
     const ProfileProperties &GetProfileProperties() override;

include/extractor/segment_data_container.hpp

@@ -8,13 +8,12 @@
 #include "storage/shared_memory_ownership.hpp"
 #include "storage/tar_fwd.hpp"
 
-#include <boost/filesystem/path.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/iterator_range.hpp>
 
-#include <unordered_map>
+#include <filesystem>
-
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 namespace osrm::extractor

include/guidance/files.hpp

@@ -10,12 +10,16 @@
 
 #include <boost/assert.hpp>
 
+#include <cstdint>
+#include <filesystem>
+#include <type_traits>
+
 namespace osrm::guidance::files
 {
 
 // reads .osrm.edges
 template <typename TurnDataT>
-inline void readTurnData(const boost::filesystem::path &path,
+inline void readTurnData(const std::filesystem::path &path,
                          TurnDataT &turn_data,
                          std::uint32_t &connectivity_checksum)
 {
@@ -32,7 +36,7 @@ inline void readTurnData(const boost::filesystem::path &path,
 
 // writes .osrm.edges
 template <typename TurnDataT>
-inline void writeTurnData(const boost::filesystem::path &path,
+inline void writeTurnData(const std::filesystem::path &path,
                           const TurnDataT &turn_data,
                           const std::uint32_t connectivity_checksum)
 {

include/partitioner/edge_based_graph_reader.hpp

@@ -173,8 +173,8 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
                 for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
                 {
                     const auto &data = edge_based_graph.GetEdgeData(edge);
-                    // we only need to save the forward edges, since the read method will
+                    // we only need to save the forward edges, since the read method
-                    // convert from forward to bi-directional edges again
+                    // will convert from forward to bi-directional edges again
                     if (data.forward)
                     {
                         auto target = edge_based_graph.GetTarget(edge);
@@ -191,7 +191,7 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
     return edges;
 }
 
-inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const boost::filesystem::path &path)
+inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const std::filesystem::path &path)
 {
     EdgeID number_of_edge_based_nodes;
     std::vector<extractor::EdgeBasedEdge> edges;

include/partitioner/files.hpp

@@ -10,7 +10,7 @@ namespace osrm::partitioner::files
 
 // read .osrm.partition file
 template <typename MultiLevelPartitionT>
-inline void readPartition(const boost::filesystem::path &path, MultiLevelPartitionT &mlp)
+inline void readPartition(const std::filesystem::path &path, MultiLevelPartitionT &mlp)
 {
     static_assert(std::is_same<MultiLevelPartitionView, MultiLevelPartitionT>::value ||
                       std::is_same<MultiLevelPartition, MultiLevelPartitionT>::value,
@@ -24,7 +24,7 @@ inline void readPartition(const boost::filesystem::path &path, MultiLevelPartiti
 
 // writes .osrm.partition file
 template <typename MultiLevelPartitionT>
-inline void writePartition(const boost::filesystem::path &path, const MultiLevelPartitionT &mlp)
+inline void writePartition(const std::filesystem::path &path, const MultiLevelPartitionT &mlp)
 {
     static_assert(std::is_same<MultiLevelPartitionView, MultiLevelPartitionT>::value ||
                       std::is_same<MultiLevelPartition, MultiLevelPartitionT>::value,
@@ -38,7 +38,7 @@ inline void writePartition(const boost::filesystem::path &path, const MultiLevel
 
 // reads .osrm.cells file
 template <typename CellStorageT>
-inline void readCells(const boost::filesystem::path &path, CellStorageT &storage)
+inline void readCells(const std::filesystem::path &path, CellStorageT &storage)
 {
     static_assert(std::is_same<CellStorageView, CellStorageT>::value ||
                       std::is_same<CellStorage, CellStorageT>::value,
@@ -52,7 +52,7 @@ inline void readCells(const boost::filesystem::path &path, CellStorageT &storage
 
 // writes .osrm.cells file
 template <typename CellStorageT>
-inline void writeCells(const boost::filesystem::path &path, CellStorageT &storage)
+inline void writeCells(const std::filesystem::path &path, CellStorageT &storage)
 {
     static_assert(std::is_same<CellStorageView, CellStorageT>::value ||
                       std::is_same<CellStorage, CellStorageT>::value,
@@ -66,7 +66,7 @@ inline void writeCells(const boost::filesystem::path &path, CellStorageT &storag
 
 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const boost::filesystem::path &path,
+inline void readGraph(const std::filesystem::path &path,
                       MultiLevelGraphT &graph,
                       std::uint32_t &connectivity_checksum)
 {
@@ -80,7 +80,7 @@ inline void readGraph(const boost::filesystem::path &path,
 
 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const boost::filesystem::path &path,
+inline void writeGraph(const std::filesystem::path &path,
                        const MultiLevelGraphT &graph,
                        const std::uint32_t connectivity_checksum)
 {

include/partitioner/partitioner_config.hpp

@@ -1,9 +1,8 @@
 #ifndef OSRM_PARTITIONER_CONFIG_HPP
 #define OSRM_PARTITIONER_CONFIG_HPP
 
-#include <boost/filesystem/path.hpp>
-
 #include <array>
+#include <filesystem>
 #include <string>
 
 #include "storage/io_config.hpp"
@@ -29,7 +28,7 @@ struct PartitionerConfig final : storage::IOConfig
     {
     }
 
-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
     {
         IOConfig::UseDefaultOutputNames(base);
     }

include/storage/io.hpp

@@ -10,14 +10,13 @@
 #include "util/log.hpp"
 #include "util/version.hpp"
 
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/iostreams/device/array.hpp>
 #include <boost/iostreams/seek.hpp>
 #include <boost/iostreams/stream.hpp>
-
 #include <cerrno>
 #include <cstring>
+#include <filesystem>
+#include <fstream>
 #include <iostream>
 #include <tuple>
 #include <type_traits>
@@ -35,11 +34,11 @@ class FileReader
     };
 
     FileReader(const std::string &filename, const FingerprintFlag flag)
-        : FileReader(boost::filesystem::path(filename), flag)
+        : FileReader(std::filesystem::path(filename), flag)
     {
     }
 
-    FileReader(const boost::filesystem::path &filepath_, const FingerprintFlag flag)
+    FileReader(const std::filesystem::path &filepath_, const FingerprintFlag flag)
         : filepath(filepath_), fingerprint(flag)
     {
         input_stream.open(filepath, std::ios::binary);
@@ -58,14 +57,14 @@ class FileReader
 
     std::size_t GetSize()
     {
-        const boost::filesystem::path path(filepath);
+        const std::filesystem::path path(filepath);
         try
         {
-            return std::size_t(boost::filesystem::file_size(path)) -
+            return std::size_t(std::filesystem::file_size(path)) -
                    ((fingerprint == FingerprintFlag::VerifyFingerprint) ? sizeof(util::FingerPrint)
                                                                         : 0);
         }
-        catch (const boost::filesystem::filesystem_error &ex)
+        catch (const std::filesystem::filesystem_error &ex)
         {
             std::cout << ex.what() << std::endl;
             throw;
@@ -196,8 +195,8 @@ class FileReader
     }
 
   private:
-    const boost::filesystem::path filepath;
+    const std::filesystem::path filepath;
-    boost::filesystem::ifstream input_stream;
+    std::ifstream input_stream;
     FingerprintFlag fingerprint;
 };
 
@@ -211,11 +210,11 @@ class FileWriter
     };
 
     FileWriter(const std::string &filename, const FingerprintFlag flag)
-        : FileWriter(boost::filesystem::path(filename), flag)
+        : FileWriter(std::filesystem::path(filename), flag)
     {
     }
 
-    FileWriter(const boost::filesystem::path &filepath_, const FingerprintFlag flag)
+    FileWriter(const std::filesystem::path &filepath_, const FingerprintFlag flag)
         : filepath(filepath_), fingerprint(flag)
     {
         output_stream.open(filepath, std::ios::binary);
@@ -284,8 +283,8 @@ class FileWriter
     }
 
   private:
-    const boost::filesystem::path filepath;
+    const std::filesystem::path filepath;
-    boost::filesystem::ofstream output_stream;
+    std::ofstream output_stream;
     FingerprintFlag fingerprint;
 };
 

include/storage/io_config.hpp

@@ -3,19 +3,19 @@
 
 #include "util/exception.hpp"
 
-#include <array>
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/filesystem.hpp>
+
-#include <boost/filesystem/path.hpp>
+#include <array>
+#include <filesystem>
 #include <string>
 
 namespace osrm::storage
 {
 struct IOConfig
 {
-    IOConfig(std::vector<boost::filesystem::path> required_input_files_,
+    IOConfig(std::vector<std::filesystem::path> required_input_files_,
-             std::vector<boost::filesystem::path> optional_input_files_,
+             std::vector<std::filesystem::path> optional_input_files_,
-             std::vector<boost::filesystem::path> output_files_)
+             std::vector<std::filesystem::path> output_files_)
         : required_input_files(std::move(required_input_files_)),
           optional_input_files(std::move(optional_input_files_)),
           output_files(std::move(output_files_))
@@ -24,7 +24,7 @@ struct IOConfig
 
     bool IsValid() const;
     std::vector<std::string> GetMissingFiles() const;
-    boost::filesystem::path GetPath(const std::string &fileName) const
+    std::filesystem::path GetPath(const std::string &fileName) const
     {
         if (!IsConfigured(fileName, required_input_files) &&
             !IsConfigured(fileName, optional_input_files) && !IsConfigured(fileName, output_files))
@@ -40,11 +40,11 @@ struct IOConfig
         return IsConfigured(fileName, required_input_files);
     }
 
-    boost::filesystem::path base_path;
+    std::filesystem::path base_path;
 
   protected:
     // Infer the base path from the path of the .osrm file
-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
     {
         // potentially strip off the .osrm (or other) extensions for
         // determining the base path=
@@ -67,7 +67,7 @@ struct IOConfig
 
   private:
     static bool IsConfigured(const std::string &fileName,
-                             const std::vector<boost::filesystem::path> &paths)
+                             const std::vector<std::filesystem::path> &paths)
     {
         for (auto &path : paths)
         {
@@ -80,9 +80,9 @@ struct IOConfig
         return false;
     }
 
-    std::vector<boost::filesystem::path> required_input_files;
+    std::vector<std::filesystem::path> required_input_files;
-    std::vector<boost::filesystem::path> optional_input_files;
+    std::vector<std::filesystem::path> optional_input_files;
-    std::vector<boost::filesystem::path> output_files;
+    std::vector<std::filesystem::path> output_files;
 };
 } // namespace osrm::storage
 

include/storage/shared_memory.hpp

@@ -5,8 +5,6 @@
 #include "util/exception_utils.hpp"
 #include "util/log.hpp"
 
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/interprocess/mapped_region.hpp>
 #ifndef _WIN32
 #include <boost/interprocess/xsi_shared_memory.hpp>
@@ -23,6 +21,8 @@
 
 #include <algorithm>
 #include <exception>
+#include <filesystem>
+#include <fstream>
 #include <thread>
 
 #include "storage/shared_memory_ownership.hpp"
@@ -32,10 +32,10 @@ namespace osrm::storage
 
 struct OSRMLockFile
 {
-    template <typename IdentifierT> boost::filesystem::path operator()(const IdentifierT &id)
+    template <typename IdentifierT> std::filesystem::path operator()(const IdentifierT &id)
     {
-        boost::filesystem::path temp_dir = boost::filesystem::temp_directory_path();
+        std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
-        boost::filesystem::path lock_file = temp_dir / ("osrm-" + std::to_string(id) + ".lock");
+        std::filesystem::path lock_file = temp_dir / ("osrm-" + std::to_string(id) + ".lock");
         return lock_file;
     }
 };
@@ -51,7 +51,7 @@ class SharedMemory
     SharedMemory &operator=(const SharedMemory &) = delete;
 
     template <typename IdentifierT>
-    SharedMemory(const boost::filesystem::path &lock_file,
+    SharedMemory(const std::filesystem::path &lock_file,
                  const IdentifierT id,
                  const uint64_t size = 0)
         : key(lock_file.string().c_str(), id)
@@ -202,7 +202,7 @@ class SharedMemory
     void *Ptr() const { return region.get_address(); }
     std::size_t Size() const { return region.get_size(); }
 
-    SharedMemory(const boost::filesystem::path &lock_file, const int id, const uint64_t size = 0)
+    SharedMemory(const std::filesystem::path &lock_file, const int id, const uint64_t size = 0)
     {
         sprintf(key, "%s.%d", "osrm.lock", id);
         if (0 == size)
@@ -290,7 +290,7 @@ std::unique_ptr<SharedMemory> makeSharedMemory(const IdentifierT &id, const uint
     try
     {
         LockFileT lock_file;
-        if (!boost::filesystem::exists(lock_file(id)))
+        if (!std::filesystem::exists(lock_file(id)))
         {
             if (0 == size)
             {
@@ -298,7 +298,7 @@ std::unique_ptr<SharedMemory> makeSharedMemory(const IdentifierT &id, const uint
             }
             else
             {
-                boost::filesystem::ofstream ofs(lock_file(id));
+                std::ofstream ofs(lock_file(id));
             }
         }
         return std::make_unique<SharedMemory>(lock_file(id), id, size);

include/storage/storage.hpp

@@ -32,15 +32,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/shared_datatype.hpp"
 #include "storage/storage_config.hpp"
 
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
-
 #include <string>
 #include <vector>
 
 namespace osrm::storage
 {
 
-void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDataLayout &layout);
+void populateLayoutFromFile(const std::filesystem::path &path, storage::BaseDataLayout &layout);
 
 class Storage
 {
@@ -51,10 +50,10 @@ class Storage
     void PopulateStaticData(const SharedDataIndex &index);
     void PopulateUpdatableData(const SharedDataIndex &index);
     void PopulateLayout(storage::BaseDataLayout &layout,
-                        const std::vector<std::pair<bool, boost::filesystem::path>> &files);
+                        const std::vector<std::pair<bool, std::filesystem::path>> &files);
     std::string PopulateLayoutWithRTree(storage::BaseDataLayout &layout);
-    std::vector<std::pair<bool, boost::filesystem::path>> GetUpdatableFiles();
+    std::vector<std::pair<bool, std::filesystem::path>> GetUpdatableFiles();
-    std::vector<std::pair<bool, boost::filesystem::path>> GetStaticFiles();
+    std::vector<std::pair<bool, std::filesystem::path>> GetStaticFiles();
 
   private:
     StorageConfig config;

include/storage/storage_config.hpp

@@ -28,22 +28,23 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef STORAGE_CONFIG_HPP
 #define STORAGE_CONFIG_HPP
 
-#include <boost/filesystem/path.hpp>
-
 #include "storage/io_config.hpp"
 #include "osrm/datasets.hpp"
 
+#include <filesystem>
+#include <istream>
 #include <set>
+#include <vector>
 
 namespace osrm::storage
 {
 
 std::istream &operator>>(std::istream &in, FeatureDataset &datasets);
 
-static std::vector<boost::filesystem::path>
+static std::vector<std::filesystem::path>
 GetRequiredFiles(const std::vector<storage::FeatureDataset> &disabled_feature_dataset)
 {
-    std::set<boost::filesystem::path> required{
+    std::set<std::filesystem::path> required{
         ".osrm.datasource_names",
         ".osrm.ebg_nodes",
         ".osrm.edges",
@@ -82,7 +83,7 @@ GetRequiredFiles(const std::vector<storage::FeatureDataset> &disabled_feature_da
         }
     }
 
-    return std::vector<boost::filesystem::path>(required.begin(), required.end());
+    return std::vector<std::filesystem::path>(required.begin(), required.end());
     ;
 }
 
@@ -94,7 +95,7 @@ GetRequiredFiles(const std::vector<storage::FeatureDataset> &disabled_feature_da
 struct StorageConfig final : IOConfig
 {
 
-    StorageConfig(const boost::filesystem::path &base,
+    StorageConfig(const std::filesystem::path &base,
                   const std::vector<storage::FeatureDataset> &disabled_feature_datasets_ = {})
         : StorageConfig(disabled_feature_datasets_)
     {

include/storage/tar.hpp

@@ -7,7 +7,7 @@
 #include "util/integer_range.hpp"
 #include "util/version.hpp"
 
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
 
 extern "C"
 {
@@ -19,7 +19,7 @@ namespace osrm::storage::tar
 namespace detail
 {
 inline void
-checkMTarError(int error_code, const boost::filesystem::path &filepath, const std::string &name)
+checkMTarError(int error_code, const std::filesystem::path &filepath, const std::string &name)
 {
     switch (error_code)
     {
@@ -78,7 +78,7 @@ class FileReader
         HasNoFingerprint
     };
 
-    FileReader(const boost::filesystem::path &path, FingerprintFlag flag) : path(path)
+    FileReader(const std::filesystem::path &path, FingerprintFlag flag) : path(path)
     {
         auto ret = mtar_open(&handle, path.string().c_str(), "r");
         detail::checkMTarError(ret, path, "");
@@ -204,7 +204,7 @@ class FileReader
         return true;
     }
 
-    boost::filesystem::path path;
+    std::filesystem::path path;
     mtar_t handle;
 };
 
@@ -217,7 +217,7 @@ class FileWriter
         HasNoFingerprint
     };
 
-    FileWriter(const boost::filesystem::path &path, FingerprintFlag flag) : path(path)
+    FileWriter(const std::filesystem::path &path, FingerprintFlag flag) : path(path)
     {
         auto ret = mtar_open(&handle, path.string().c_str(), "w");
         detail::checkMTarError(ret, path, "");
@@ -305,7 +305,7 @@ class FileWriter
         WriteFrom("osrm_fingerprint.meta", fingerprint);
     }
 
-    boost::filesystem::path path;
+    std::filesystem::path path;
     mtar_t handle;
 };
 } // namespace osrm::storage::tar

include/storage/view_factory.hpp

@@ -202,7 +202,7 @@ inline auto make_search_tree_view(const SharedDataIndex &index, const std::strin
 
     const char *path = index.template GetBlockPtr<char>(name + "/file_index_path");
 
-    if (!boost::filesystem::exists(boost::filesystem::path{path}))
+    if (!std::filesystem::exists(std::filesystem::path{path}))
     {
         throw util::exception("Could not load " + std::string(path) + "Does the leaf file exist?" +
                               SOURCE_REF);

include/updater/csv_file_parser.hpp

@@ -12,12 +12,12 @@
 #include <tbb/spin_mutex.h>
 
 #include <boost/exception/diagnostic_information.hpp>
-#include <boost/filesystem.hpp>
 #include <boost/iostreams/device/mapped_file.hpp>
 #include <boost/phoenix.hpp>
 #include <boost/spirit/include/qi.hpp>
 
 #include <exception>
+#include <filesystem>
 #include <stdexcept>
 #include <vector>
 
@@ -100,7 +100,7 @@ template <typename Key, typename Value> struct CSVFilesParser
         std::vector<std::pair<Key, Value>> result;
         try
         {
-            if (boost::filesystem::file_size(filename) == 0)
+            if (std::filesystem::file_size(filename) == 0)
                 return result;
 
             boost::iostreams::mapped_file_source mmap(filename);

include/updater/updater_config.hpp

@@ -28,14 +28,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef OSRM_UPDATER_UPDATER_CONFIG_HPP
 #define OSRM_UPDATER_UPDATER_CONFIG_HPP
 
-#include <boost/filesystem/path.hpp>
-
-#include <chrono>
-#include <string>
-
 #include "storage/io_config.hpp"
 #include "storage/storage_config.hpp"
 
+#include <chrono>
+#include <filesystem>
+#include <string>
+
 namespace osrm::updater
 {
 
@@ -59,7 +58,7 @@ struct UpdaterConfig final : storage::IOConfig
     {
     }
 
-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
     {
         IOConfig::UseDefaultOutputNames(base);
     }

include/util/lua_util.hpp

@@ -8,7 +8,7 @@ extern "C"
 #include <lualib.h>
 }
 
-#include <boost/filesystem.hpp>
+#include <filesystem>
 
 #include <string>
 
@@ -20,7 +20,7 @@ namespace osrm::util
 // See http://lua-users.org/wiki/PackagePath for details on the package.path syntax.
 inline void luaAddScriptFolderToLoadPath(lua_State *lua_state, const char *file_name)
 {
-    boost::filesystem::path profile_path = boost::filesystem::canonical(file_name);
+    std::filesystem::path profile_path = std::filesystem::canonical(file_name);
     std::string folder = profile_path.parent_path().generic_string();
     const std::string lua_code = "package.path = \"" + folder + "/?.lua;\" .. package.path";
     luaL_dostring(lua_state, lua_code.c_str());

include/util/mmap_file.hpp

@@ -5,20 +5,22 @@
 #include "util/exception_utils.hpp"
 #include "util/vector_view.hpp"
 
-#include <boost/filesystem/path.hpp>
 #include <boost/iostreams/device/mapped_file.hpp>
 
+#include <filesystem>
+
 namespace osrm::util
 {
 
 namespace detail
 {
 template <typename T, typename MmapContainerT>
-util::vector_view<T> mmapFile(const boost::filesystem::path &file, MmapContainerT &mmap_container)
+util::vector_view<T> mmapFile(const std::filesystem::path &file, MmapContainerT &mmap_container)
 {
     try
     {
-        mmap_container.open(file);
+        auto path_string = file.string();
+        mmap_container.open(path_string);
         std::size_t num_objects = mmap_container.size() / sizeof(T);
         auto data_ptr = mmap_container.data();
         BOOST_ASSERT(reinterpret_cast<uintptr_t>(data_ptr) % alignof(T) == 0);
@@ -33,9 +35,8 @@ util::vector_view<T> mmapFile(const boost::filesystem::path &file, MmapContainer
 }
 
 template <typename T, typename MmapContainerT>
-util::vector_view<T> mmapFile(const boost::filesystem::path &file,
+util::vector_view<T>
-                              MmapContainerT &mmap_container,
+mmapFile(const std::filesystem::path &file, MmapContainerT &mmap_container, const std::size_t size)
-                              const std::size_t size)
 {
     try
     {
@@ -61,21 +62,21 @@ util::vector_view<T> mmapFile(const boost::filesystem::path &file,
 } // namespace detail
 
 template <typename T>
-util::vector_view<const T> mmapFile(const boost::filesystem::path &file,
+util::vector_view<const T> mmapFile(const std::filesystem::path &file,
                                     boost::iostreams::mapped_file_source &mmap_container)
 {
     return detail::mmapFile<const T>(file, mmap_container);
 }
 
 template <typename T>
-util::vector_view<T> mmapFile(const boost::filesystem::path &file,
+util::vector_view<T> mmapFile(const std::filesystem::path &file,
                               boost::iostreams::mapped_file &mmap_container)
 {
     return detail::mmapFile<T>(file, mmap_container);
 }
 
 template <typename T>
-util::vector_view<T> mmapFile(const boost::filesystem::path &file,
+util::vector_view<T> mmapFile(const std::filesystem::path &file,
                               boost::iostreams::mapped_file &mmap_container,
                               std::size_t size)
 {

include/util/mmap_tar.hpp

@@ -15,7 +15,7 @@ namespace osrm::util
 using DataRange = std::pair<const char *, const char *>;
 using DataMap = std::unordered_map<std::string, DataRange>;
 
-inline DataMap mmapTarFile(const boost::filesystem::path &path,
+inline DataMap mmapTarFile(const std::filesystem::path &path,
                            boost::iostreams::mapped_file_source &region)
 {
     DataMap map;

include/util/static_rtree.hpp

@@ -20,7 +20,6 @@
 #include "storage/shared_memory_ownership.hpp"
 
 #include <boost/assert.hpp>
-#include <boost/filesystem.hpp>
 #include <boost/format.hpp>
 #include <boost/iostreams/device/mapped_file.hpp>
 
@@ -30,6 +29,7 @@
 
 #include <algorithm>
 #include <array>
+#include <filesystem>
 #include <limits>
 #include <memory>
 #include <queue>
@@ -271,7 +271,7 @@ class StaticRTree
     // Construct a packed Hilbert-R-Tree with Kamel-Faloutsos algorithm [1]
     explicit StaticRTree(const std::vector<EdgeDataT> &input_data_vector,
                          const Vector<Coordinate> &coordinate_list,
-                         const boost::filesystem::path &on_disk_file_name)
+                         const std::filesystem::path &on_disk_file_name)
         : m_coordinate_list(coordinate_list.data(), coordinate_list.size())
     {
         const auto element_count = input_data_vector.size();
@@ -458,7 +458,7 @@ class StaticRTree
      * Constructs an empty RTree for de-serialization.
      */
     template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
-    explicit StaticRTree(const boost::filesystem::path &on_disk_file_name,
+    explicit StaticRTree(const std::filesystem::path &on_disk_file_name,
                          const Vector<Coordinate> &coordinate_list)
         : m_coordinate_list(coordinate_list.data(), coordinate_list.size()),
           m_objects(mmapFile<EdgeDataT>(on_disk_file_name, m_objects_region))
@@ -473,7 +473,7 @@ class StaticRTree
      */
     explicit StaticRTree(Vector<TreeNode> search_tree_,
                          Vector<std::uint64_t> tree_level_starts,
-                         const boost::filesystem::path &on_disk_file_name,
+                         const std::filesystem::path &on_disk_file_name,
                          const Vector<Coordinate> &coordinate_list)
         : m_search_tree(std::move(search_tree_)),
           m_coordinate_list(coordinate_list.data(), coordinate_list.size()),

include/util/timezones.hpp

@@ -3,13 +3,13 @@
 
 #include "util/log.hpp"
 
-#include <boost/filesystem/path.hpp>
 #include <boost/geometry.hpp>
 #include <boost/geometry/index/rtree.hpp>
 
 #include <rapidjson/document.h>
 
 #include <chrono>
+#include <filesystem>
 #include <optional>
 
 namespace osrm::updater
@@ -32,7 +32,7 @@ class Timezoner
     Timezoner() = default;
 
     Timezoner(const char geojson[], std::time_t utc_time_now);
-    Timezoner(const boost::filesystem::path &tz_shapes_filename, std::time_t utc_time_now);
+    Timezoner(const std::filesystem::path &tz_shapes_filename, std::time_t utc_time_now);
 
     std::optional<struct tm> operator()(const point_t &point) const;
 

scripts/ci/windows-build.bat

@@ -0,0 +1,96 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO NUMBER_OF_PROCESSORS^: %NUMBER_OF_PROCESSORS%
+
+SET PROJECT_DIR=%CD%
+SET CONFIGURATION=Release
+
+mkdir build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+cd build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+cmake -DENABLE_CONAN=ON -DENABLE_NODE_BINDINGS=ON -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "Visual Studio 17 2022" ..
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+msbuild OSRM.sln ^
+/p:Configuration=%CONFIGURATION% ^
+/p:Platform=x64 ^
+/p:nowarn="4244;4267;4365;4456;4514;4625;4626;4710;4711;4820;5026;5027" ^
+/t:rebuild ^
+/p:BuildInParallel=true ^
+/m:%NUMBER_OF_PROCESSORS% ^
+/toolsversion:Current ^
+/clp:Verbosity=quiet ^
+/nologo
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+CD %PROJECT_DIR%\build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running extractor-tests.exe ...
+unit_tests\%CONFIGURATION%\extractor-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running contractor-tests.exe ...
+unit_tests\%CONFIGURATION%\contractor-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running engine-tests.exe ...
+unit_tests\%CONFIGURATION%\engine-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running util-tests.exe ...
+unit_tests\%CONFIGURATION%\util-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running server-tests.exe ...
+unit_tests\%CONFIGURATION%\server-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running partitioner-tests.exe ...
+unit_tests\%CONFIGURATION%\partitioner-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running customizer-tests.exe ...
+unit_tests\%CONFIGURATION%\customizer-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET test_region=monaco
+SET test_region_ch=ch\monaco
+SET test_region_corech=corech\monaco
+SET test_region_mld=mld\monaco
+SET test_osm=%test_region%.osm.pbf
+COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm% 
+%CONFIGURATION%\osrm-extract.exe -p %PROJECT_DIR%\profiles\car.lua %test_osm%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+MKDIR ch
+XCOPY %test_region%.osrm.* ch\
+XCOPY %test_region%.osrm ch\
+MKDIR corech
+XCOPY %test_region%.osrm.* corech\
+XCOPY %test_region%.osrm corech\
+MKDIR mld
+XCOPY %test_region%.osrm.* mld\
+XCOPY %test_region%.osrm mld\
+%CONFIGURATION%\osrm-contract.exe %test_region_ch%.osrm
+%CONFIGURATION%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
+%CONFIGURATION%\osrm-partition.exe %test_region_mld%.osrm
+%CONFIGURATION%\osrm-customize.exe %test_region_mld%.osrm
+XCOPY /Y ch\*.* ..\test\data\ch\
+XCOPY /Y corech\*.* ..\test\data\corech\
+XCOPY /Y mld\*.* ..\test\data\mld\
+unit_tests\%CONFIGURATION%\library-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+:ERROR
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ECHO ERRORLEVEL^: %ERRORLEVEL%
+SET EL=%ERRORLEVEL%
+
+:DONE
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+EXIT /b %EL%

src/benchmarks/static_rtree.cpp

@@ -11,11 +11,10 @@
 #include "util/serialization.hpp"
 #include "util/timing_util.hpp"
 
+#include <fstream>
 #include <iostream>
 #include <random>
 
-#include <boost/filesystem/fstream.hpp>
-
 namespace osrm::benchmarks
 {
 

src/engine/datafacade/mmap_memory_allocator.cpp

@@ -44,7 +44,7 @@ MMapMemoryAllocator::MMapMemoryAllocator(const storage::StorageConfig &config)
 
     for (const auto &file : files)
     {
-        if (boost::filesystem::exists(file.second))
+        if (std::filesystem::exists(file.second))
         {
             std::unique_ptr<storage::BaseDataLayout> layout =
                 std::make_unique<storage::TarDataLayout>();

src/extractor/compressed_edge_container.cpp

@@ -2,10 +2,11 @@
 #include "util/log.hpp"
 
 #include <boost/assert.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
+#include <filesystem>
+#include <fstream>
+#include <iostream>
 #include <limits>
 #include <string>
 

src/extractor/location_dependent_data.cpp

@@ -7,17 +7,17 @@
 #include <rapidjson/error/en.h>
 #include <rapidjson/istreamwrapper.h>
 
-#include <boost/filesystem.hpp>
 #include <boost/geometry/algorithms/equals.hpp>
 #include <boost/iterator/function_output_iterator.hpp>
 
+#include <filesystem>
 #include <fstream>
 #include <string>
 
 namespace osrm::extractor
 {
 
-LocationDependentData::LocationDependentData(const std::vector<boost::filesystem::path> &file_paths)
+LocationDependentData::LocationDependentData(const std::vector<std::filesystem::path> &file_paths)
 {
     std::vector<rtree_t::value_type> bounding_boxes;
     for (const auto &path : file_paths)
@@ -32,12 +32,12 @@ LocationDependentData::LocationDependentData(const std::vector<boost::filesystem
 }
 
 void LocationDependentData::loadLocationDependentData(
-    const boost::filesystem::path &file_path, std::vector<rtree_t::value_type> &bounding_boxes)
+    const std::filesystem::path &file_path, std::vector<rtree_t::value_type> &bounding_boxes)
 {
     if (file_path.empty())
         return;
 
-    if (!boost::filesystem::exists(file_path) || !boost::filesystem::is_regular_file(file_path))
+    if (!std::filesystem::exists(file_path) || !std::filesystem::is_regular_file(file_path))
     {
         throw osrm::util::exception(std::string("File with location-dependent data ") +
                                     file_path.string() + " does not exists");

src/extractor/raster_source.cpp

@@ -103,8 +103,8 @@ int RasterContainer::LoadRasterSource(const std::string &path_string,
     util::Log() << "[source loader] Loading from " << path_string << "  ... ";
     TIMER_START(loading_source);
 
-    boost::filesystem::path filepath(path_string);
+    std::filesystem::path filepath(path_string);
-    if (!boost::filesystem::exists(filepath))
+    if (!std::filesystem::exists(filepath))
     {
         throw util::RuntimeError(
             path_string, ErrorCode::FileOpenError, SOURCE_REF, "File not found");

src/extractor/scripting_environment_lua.cpp

@@ -113,7 +113,7 @@ void handle_lua_error(const sol::protected_function_result &luares)
 
 Sol2ScriptingEnvironment::Sol2ScriptingEnvironment(
     const std::string &file_name,
-    const std::vector<boost::filesystem::path> &location_dependent_data_paths)
+    const std::vector<std::filesystem::path> &location_dependent_data_paths)
     : file_name(file_name), location_dependent_data(location_dependent_data_paths)
 {
     util::Log() << "Using script " << file_name;

src/partitioner/partitioner.cpp

@@ -19,16 +19,15 @@
 #include "util/json_container.hpp"
 #include "util/log.hpp"
 #include "util/mmap_file.hpp"
-
+#include "util/timing_util.hpp"
-#include <algorithm>
-#include <iterator>
-#include <vector>
 
 #include <boost/assert.hpp>
-#include <boost/filesystem/operations.hpp>
 #include <tbb/global_control.h>
 
-#include "util/timing_util.hpp"
+#include <algorithm>
+#include <filesystem>
+#include <iterator>
+#include <vector>
 
 namespace osrm::partitioner
 {
@@ -171,11 +170,11 @@ int Partitioner::Run(const PartitionerConfig &config)
 
         extractor::files::writeManeuverOverrides(filename, maneuver_overrides, node_sequences);
     }
-    if (boost::filesystem::exists(config.GetPath(".osrm.hsgr")))
+    if (std::filesystem::exists(config.GetPath(".osrm.hsgr")))
     {
         util::Log(logWARNING) << "Found existing .osrm.hsgr file, removing. You need to re-run "
                                  "osrm-contract after osrm-partition.";
-        boost::filesystem::remove(config.GetPath(".osrm.hsgr"));
+        std::filesystem::remove(config.GetPath(".osrm.hsgr"));
     }
     TIMER_STOP(renumber);
     util::Log() << "Renumbered data in " << TIMER_SEC(renumber) << " seconds";

src/storage/io_config.cpp

@@ -2,14 +2,12 @@
 
 #include "util/log.hpp"
 
-#include <boost/filesystem.hpp>
+#include <filesystem>
-#include <boost/filesystem/operations.hpp>
-#include <boost/filesystem/path.hpp>
 
 namespace osrm::storage
 {
 
-namespace fs = boost::filesystem;
+namespace fs = std::filesystem;
 
 bool IOConfig::IsValid() const
 {

src/storage/storage.cpp

@@ -23,13 +23,11 @@
 #endif
 
 #include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/filesystem/fstream.hpp>
-#include <boost/filesystem/path.hpp>
 #include <boost/interprocess/sync/file_lock.hpp>
 #include <boost/interprocess/sync/scoped_lock.hpp>
 
 #include <cstdint>
-
+#include <filesystem>
 #include <fstream>
 #include <iterator>
 #include <new>
@@ -164,7 +162,7 @@ bool swapData(Monitor &monitor,
 }
 } // namespace
 
-void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDataLayout &layout)
+void populateLayoutFromFile(const std::filesystem::path &path, storage::BaseDataLayout &layout)
 {
     tar::FileReader reader(path, tar::FileReader::VerifyFingerprint);
 
@@ -190,11 +188,11 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
 
     util::LogPolicy::GetInstance().Unmute();
 
-    boost::filesystem::path lock_path =
+    std::filesystem::path lock_path =
-        boost::filesystem::temp_directory_path() / "osrm-datastore.lock";
+        std::filesystem::temp_directory_path() / "osrm-datastore.lock";
-    if (!boost::filesystem::exists(lock_path))
+    if (!std::filesystem::exists(lock_path))
     {
-        boost::filesystem::ofstream ofs(lock_path);
+        std::ofstream ofs(lock_path);
     }
 
     boost::interprocess::file_lock file_lock(lock_path.string().c_str());
@@ -257,7 +255,7 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
         std::unique_ptr<storage::BaseDataLayout> static_layout =
             std::make_unique<storage::ContiguousDataLayout>();
         Storage::PopulateLayoutWithRTree(*static_layout);
-        std::vector<std::pair<bool, boost::filesystem::path>> files = Storage::GetStaticFiles();
+        std::vector<std::pair<bool, std::filesystem::path>> files = Storage::GetStaticFiles();
         Storage::PopulateLayout(*static_layout, files);
         auto static_handle = setupRegion(shared_register, *static_layout);
         regions.push_back({static_handle.data_ptr, std::move(static_layout)});
@@ -266,7 +264,7 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
 
     std::unique_ptr<storage::BaseDataLayout> updatable_layout =
         std::make_unique<storage::ContiguousDataLayout>();
-    std::vector<std::pair<bool, boost::filesystem::path>> files = Storage::GetUpdatableFiles();
+    std::vector<std::pair<bool, std::filesystem::path>> files = Storage::GetUpdatableFiles();
     Storage::PopulateLayout(*updatable_layout, files);
     auto updatable_handle = setupRegion(shared_register, *updatable_layout);
     regions.push_back({updatable_handle.data_ptr, std::move(updatable_layout)});
@@ -285,12 +283,12 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
     return EXIT_SUCCESS;
 }
 
-std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetStaticFiles()
+std::vector<std::pair<bool, std::filesystem::path>> Storage::GetStaticFiles()
 {
     constexpr bool IS_REQUIRED = true;
     constexpr bool IS_OPTIONAL = false;
 
-    std::vector<std::pair<bool, boost::filesystem::path>> files = {
+    std::vector<std::pair<bool, std::filesystem::path>> files = {
         {IS_OPTIONAL, config.GetPath(".osrm.cells")},
         {IS_OPTIONAL, config.GetPath(".osrm.partition")},
         {IS_REQUIRED, config.GetPath(".osrm.ebg_nodes")},
@@ -310,7 +308,7 @@ std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetStaticFiles()
 
     for (const auto &file : files)
     {
-        if (file.first == IS_REQUIRED && !boost::filesystem::exists(file.second))
+        if (file.first == IS_REQUIRED && !std::filesystem::exists(file.second))
         {
             throw util::exception("Could not find required file(s): " + std::get<1>(file).string());
         }
@@ -319,12 +317,12 @@ std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetStaticFiles()
     return files;
 }
 
-std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetUpdatableFiles()
+std::vector<std::pair<bool, std::filesystem::path>> Storage::GetUpdatableFiles()
 {
     constexpr bool IS_REQUIRED = true;
     constexpr bool IS_OPTIONAL = false;
 
-    std::vector<std::pair<bool, boost::filesystem::path>> files = {
+    std::vector<std::pair<bool, std::filesystem::path>> files = {
         {IS_OPTIONAL, config.GetPath(".osrm.mldgr")},
         {IS_OPTIONAL, config.GetPath(".osrm.cell_metrics")},
         {IS_OPTIONAL, config.GetPath(".osrm.hsgr")},
@@ -335,7 +333,7 @@ std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetUpdatableFiles
 
     for (const auto &file : files)
     {
-        if (file.first == IS_REQUIRED && !boost::filesystem::exists(file.second))
+        if (file.first == IS_REQUIRED && !std::filesystem::exists(file.second))
         {
             throw util::exception("Could not find required file(s): " + std::get<1>(file).string());
         }
@@ -347,9 +345,9 @@ std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetUpdatableFiles
 std::string Storage::PopulateLayoutWithRTree(storage::BaseDataLayout &layout)
 {
     // Figure out the path to the rtree file (it's not a tar file)
-    auto absolute_file_index_path = boost::filesystem::absolute(config.GetPath(".osrm.fileIndex"));
+    auto absolute_file_index_path = std::filesystem::absolute(config.GetPath(".osrm.fileIndex"));
 
-    // Convert the boost::filesystem::path object into a plain string
+    // Convert the std::filesystem::path object into a plain string
     // that can then be stored as a member of an allocator object
     auto rtree_filename = absolute_file_index_path.string();
 
@@ -366,11 +364,11 @@ std::string Storage::PopulateLayoutWithRTree(storage::BaseDataLayout &layout)
  * in that big block.  It updates the fields in the layout parameter.
  */
 void Storage::PopulateLayout(storage::BaseDataLayout &layout,
-                             const std::vector<std::pair<bool, boost::filesystem::path>> &files)
+                             const std::vector<std::pair<bool, std::filesystem::path>> &files)
 {
     for (const auto &file : files)
     {
-        if (boost::filesystem::exists(file.second))
+        if (std::filesystem::exists(file.second))
         {
             populateLayoutFromFile(file.second, layout);
         }
@@ -389,7 +387,7 @@ void Storage::PopulateStaticData(const SharedDataIndex &index)
                   file_index_path_ptr + index.GetBlockSize("/common/rtree/file_index_path"),
                   0);
         const auto absolute_file_index_path =
-            boost::filesystem::absolute(config.GetPath(".osrm.fileIndex")).string();
+            std::filesystem::absolute(config.GetPath(".osrm.fileIndex")).string();
         BOOST_ASSERT(static_cast<std::size_t>(index.GetBlockSize(
                          "/common/rtree/file_index_path")) >= absolute_file_index_path.size());
         std::copy(
@@ -482,13 +480,13 @@ void Storage::PopulateStaticData(const SharedDataIndex &index)
         metric_name = profile_properties_ptr->GetWeightName();
     }
 
-    if (boost::filesystem::exists(config.GetPath(".osrm.partition")))
+    if (std::filesystem::exists(config.GetPath(".osrm.partition")))
     {
         auto mlp = make_partition_view(index, "/mld/multilevelpartition");
         partitioner::files::readPartition(config.GetPath(".osrm.partition"), mlp);
     }
 
-    if (boost::filesystem::exists(config.GetPath(".osrm.cells")))
+    if (std::filesystem::exists(config.GetPath(".osrm.cells")))
     {
         auto storage = make_cell_storage_view(index, "/mld/cellstorage");
         partitioner::files::readCells(config.GetPath(".osrm.cells"), storage);
@@ -541,7 +539,7 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
         metric_name = properties.GetWeightName();
     }
 
-    if (boost::filesystem::exists(config.GetPath(".osrm.hsgr")))
+    if (std::filesystem::exists(config.GetPath(".osrm.hsgr")))
     {
         const std::string metric_prefix = "/ch/metrics/" + metric_name;
         auto contracted_metric = make_contracted_metric_view(index, metric_prefix);
@@ -567,7 +565,7 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
         }
     }
 
-    if (boost::filesystem::exists(config.GetPath(".osrm.cell_metrics")))
+    if (std::filesystem::exists(config.GetPath(".osrm.cell_metrics")))
     {
         auto exclude_metrics = make_cell_metric_view(index, "/mld/metrics/" + metric_name);
         std::unordered_map<std::string, std::vector<customizer::CellMetricView>> metrics = {
@@ -576,7 +574,7 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
         customizer::files::readCellMetrics(config.GetPath(".osrm.cell_metrics"), metrics);
     }
 
-    if (boost::filesystem::exists(config.GetPath(".osrm.mldgr")))
+    if (std::filesystem::exists(config.GetPath(".osrm.mldgr")))
     {
         auto graph_view = make_multi_level_graph_view(index, "/mld/multilevelgraph");
         std::uint32_t graph_connectivity_checksum = 0;

src/tools/components.cpp

@@ -10,7 +10,6 @@
 #include "util/tarjan_scc.hpp"
 #include "util/typedefs.hpp"
 
-#include <boost/filesystem.hpp>
 #include <boost/iterator/function_output_iterator.hpp>
 
 #include <tbb/parallel_sort.h>
@@ -19,6 +18,7 @@
 #include <cstdlib>
 
 #include <algorithm>
+#include <filesystem>
 #include <fstream>
 #include <memory>
 #include <ostream>
@@ -118,7 +118,7 @@ int main(int argc, char *argv[])
     const std::string inpath{argv[1]};
     const std::string outpath{argv[2]};
 
-    if (boost::filesystem::exists(outpath))
+    if (std::filesystem::exists(outpath))
     {
         util::Log(logWARNING) << "Components file " << outpath << " already exists";
         return EXIT_FAILURE;

src/tools/contract.cpp

@@ -6,12 +6,12 @@
 #include "util/timezones.hpp"
 #include "util/version.hpp"
 
-#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 #include <boost/program_options/errors.hpp>
 
 #include <cstdlib>
 #include <exception>
+#include <filesystem>
 #include <new>
 #include <ostream>
 #include <thread>
@@ -86,7 +86,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
         "input,i",
-        boost::program_options::value<boost::filesystem::path>(&contractor_config.base_path),
+        boost::program_options::value<std::filesystem::path>(&contractor_config.base_path),
         "Input file in .osm, .osm.bz2 or .osm.pbf format");
 
     // positional option
@@ -99,7 +99,7 @@ return_code parseArguments(int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        "Usage: " + boost::filesystem::path(executable).filename().string() +
+        "Usage: " + std::filesystem::path(executable).filename().string() +
         " <input.osrm> [options]");
     visible_options.add(generic_options).add(config_options);
 

src/tools/customize.cpp

@@ -5,9 +5,9 @@
 #include "util/meminfo.hpp"
 #include "util/version.hpp"
 
-#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 
+#include <filesystem>
 #include <iostream>
 #include <thread>
 
@@ -76,7 +76,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
         "input,i",
-        boost::program_options::value<boost::filesystem::path>(&customization_config.base_path),
+        boost::program_options::value<std::filesystem::path>(&customization_config.base_path),
         "Input base file path");
 
     // positional option
@@ -89,7 +89,7 @@ return_code parseArguments(int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        boost::filesystem::path(executable).filename().string() + " <input.osrm> [options]");
+        std::filesystem::path(executable).filename().string() + " <input.osrm> [options]");
     visible_options.add(generic_options).add(config_options);
 
     // parse command line options

src/tools/extract.cpp

@@ -2,19 +2,17 @@
 #include "osrm/extractor.hpp"
 #include "osrm/extractor_config.hpp"
 #include "util/log.hpp"
+#include "util/meminfo.hpp"
 #include "util/version.hpp"
 
-#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
-
 #include <cstdlib>
 #include <exception>
+#include <filesystem>
 #include <iostream>
 #include <new>
 #include <thread>
 
-#include "util/meminfo.hpp"
-
 using namespace osrm;
 
 enum class return_code : unsigned
@@ -40,7 +38,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description config_options("Configuration");
     config_options.add_options()(
         "profile,p",
-        boost::program_options::value<boost::filesystem::path>(&extractor_config.profile_path)
+        boost::program_options::value<std::filesystem::path>(&extractor_config.profile_path)
             ->default_value("profiles/car.lua"),
         "Path to LUA routing profile")(
         "data_version,d",
@@ -67,7 +65,7 @@ return_code parseArguments(int argc,
             ->default_value(false),
         "Save conditional restrictions found during extraction to disk for use "
         "during contraction")("location-dependent-data",
-                              boost::program_options::value<std::vector<boost::filesystem::path>>(
+                              boost::program_options::value<std::vector<std::filesystem::path>>(
                                   &extractor_config.location_dependent_data_paths)
                                   ->composing(),
                               "GeoJSON files with location-dependent data")(
@@ -88,7 +86,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
         "input,i",
-        boost::program_options::value<boost::filesystem::path>(&extractor_config.input_path),
+        boost::program_options::value<std::filesystem::path>(&extractor_config.input_path),
         "Input file in .osm, .osm.bz2 or .osm.pbf format")(
         "generate-edge-lookup",
         boost::program_options::bool_switch(&dummy)->implicit_value(true)->default_value(false),
@@ -104,7 +102,7 @@ return_code parseArguments(int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        boost::filesystem::path(executable).filename().string() +
+        std::filesystem::path(executable).filename().string() +
         " <input.osm/.osm.bz2/.osm.pbf> [options]");
     visible_options.add(generic_options).add(config_options);
 
@@ -176,14 +174,14 @@ try
         return EXIT_FAILURE;
     }
 
-    if (!boost::filesystem::is_regular_file(extractor_config.input_path))
+    if (!std::filesystem::is_regular_file(extractor_config.input_path))
     {
         util::Log(logERROR) << "Input file " << extractor_config.input_path.string()
                             << " not found!";
         return EXIT_FAILURE;
     }
 
-    if (!boost::filesystem::is_regular_file(extractor_config.profile_path))
+    if (!std::filesystem::is_regular_file(extractor_config.profile_path))
     {
         util::Log(logERROR) << "Profile " << extractor_config.profile_path.string()
                             << " not found!";

src/tools/io-benchmark.cpp

@@ -3,9 +3,6 @@
 #include "util/log.hpp"
 #include "util/timing_util.hpp"
 
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
-
 #include <cmath>
 #include <cstdio>
 #include <fcntl.h>
@@ -15,6 +12,8 @@
 
 #include <algorithm>
 #include <chrono>
+#include <filesystem>
+#include <fstream>
 #include <iomanip>
 #include <numeric>
 #include <random>
@@ -45,7 +44,7 @@ void runStatistics(std::vector<double> &timings_vector, Statistics &stats)
 }
 } // namespace osrm::tools
 
-boost::filesystem::path test_path;
+std::filesystem::path test_path;
 
 int main(int argc, char *argv[])
 {
@@ -66,7 +65,7 @@ int main(int argc, char *argv[])
         return -1;
     }
 
-    test_path = boost::filesystem::path(argv[1]);
+    test_path = std::filesystem::path(argv[1]);
     test_path /= "osrm.tst";
     osrm::util::Log(logDEBUG) << "temporary file: " << test_path.string();
 
@@ -74,7 +73,7 @@ int main(int argc, char *argv[])
     if (2 == argc)
     {
         // create file to test
-        if (boost::filesystem::exists(test_path))
+        if (std::filesystem::exists(test_path))
         {
             throw osrm::util::exception("Data file already exists: " + test_path.string() +
                                         SOURCE_REF);
@@ -120,7 +119,7 @@ int main(int argc, char *argv[])
     else
     {
         // Run Non-Cached I/O benchmarks
-        if (!boost::filesystem::exists(test_path))
+        if (!std::filesystem::exists(test_path))
         {
             throw osrm::util::exception("data file does not exist" + SOURCE_REF);
         }
@@ -298,9 +297,9 @@ int main(int argc, char *argv[])
                           << "max: " << stats.max << "ms, "
                           << "dev: " << stats.dev << "ms";
 
-        if (boost::filesystem::exists(test_path))
+        if (std::filesystem::exists(test_path))
         {
-            boost::filesystem::remove(test_path);
+            std::filesystem::remove(test_path);
             osrm::util::Log(logDEBUG) << "removing temporary files";
         }
     }

src/tools/partition.cpp

@@ -8,10 +8,10 @@
 #include "util/version.hpp"
 
 #include <boost/algorithm/string/join.hpp>
-#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 #include <boost/range/adaptor/transformed.hpp>
 
+#include <filesystem>
 #include <iostream>
 #include <iterator>
 #include <regex>
@@ -119,7 +119,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
         "input,i",
-        boost::program_options::value<boost::filesystem::path>(&config.base_path),
+        boost::program_options::value<std::filesystem::path>(&config.base_path),
         "Input base file path");
 
     // positional option
@@ -132,7 +132,7 @@ return_code parseArguments(int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        boost::filesystem::path(executable).filename().string() + " <input.osrm> [options]");
+        std::filesystem::path(executable).filename().string() + " <input.osrm> [options]");
     visible_options.add(generic_options).add(config_options);
 
     // parse command line options
@@ -216,9 +216,9 @@ try
         return EXIT_FAILURE;
     }
 
-    auto check_file = [](const boost::filesystem::path &path)
+    auto check_file = [](const std::filesystem::path &path)
     {
-        if (!boost::filesystem::is_regular_file(path))
+        if (!std::filesystem::is_regular_file(path))
         {
             util::Log(logERROR) << "Input file " << path << " not found!";
             return false;

src/tools/routed.cpp

@@ -12,7 +12,6 @@
 
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/any.hpp>
-#include <boost/filesystem.hpp>
 #include <boost/optional/optional_io.hpp>
 #include <boost/program_options.hpp>
 
@@ -22,6 +21,7 @@
 
 #include <chrono>
 #include <exception>
+#include <filesystem>
 #include <future>
 #include <iostream>
 #include <new>
@@ -102,7 +102,7 @@ void validate(boost::any &v, const std::vector<std::string> &values, double *, d
 // generate boost::program_options object for the routing part
 inline unsigned generateServerProgramOptions(const int argc,
                                              const char *argv[],
-                                             boost::filesystem::path &base_path,
+                                             std::filesystem::path &base_path,
                                              std::string &ip_address,
                                              int &ip_port,
                                              bool &trial,
@@ -110,8 +110,8 @@ inline unsigned generateServerProgramOptions(const int argc,
                                              int &requested_thread_num,
                                              short &keepalive_timeout)
 {
-    using boost::filesystem::path;
     using boost::program_options::value;
+    using std::filesystem::path;
 
     const auto hardware_threads = std::max<int>(1, std::thread::hardware_concurrency());
 
@@ -148,7 +148,7 @@ inline unsigned generateServerProgramOptions(const int argc,
          value<bool>(&config.use_shared_memory)->implicit_value(true)->default_value(false),
          "Load data from shared memory") //
         ("memory_file",
-         value<boost::filesystem::path>(&config.memory_file),
+         value<std::filesystem::path>(&config.memory_file),
          "DEPRECATED: Will behave the same as --mmap.")(
             "mmap,m",
             value<bool>(&config.use_mmap)->implicit_value(true)->default_value(false),
@@ -192,7 +192,7 @@ inline unsigned generateServerProgramOptions(const int argc,
     // hidden options, will be allowed on command line, but will not be shown to the user
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
-        "base,b", value<boost::filesystem::path>(&base_path), "base path to .osrm file");
+        "base,b", value<std::filesystem::path>(&base_path), "base path to .osrm file");
 
     // positional option
     boost::program_options::positional_options_description positional_options;
@@ -204,7 +204,7 @@ inline unsigned generateServerProgramOptions(const int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        boost::filesystem::path(executable).filename().string() + " <base.osrm> [<options>]");
+        std::filesystem::path(executable).filename().string() + " <base.osrm> [<options>]");
     visible_options.add(generic_options).add(config_options);
 
     // parse command line options
@@ -267,7 +267,7 @@ try
     int ip_port;
 
     EngineConfig config;
-    boost::filesystem::path base_path;
+    std::filesystem::path base_path;
 
     int requested_thread_num = 1;
     short keepalive_timeout = 5;

src/tools/store.cpp

@@ -11,11 +11,11 @@
 #include "util/version.hpp"
 
 #include <boost/algorithm/string/case_conv.hpp>
-#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 
 #include <csignal>
 #include <cstdlib>
+#include <filesystem>
 
 using namespace osrm;
 
@@ -97,7 +97,7 @@ void springClean()
 bool generateDataStoreOptions(const int argc,
                               const char *argv[],
                               std::string &verbosity,
-                              boost::filesystem::path &base_path,
+                              std::filesystem::path &base_path,
                               int &max_wait,
                               std::string &dataset_name,
                               bool &list_datasets,
@@ -155,7 +155,7 @@ bool generateDataStoreOptions(const int argc,
     // hidden options, will be allowed on command line but will not be shown to the user
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()("base,b",
-                                 boost::program_options::value<boost::filesystem::path>(&base_path),
+                                 boost::program_options::value<std::filesystem::path>(&base_path),
                                  "base path to .osrm file");
 
     // positional option
@@ -168,7 +168,7 @@ bool generateDataStoreOptions(const int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        boost::filesystem::path(executable).filename().string() + " [<options>] <configuration>");
+        std::filesystem::path(executable).filename().string() + " [<options>] <configuration>");
     visible_options.add(generic_options).add(config_options);
 
     // print help options if no infile is specified
@@ -242,7 +242,7 @@ try
     util::LogPolicy::GetInstance().Unmute();
 
     std::string verbosity;
-    boost::filesystem::path base_path;
+    std::filesystem::path base_path;
     int max_wait = -1;
     std::string dataset_name;
     bool list_datasets = false;

src/updater/updater.cpp

@@ -25,7 +25,6 @@
 #include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
-#include <boost/filesystem/fstream.hpp>
 
 #include <tbb/blocked_range.h>
 #include <tbb/concurrent_vector.h>
@@ -38,6 +37,7 @@
 #include <atomic>
 #include <bitset>
 #include <cstdint>
+#include <fstream>
 #include <iterator>
 #include <memory>
 #include <tuple>
@@ -408,7 +408,7 @@ void saveDatasourcesNames(const UpdaterConfig &config)
     // for rendering in the debug tiles.
     for (auto const &name : config.segment_speed_lookup_paths)
     {
-        sources.SetSourceName(source, boost::filesystem::path(name).stem().string());
+        sources.SetSourceName(source, std::filesystem::path(name).stem().string());
         source++;
     }
 

src/util/timezones.cpp

@@ -3,13 +3,11 @@
 #include "util/geojson_validation.hpp"
 #include "util/log.hpp"
 
-#include <boost/filesystem/fstream.hpp>
-#include <boost/filesystem/path.hpp>
-
 #include <rapidjson/document.h>
 #include <rapidjson/error/en.h>
 #include <rapidjson/istreamwrapper.h>
 
+#include <filesystem>
 #include <fstream>
 #include <optional>
 #include <regex>
@@ -40,7 +38,7 @@ Timezoner::Timezoner(const char geojson[], std::time_t utc_time_now)
     LoadLocalTimesRTree(doc, utc_time_now);
 }
 
-Timezoner::Timezoner(const boost::filesystem::path &tz_shapes_filename, std::time_t utc_time_now)
+Timezoner::Timezoner(const std::filesystem::path &tz_shapes_filename, std::time_t utc_time_now)
 {
     util::Log() << "Time zone validation based on UTC time : " << utc_time_now;
 

unit_tests/common/temporary_file.hpp

@@ -1,16 +1,39 @@
 #ifndef UNIT_TESTS_TEMPORARY_FILE_HPP
 #define UNIT_TESTS_TEMPORARY_FILE_HPP
 
-#include <boost/filesystem.hpp>
+#include <cstdlib>
+#include <filesystem>
+#include <random>
+#include <string>
+
+inline std::string random_string(std::string::size_type length)
+{
+    static auto &chrs = "0123456789"
+                        "abcdefghijklmnopqrstuvwxyz"
+                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+    thread_local static std::mt19937 rg{std::random_device{}()};
+    thread_local static std::uniform_int_distribution<std::string::size_type> pick(
+        0, sizeof(chrs) - 2);
+
+    std::string s;
+    s.reserve(length);
+
+    while (length--)
+    {
+        s += chrs[pick(rg)];
+    }
+    return s;
+}
 
 struct TemporaryFile
 {
-    TemporaryFile() : path(boost::filesystem::unique_path()) {}
+    TemporaryFile() : path(std::filesystem::temp_directory_path() / random_string(8)) {}
     TemporaryFile(const std::string &path) : path(path) {}
 
-    ~TemporaryFile() { boost::filesystem::remove(path); }
+    ~TemporaryFile() { std::filesystem::remove(path); }
 
-    boost::filesystem::path path;
+    std::filesystem::path path;
 };
 
 #endif // UNIT_TESTS_TEMPORARY_FILE_HPP

unit_tests/extractor/location_dependent_data_tests.cpp

@@ -1,11 +1,14 @@
 #include "extractor/location_dependent_data.hpp"
 
 #include "../common/range_tools.hpp"
+#include "../common/temporary_file.hpp"
 
-#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include <cstdlib>
+#include <filesystem>
 #include <fstream>
+#include <random>
 #include <vector>
 
 BOOST_AUTO_TEST_SUITE(location_dependent_data_tests)
@@ -16,14 +19,13 @@ using point_t = LocationDependentData::point_t;
 
 struct LocationDataFixture
 {
-    LocationDataFixture(const std::string &json) : temporary_file(boost::filesystem::unique_path())
+    LocationDataFixture(const std::string &json)
     {
-        std::ofstream file(temporary_file.string());
+        std::ofstream file(temporary_file.path.string());
         file << json;
     }
-    ~LocationDataFixture() { remove(temporary_file); }
 
-    boost::filesystem::path temporary_file;
+    TemporaryFile temporary_file;
 };
 
 BOOST_AUTO_TEST_CASE(polygon_tests)
@@ -50,7 +52,7 @@ BOOST_AUTO_TEST_CASE(polygon_tests)
 }
 ]})json");
 
-    LocationDependentData data({fixture.temporary_file});
+    LocationDependentData data({fixture.temporary_file.path});
 
     BOOST_CHECK(data.GetPropertyIndexes(point_t(0, 0)).empty());
     CHECK_EQUAL_RANGE(data.GetPropertyIndexes(point_t(1, 1)), 0);
@@ -86,7 +88,7 @@ BOOST_AUTO_TEST_CASE(multy_polygon_tests)
 }
 ]})json");
 
-    LocationDependentData data({fixture.temporary_file});
+    LocationDependentData data({fixture.temporary_file.path});
 
     BOOST_CHECK(data.GetPropertyIndexes(point_t(0, 2)).empty());
     BOOST_CHECK(data.GetPropertyIndexes(point_t(0, -3)).empty());
@@ -117,7 +119,7 @@ BOOST_AUTO_TEST_CASE(polygon_merging_tests)
 }
 ]})json");
 
-    LocationDependentData data({fixture.temporary_file});
+    LocationDependentData data({fixture.temporary_file.path});
 
     CHECK_EQUAL_RANGE(data.GetPropertyIndexes(point_t(-3, 3)), 0);
     CHECK_EQUAL_RANGE(data.GetPropertyIndexes(point_t(-3, 1)), 0);
@@ -153,7 +155,7 @@ BOOST_AUTO_TEST_CASE(staircase_polygon)
 }
 ]})json");
 
-    LocationDependentData data({fixture.temporary_file});
+    LocationDependentData data({fixture.temporary_file.path});
 
     // all corners
     BOOST_CHECK(!data.GetPropertyIndexes(point_t(0, 0)).empty());

unit_tests/extractor/name_table.cpp

@@ -3,9 +3,9 @@
 
 #include "../common/temporary_file.hpp"
 
-#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include <filesystem>
 #include <iomanip>
 #include <iostream>
 #include <sstream>

unit_tests/extractor/raster_source.cpp

@@ -4,9 +4,10 @@
 
 #include <osrm/coordinate.hpp>
 
-#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include <filesystem>
+
 BOOST_AUTO_TEST_SUITE(raster_source)
 
 using namespace osrm;

unit_tests/storage/data_layout.cpp

@@ -3,10 +3,10 @@
 #include "../common/range_tools.hpp"
 #include "../common/temporary_file.hpp"
 
-#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <cmath>
+#include <filesystem>
 
 BOOST_AUTO_TEST_SUITE(data_layout)
 

unit_tests/storage/serialization.cpp

@@ -5,9 +5,9 @@
 #include "../common/range_tools.hpp"
 #include "../common/temporary_file.hpp"
 
-#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include <filesystem>
 #include <random>
 
 BOOST_AUTO_TEST_SUITE(serialization)

unit_tests/updater/timezoner.cpp

@@ -2,9 +2,10 @@
 #include "util/geojson_validation.hpp"
 #include "util/timezones.hpp"
 
-#include <boost/filesystem/path.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include <filesystem>
+
 BOOST_AUTO_TEST_SUITE(timezoner)
 
 using namespace osrm;
@@ -22,7 +23,7 @@ BOOST_AUTO_TEST_CASE(timezoner_test)
     std::time_t now = time(0);
     BOOST_CHECK_NO_THROW(Timezoner tz(json, now));
 
-    boost::filesystem::path test_path(TEST_DATA_DIR "/test.geojson");
+    std::filesystem::path test_path(TEST_DATA_DIR "/test.geojson");
     BOOST_CHECK_NO_THROW(Timezoner tz(test_path, now));
 
     // missing opening bracket

unit_tests/util/serialization.cpp

@@ -3,9 +3,10 @@
 #include "../common/range_tools.hpp"
 #include "../common/temporary_file.hpp"
 
-#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include <filesystem>
+
 BOOST_AUTO_TEST_SUITE(serialization)
 
 using namespace osrm;

unit_tests/util/static_rtree.cpp

@@ -227,7 +227,7 @@ void sampling_verify_rtree(RTreeT &rtree,
 }
 
 template <typename RTreeT, typename FixtureT>
-auto make_rtree(const boost::filesystem::path &path, FixtureT &fixture)
+auto make_rtree(const std::filesystem::path &path, FixtureT &fixture)
 {
     return RTreeT(fixture.edges, fixture.coords, path);
 }