Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Replace boost::filesystem with std (#6432)

Browse Source
This commit is contained in:
Dennis Luxen 2024-06-20 21:44:28 +02:00 committed by GitHub
parent c3f2a6cdb9
commit f1eabc3ecc
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
64 changed files with 417 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/osrm-backend.yml vendored
View File

@ -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"

1
CHANGELOG.md
View File

@ -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)

2
features/support/env.js
View File

@ -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}`;

5
include/contractor/contractor_config.hpp
View File

@ -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);

4
include/contractor/files.hpp
View File

@ -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)
{

5
include/customizer/customizer_config.hpp
View File

@ -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);

2
include/customizer/edge_based_graph.hpp
View File

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

8
include/customizer/files.hpp
View File

@ -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)
{

2
include/engine/datafacade/contiguous_internalmem_datafacade.hpp
View File

@ -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;

5
include/engine/engine_config.hpp
View File

@ -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;

13
include/extractor/extractor_config.hpp
View File

@ -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;
boost::filesystem::path profile_path;
std::vector<boost::filesystem::path> location_dependent_data_paths;
std::filesystem::path input_path;
std::filesystem::path profile_path;
std::vector<std::filesystem::path> location_dependent_data_paths;
std::string data_version;
unsigned requested_num_threads = 0;

110
include/extractor/files.hpp
View File

@ -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,
const IntersectionBearingsT &intersection_bearings,
const EntryClassVectorT &entry_classes)
void writeIntersections(const std::filesystem::path &path,
const IntersectionBearingsT &intersection_bearings,
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,
IntersectionBearingsT &intersection_bearings,
EntryClassVectorT &entry_classes)
void readIntersections(const std::filesystem::path &path,
IntersectionBearingsT &intersection_bearings,
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,
ProfileProperties &properties)
inline void readProfileProperties(const std::filesystem::path &path, 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,
CoordinatesT &coordinates,
PackedOSMIDsT &osm_node_ids)
void readNodes(const std::filesystem::path &path,
CoordinatesT &coordinates,
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,
const CoordinatesT &coordinates,
const PackedOSMIDsT &osm_node_ids)
void writeNodes(const std::filesystem::path &path,
const CoordinatesT &coordinates,
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,
const std::vector<NBGToEBG> &mapping)
inline void writeNBGMapping(const std::filesystem::path &path, 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>
void readNames(const boost::filesystem::path &path, NameTableT &table)
template <typename NameTableT> void readNames(const std::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,
NodeDistancesVectorT &distances)
void readEdgeBasedNodeDistances(const std::filesystem::path &path, 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};

6
include/extractor/location_dependent_data.hpp
View File

@ -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;

3
include/extractor/node_based_graph_factory.hpp
View File

@ -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>

5
include/extractor/raster_source.hpp
View File

@ -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;

2
include/extractor/scripting_environment_lua.hpp
View File

@ -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;

5
include/extractor/segment_data_container.hpp
View File

@ -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

8
include/guidance/files.hpp
View File

@ -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)
{

6
include/partitioner/edge_based_graph_reader.hpp
View File

@ -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
// convert from forward to bi-directional edges again
// we only need to save the forward edges, since the read method
// 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;

12
include/partitioner/files.hpp
View File

@ -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)
{

5
include/partitioner/partitioner_config.hpp
View File

@ -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);
}

27
include/storage/io.hpp
View File

@ -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;
boost::filesystem::ifstream input_stream;
const std::filesystem::path filepath;
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;
boost::filesystem::ofstream output_stream;
const std::filesystem::path filepath;
std::ofstream output_stream;
FingerprintFlag fingerprint;
};

26
include/storage/io_config.hpp
View File

@ -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_,
std::vector<boost::filesystem::path> optional_input_files_,
std::vector<boost::filesystem::path> output_files_)
IOConfig(std::vector<std::filesystem::path> required_input_files_,
std::vector<std::filesystem::path> optional_input_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<boost::filesystem::path> optional_input_files;
std::vector<boost::filesystem::path> output_files;
std::vector<std::filesystem::path> required_input_files;
std::vector<std::filesystem::path> optional_input_files;
std::vector<std::filesystem::path> output_files;
};
} // namespace osrm::storage

18
include/storage/shared_memory.hpp
View File

@ -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();
boost::filesystem::path lock_file = temp_dir / ("osrm-" + std::to_string(id) + ".lock");
std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
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);

11
include/storage/storage.hpp
View File

@ -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, boost::filesystem::path>> GetStaticFiles();
std::vector<std::pair<bool, std::filesystem::path>> GetUpdatableFiles();
std::vector<std::pair<bool, std::filesystem::path>> GetStaticFiles();
private:
StorageConfig config;

13
include/storage/storage_config.hpp
View File

@ -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_)
{

12
include/storage/tar.hpp
View File

@ -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

2
include/storage/view_factory.hpp
View File

@ -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);

4
include/updater/csv_file_parser.hpp
View File

@ -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);

11
include/updater/updater_config.hpp
View File

@ -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);
}

4
include/util/lua_util.hpp
View File

@ -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());

19
include/util/mmap_file.hpp
View File

@ -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,
MmapContainerT &mmap_container,
const std::size_t size)
util::vector_view<T>
mmapFile(const std::filesystem::path &file, MmapContainerT &mmap_container, 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)
{

2
include/util/mmap_tar.hpp
View File

@ -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;

8
include/util/static_rtree.hpp
View File

@ -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()),

4
include/util/timezones.hpp
View File

@ -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;

96
scripts/ci/windows-build.bat Normal file
View File

@ -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%

3
src/benchmarks/static_rtree.cpp
View File

@ -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
{

2
src/engine/datafacade/mmap_memory_allocator.cpp
View File

@ -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>();

5
src/extractor/compressed_edge_container.cpp
View File

@ -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>

8
src/extractor/location_dependent_data.cpp
View File

@ -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");

4
src/extractor/raster_source.cpp
View File

@ -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);
if (!boost::filesystem::exists(filepath))
std::filesystem::path filepath(path_string);
if (!std::filesystem::exists(filepath))
{
throw util::RuntimeError(
path_string, ErrorCode::FileOpenError, SOURCE_REF, "File not found");

2
src/extractor/scripting_environment_lua.cpp
View File

@ -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;

15
src/partitioner/partitioner.cpp
View File

@ -19,16 +19,15 @@
#include "util/json_container.hpp"
#include "util/log.hpp"
#include "util/mmap_file.hpp"
#include <algorithm>
#include <iterator>
#include <vector>
#include "util/timing_util.hpp"
#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";

6
src/storage/io_config.cpp
View File

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

50
src/storage/storage.cpp
View File

@ -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 =
boost::filesystem::temp_directory_path() / "osrm-datastore.lock";
if (!boost::filesystem::exists(lock_path))
std::filesystem::path lock_path =
std::filesystem::temp_directory_path() / "osrm-datastore.lock";
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;

4
src/tools/components.cpp
View File

@ -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;

6
src/tools/contract.cpp
View File

@ -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);

6
src/tools/customize.cpp
View File

@ -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

18
src/tools/extract.cpp
View File

@ -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!";

17
src/tools/io-benchmark.cpp
View File

@ -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";
}
}

10
src/tools/partition.cpp
View File

@ -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;

14
src/tools/routed.cpp
View File

@ -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;

10
src/tools/store.cpp
View File

@ -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;

4
src/updater/updater.cpp
View File

@ -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++;
}

6
src/util/timezones.cpp
View File

@ -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;

31
unit_tests/common/temporary_file.hpp
View File

@ -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

20
unit_tests/extractor/location_dependent_data_tests.cpp
View File

@ -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());

2
unit_tests/extractor/name_table.cpp
View File

@ -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>

3
unit_tests/extractor/raster_source.cpp
View File

@ -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;

2
unit_tests/storage/data_layout.cpp
View File

@ -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)

2
unit_tests/storage/serialization.cpp
View File

@ -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)

5
unit_tests/updater/timezoner.cpp
View File

@ -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

3
unit_tests/util/serialization.cpp
View File

@ -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;

2
unit_tests/util/static_rtree.cpp
View File

@ -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);
}