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

Final merge commit

Browse Source
This commit is contained in:
Mugr Rex 2023-04-20 16:04:04 +02:00
parent 0ca913132a
commit 45bfe937aa
21 changed files with 100 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -10,6 +10,7 @@
- NodeJS:
- CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
- Misc:
- FIXED: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551), see also [#6592](https://github.com/Project-OSRM/osrm-backend/issues/6592)
- CHANGED: keep libosrm* in the docker image for downstream linking [#6602](https://github.com/Project-OSRM/osrm-backend/pull/6602)
- CHANGED: Move vector in CSVFilesParser instead copying it. [#6470](https://github.com/Project-OSRM/osrm-backend/pull/6470)
- REMOVED: Get rid of unused functions in util/json_util.hpp. [#6446](https://github.com/Project-OSRM/osrm-backend/pull/6446)

46
include/extractor/intersection/node_based_graph_walker.hpp
View File

@ -11,8 +11,8 @@
#include "util/typedefs.hpp"
#include <boost/assert.hpp>
#include <boost/optional.hpp>
#include <cstdint>
#include <optional>
#include <utility>
namespace osrm::extractor::intersection
@ -42,10 +42,10 @@ class NodeBasedGraphWalker
* selector not provinding any further edge to traverse)
*/
template <class accumulator_type, class selector_type>
boost::optional<std::pair<NodeID, EdgeID>> TraverseRoad(NodeID starting_at_node_id,
EdgeID following_edge_id,
accumulator_type &accumulator,
const selector_type &selector) const;
std::optional<std::pair<NodeID, EdgeID>> TraverseRoad(NodeID starting_at_node_id,
EdgeID following_edge_id,
accumulator_type &accumulator,
const selector_type &selector) const;
private:
const util::NodeBasedDynamicGraph &node_based_graph;
@ -111,11 +111,11 @@ struct SelectRoadByNameOnlyChoiceAndStraightness
* traversal. If no such edge is found, return {} is allowed. Usually you want to choose some
* form of obious turn to follow.
*/
boost::optional<EdgeID> operator()(const NodeID nid,
const EdgeID via_edge_id,
const IntersectionView &intersection,
const util::NodeBasedDynamicGraph &node_based_graph,
const EdgeBasedNodeDataContainer &node_data_container) const;
std::optional<EdgeID> operator()(const NodeID nid,
const EdgeID via_edge_id,
const IntersectionView &intersection,
const util::NodeBasedDynamicGraph &node_based_graph,
const EdgeBasedNodeDataContainer &node_data_container) const;
private:
const NameID desired_name_id;
@ -138,11 +138,11 @@ struct SelectStraightmostRoadByNameAndOnlyChoice
* traversal. If no such edge is found, return {} is allowed. Usually you want to choose some
* form of obious turn to follow.
*/
boost::optional<EdgeID> operator()(const NodeID nid,
const EdgeID via_edge_id,
const IntersectionView &intersection,
const util::NodeBasedDynamicGraph &node_based_graph,
const EdgeBasedNodeDataContainer &node_data_container) const;
std::optional<EdgeID> operator()(const NodeID nid,
const EdgeID via_edge_id,
const IntersectionView &intersection,
const util::NodeBasedDynamicGraph &node_based_graph,
const EdgeBasedNodeDataContainer &node_data_container) const;
private:
const NameID desired_name_id;
@ -187,7 +187,7 @@ struct IntersectionFinderAccumulator
};
template <class accumulator_type, class selector_type>
boost::optional<std::pair<NodeID, EdgeID>>
std::optional<std::pair<NodeID, EdgeID>>
NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,
EdgeID current_edge_id,
accumulator_type &accumulator,
@ -254,19 +254,19 @@ NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,
struct SkipTrafficSignalBarrierRoadSelector
{
boost::optional<EdgeID> operator()(const NodeID,
const EdgeID,
const IntersectionView &intersection,
const util::NodeBasedDynamicGraph &,
const EdgeBasedNodeDataContainer &) const
std::optional<EdgeID> operator()(const NodeID,
const EdgeID,
const IntersectionView &intersection,
const util::NodeBasedDynamicGraph &,
const EdgeBasedNodeDataContainer &) const
{
if (intersection.isTrafficSignalOrBarrier())
{
return boost::make_optional(intersection[1].eid);
return std::make_optional(intersection[1].eid);
}
else
{
return boost::none;
return std::nullopt;
}
}
};

4
include/extractor/maneuver_override_relation_parser.hpp
View File

@ -3,7 +3,7 @@
#include "maneuver_override.hpp"
#include <boost/optional.hpp>
#include <optional>
#include <string>
#include <vector>
@ -55,7 +55,7 @@ class ManeuverOverrideRelationParser
{
public:
ManeuverOverrideRelationParser();
boost::optional<InputManeuverOverride> TryParse(const osmium::Relation &relation) const;
std::optional<InputManeuverOverride> TryParse(const osmium::Relation &relation) const;
};
} // namespace osrm::extractor

4
include/extractor/profile_properties.hpp
View File

@ -7,11 +7,11 @@
#include <boost/assert.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <boost/optional.hpp>
#include <algorithm>
#include <array>
#include <cstdint>
#include <optional>
namespace osrm::extractor
{
@ -80,7 +80,7 @@ struct ProfileProperties
}
// Check if this classes are excludable
boost::optional<std::size_t> ClassesAreExcludable(ClassData classes) const
std::optional<std::size_t> ClassesAreExcludable(ClassData classes) const
{
auto iter = std::find(excludable_classes.begin(), excludable_classes.end(), classes);
if (iter != excludable_classes.end())

5
include/guidance/intersection_handler.hpp
View File

@ -15,11 +15,10 @@
#include <algorithm>
#include <cstddef>
#include <optional>
#include <utility>
#include <vector>
#include <boost/optional.hpp>
namespace osrm::guidance
{
@ -129,7 +128,7 @@ class IntersectionHandler
// ^ via
//
// For this scenario returns intersection at `b` and `b`.
boost::optional<IntersectionHandler::IntersectionViewAndNode>
std::optional<IntersectionHandler::IntersectionViewAndNode>
getNextIntersection(const NodeID at, const EdgeID via) const;
bool isSameName(const EdgeID source_edge_id, const EdgeID target_edge_id) const;

9
include/guidance/sliproad_handler.hpp
View File

@ -9,10 +9,9 @@
#include "util/node_based_graph.hpp"
#include <optional>
#include <vector>
#include <boost/optional.hpp>
namespace osrm::guidance
{
@ -43,9 +42,9 @@ class SliproadHandler final : public IntersectionHandler
Intersection intersection) const override final;
private:
boost::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
const Intersection &intersection,
const NodeID at) const;
std::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
const Intersection &intersection,
const NodeID at) const;
// Next intersection from `start` onto `onto` is too far away for a Siproad scenario
bool nextIntersectionIsTooFarAway(const NodeID start, const EdgeID onto) const;

7
include/guidance/turn_handler.hpp
View File

@ -11,9 +11,8 @@
#include "util/attributes.hpp"
#include "util/node_based_graph.hpp"
#include <boost/optional.hpp>
#include <cstddef>
#include <optional>
#include <utility>
#include <vector>
@ -72,7 +71,7 @@ class TurnHandler final : public IntersectionHandler
bool hasObvious(const EdgeID &via_edge, const Fork &fork) const;
boost::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;
std::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;
bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const;
@ -96,7 +95,7 @@ class TurnHandler final : public IntersectionHandler
handleDistinctConflict(const EdgeID via_edge, ConnectedRoad &left, ConnectedRoad &right) const;
// Classification
boost::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
std::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
OSRM_ATTR_WARN_UNUSED
Intersection assignLeftTurns(const EdgeID via_edge,

8
include/nodejs/node_osrm_support.hpp
View File

@ -21,11 +21,11 @@
#include <napi.h>
#include <boost/assert.hpp>
#include <boost/optional.hpp>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
@ -345,11 +345,11 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
return engine_config;
}
inline boost::optional<std::vector<osrm::Coordinate>>
inline std::optional<std::vector<osrm::Coordinate>>
parseCoordinateArray(const Napi::Array &coordinates_array)
{
Napi::HandleScope scope(coordinates_array.Env());
boost::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
std::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
std::vector<osrm::Coordinate> temp_coordinates;
for (uint32_t i = 0; i < coordinates_array.Length(); ++i)
@ -968,7 +968,7 @@ inline bool parseCommonParameters(const Napi::Object &obj, ParamType &params)
inline PluginParameters argumentsToPluginParameters(
const Napi::CallbackInfo &args,
const boost::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
const std::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
{
if (args.Length() < 3 || !args[1].IsObject())
{

8
include/util/coordinate_calculation.hpp
View File

@ -4,11 +4,11 @@
#include "util/coordinate.hpp"
#include <boost/math/constants/constants.hpp>
#include <boost/optional.hpp>
#include <algorithm>
#include <cmath>
#include <numeric>
#include <optional>
#include <utility>
#include <vector>
@ -102,9 +102,9 @@ double bearing(const Coordinate first_coordinate, const Coordinate second_coordi
double computeAngle(const Coordinate first, const Coordinate second, const Coordinate third);
// find the center of a circle through three coordinates
boost::optional<Coordinate> circleCenter(const Coordinate first_coordinate,
const Coordinate second_coordinate,
const Coordinate third_coordinate);
std::optional<Coordinate> circleCenter(const Coordinate first_coordinate,
const Coordinate second_coordinate,
const Coordinate third_coordinate);
// find the radius of a circle through three coordinates
double circleRadius(const Coordinate first_coordinate,

11
include/util/geojson_debug_policies.hpp
View File

@ -1,6 +1,7 @@
#ifndef OSRM_GEOJSON_DEBUG_POLICIES
#define OSRM_GEOJSON_DEBUG_POLICIES
#include <optional>
#include <vector>
#include "extractor/query_node.hpp"
@ -9,8 +10,6 @@
#include "util/node_based_graph.hpp"
#include "util/typedefs.hpp"
#include <boost/optional.hpp>
namespace osrm::util
{
@ -20,7 +19,7 @@ struct NodeIdVectorToLineString
// converts a vector of node ids into a linestring geojson feature
util::json::Object operator()(const std::vector<NodeID> &node_ids,
const boost::optional<json::Object> &properties = {}) const;
const std::optional<json::Object> &properties = {}) const;
const std::vector<util::Coordinate> &node_coordinates;
};
@ -29,7 +28,7 @@ struct CoordinateVectorToLineString
{
// converts a vector of node ids into a linestring geojson feature
util::json::Object operator()(const std::vector<util::Coordinate> &coordinates,
const boost::optional<json::Object> &properties = {}) const;
const std::optional<json::Object> &properties = {}) const;
};
struct NodeIdVectorToMultiPoint
@ -38,7 +37,7 @@ struct NodeIdVectorToMultiPoint
// converts a vector of node ids into a linestring geojson feature
util::json::Object operator()(const std::vector<NodeID> &node_ids,
const boost::optional<json::Object> &properties = {}) const;
const std::optional<json::Object> &properties = {}) const;
const std::vector<util::Coordinate> &node_coordinates;
};
@ -47,7 +46,7 @@ struct CoordinateVectorToMultiPoint
{
// converts a vector of node ids into a linestring geojson feature
util::json::Object operator()(const std::vector<util::Coordinate> &coordinates,
const boost::optional<json::Object> &properties = {}) const;
const std::optional<json::Object> &properties = {}) const;
};
} // namespace osrm::util

5
include/util/geojson_debug_policy_toolkit.hpp
View File

@ -7,8 +7,7 @@
#include <algorithm>
#include <iterator>
#include <boost/optional.hpp>
#include <optional>
namespace osrm::util
{
@ -84,7 +83,7 @@ struct NodeIdToCoordinate
inline util::json::Object makeFeature(std::string type,
util::json::Array coordinates,
const boost::optional<util::json::Object> &properties = {})
const std::optional<util::json::Object> &properties = {})
{
util::json::Object result;
result.values["type"] = "Feature";

14
include/util/query_heap.hpp
View File

@ -3,11 +3,11 @@
#include <boost/assert.hpp>
#include <boost/heap/d_ary_heap.hpp>
#include <boost/optional.hpp>
#include <algorithm>
#include <limits>
#include <map>
#include <optional>
#include <unordered_map>
#include <vector>
@ -289,26 +289,26 @@ class QueryHeap
return inserted_nodes[index].node == node;
}
boost::optional<HeapNode &> GetHeapNodeIfWasInserted(const NodeID node)
HeapNode *GetHeapNodeIfWasInserted(const NodeID node)
{
const auto index = node_index.peek_index(node);
if (index >= static_cast<decltype(index)>(inserted_nodes.size()) ||
inserted_nodes[index].node != node)
{
return {};
return nullptr;
}
return inserted_nodes[index];
return &inserted_nodes[index];
}
boost::optional<const HeapNode &> GetHeapNodeIfWasInserted(const NodeID node) const
const HeapNode *GetHeapNodeIfWasInserted(const NodeID node) const
{
const auto index = node_index.peek_index(node);
if (index >= static_cast<decltype(index)>(inserted_nodes.size()) ||
inserted_nodes[index].node != node)
{
return {};
return nullptr;
}
return inserted_nodes[index];
return &inserted_nodes[index];
}
NodeID Min() const

4
include/util/timezones.hpp
View File

@ -6,11 +6,11 @@
#include <boost/filesystem/path.hpp>
#include <boost/geometry.hpp>
#include <boost/geometry/index/rtree.hpp>
#include <boost/optional.hpp>
#include <rapidjson/document.h>
#include <chrono>
#include <optional>
namespace osrm::updater
{
@ -34,7 +34,7 @@ class Timezoner
Timezoner(const char geojson[], std::time_t utc_time_now);
Timezoner(const boost::filesystem::path &tz_shapes_filename, std::time_t utc_time_now);
boost::optional<struct tm> operator()(const point_t &point) const;
std::optional<struct tm> operator()(const point_t &point) const;
private:
void LoadLocalTimesRTree(rapidjson::Document &geojson, std::time_t utc_time);

6
src/extractor/intersection/node_based_graph_walker.cpp
View File

@ -66,7 +66,7 @@ SelectRoadByNameOnlyChoiceAndStraightness::SelectRoadByNameOnlyChoiceAndStraight
{
}
boost::optional<EdgeID> SelectRoadByNameOnlyChoiceAndStraightness::operator()(
std::optional<EdgeID> SelectRoadByNameOnlyChoiceAndStraightness::operator()(
const NodeID /*nid*/,
const EdgeID /*via_edge_id*/,
const IntersectionView &intersection,
@ -116,7 +116,7 @@ SelectStraightmostRoadByNameAndOnlyChoice::SelectStraightmostRoadByNameAndOnlyCh
{
}
boost::optional<EdgeID> SelectStraightmostRoadByNameAndOnlyChoice::operator()(
std::optional<EdgeID> SelectStraightmostRoadByNameAndOnlyChoice::operator()(
const NodeID /*nid*/,
const EdgeID /*via_edge_id*/,
const IntersectionView &intersection,
@ -234,7 +234,7 @@ boost::optional<EdgeID> SelectStraightmostRoadByNameAndOnlyChoice::operator()(
return {};
}
return is_only_choice_with_same_name ? boost::optional<EdgeID>(min_element->eid) : boost::none;
return is_only_choice_with_same_name ? std::optional<EdgeID>(min_element->eid) : std::nullopt;
}
// ---------------------------------------------------------------------------------

8
src/extractor/maneuver_override_relation_parser.cpp
View File

@ -1,9 +1,9 @@
#include "extractor/maneuver_override_relation_parser.hpp"
#include "extractor/maneuver_override.hpp"
#include <boost/optional/optional.hpp>
#include <boost/ref.hpp>
#include <optional>
#include <osmium/osm.hpp>
#include <osmium/tags/filter.hpp>
#include <osmium/tags/taglist.hpp>
@ -21,7 +21,7 @@ ManeuverOverrideRelationParser::ManeuverOverrideRelationParser() {}
* into an InputManeuverOverride object, if the relation is considered
* valid (i.e. has the minimum tags we expect).
*/
boost::optional<InputManeuverOverride>
std::optional<InputManeuverOverride>
ManeuverOverrideRelationParser::TryParse(const osmium::Relation &relation) const
{
@ -35,7 +35,7 @@ ManeuverOverrideRelationParser::TryParse(const osmium::Relation &relation) const
if (osmium::tags::match_none_of(tag_list, filter))
// if it's not a maneuver, continue;
{
return boost::none;
return std::nullopt;
}
// we pretend every restriction is a conditional restriction. If we do not find any restriction,
@ -130,7 +130,7 @@ ManeuverOverrideRelationParser::TryParse(const osmium::Relation &relation) const
}
else
{
return boost::none;
return std::nullopt;
}
return maneuver_override;
}

9
src/guidance/intersection_handler.cpp
View File

@ -426,7 +426,7 @@ void IntersectionHandler::assignTrivialTurns(const EdgeID via_eid,
}
}
boost::optional<IntersectionHandler::IntersectionViewAndNode>
std::optional<IntersectionHandler::IntersectionViewAndNode>
IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) const
{
// We use the intersection generator to jump over traffic signals, barriers. The intersection
@ -449,7 +449,7 @@ IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) cons
if (intersection_parameters.node == SPECIAL_NODEID ||
intersection_parameters.edge == SPECIAL_EDGEID)
{
return boost::none;
return {};
}
auto intersection = extractor::intersection::getConnectedRoads<false>(node_based_graph,
@ -464,11 +464,10 @@ IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) cons
if (intersection.size() <= 2 || intersection.isTrafficSignalOrBarrier())
{
return boost::none;
return {};
}
return boost::make_optional(
IntersectionViewAndNode{std::move(intersection), intersection_node});
return std::make_optional(IntersectionViewAndNode{std::move(intersection), intersection_node});
}
bool IntersectionHandler::isSameName(const EdgeID source_edge_id, const EdgeID target_edge_id) const

18
src/guidance/sliproad_handler.cpp
View File

@ -627,7 +627,7 @@ Intersection SliproadHandler::operator()(const NodeID /*nid*/,
// Implementation details
boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
std::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
const EdgeID from, const Intersection &intersection, const NodeID at) const
{
BOOST_ASSERT(from != SPECIAL_EDGEID);
@ -638,14 +638,14 @@ boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
if (index != 0)
{
return boost::make_optional(index);
return std::make_optional(index);
}
// Otherwise check if the road is forking into two and one of them is a Sliproad;
// then the non-Sliproad is the obvious one.
if (intersection.size() != 3)
{
return boost::none;
return {};
}
const auto forking = intersection[1].instruction.type == TurnType::Fork &&
@ -653,7 +653,7 @@ boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
if (!forking)
{
return boost::none;
return {};
}
const auto first = getNextIntersection(at, intersection.getRightmostRoad().eid);
@ -661,27 +661,27 @@ boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
if (!first || !second)
{
return boost::none;
return {};
}
if (first->intersection.isDeadEnd() || second->intersection.isDeadEnd())
{
return boost::none;
return {};
}
// In case of loops at the end of the road, we will arrive back at the intersection
// itself. If that is the case, the road is obviously not a sliproad.
if (canBeTargetOfSliproad(first->intersection) && at != second->node)
{
return boost::make_optional(std::size_t{2});
return std::make_optional(std::size_t{2});
}
if (canBeTargetOfSliproad(second->intersection) && at != first->node)
{
return boost::make_optional(std::size_t{1});
return std::make_optional(std::size_t{1});
}
return boost::none;
return {};
}
bool SliproadHandler::nextIntersectionIsTooFarAway(const NodeID start, const EdgeID onto) const

12
src/guidance/turn_handler.cpp
View File

@ -6,10 +6,10 @@
#include <algorithm>
#include <limits>
#include <optional>
#include <utility>
#include <boost/assert.hpp>
#include <boost/optional.hpp>
using osrm::util::angularDeviation;
@ -585,7 +585,7 @@ Intersection TurnHandler::assignRightTurns(const EdgeID via_edge,
}
// finds a fork candidate by just looking at the geometry and angle of an intersection
boost::optional<TurnHandler::Fork>
std::optional<TurnHandler::Fork>
TurnHandler::findForkCandidatesByGeometry(Intersection &intersection) const
{
if (intersection.size() >= 3)
@ -642,7 +642,7 @@ TurnHandler::findForkCandidatesByGeometry(Intersection &intersection) const
}
}
}
return boost::none;
return {};
}
// check if the fork candidates (all roads between left and right) and the
@ -678,8 +678,8 @@ bool TurnHandler::isCompatibleByRoadClass(const Intersection &intersection, cons
// Checks whether a three-way-intersection coming from `via_edge` is a fork
// with `intersection` as described as in #IntersectionExplanation@intersection_handler.hpp
boost::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
Intersection &intersection) const
std::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
Intersection &intersection) const
{
auto fork = findForkCandidatesByGeometry(intersection);
if (fork)
@ -720,7 +720,7 @@ boost::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
}
}
return boost::none;
return {};
}
void TurnHandler::handleDistinctConflict(const EdgeID via_edge,

11
src/util/coordinate_calculation.cpp
View File

@ -9,6 +9,7 @@
#include <algorithm>
#include <iterator>
#include <limits>
#include <optional>
#include <utility>
namespace osrm::util::coordinate_calculation
@ -173,14 +174,14 @@ double computeAngle(const Coordinate first, const Coordinate second, const Coord
return angle;
}
boost::optional<Coordinate>
std::optional<Coordinate>
circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
{
// free after http://paulbourke.net/geometry/circlesphere/
// require three distinct points
if (C1 == C2 || C2 == C3 || C1 == C3)
{
return boost::none;
return {};
}
// define line through c1, c2 and c2,c3
@ -195,7 +196,7 @@ circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
(std::abs(C2C1_lat) < std::numeric_limits<double>::epsilon() &&
std::abs(C3C2_lat) < std::numeric_limits<double>::epsilon()))
{
return boost::none;
return {};
}
else if (std::abs(C2C1_lon) < std::numeric_limits<double>::epsilon())
{
@ -233,7 +234,7 @@ circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
// can this ever happen?
if (std::abs(C2C1_slope - C3C2_slope) < std::numeric_limits<double>::epsilon())
return boost::none;
return {};
const double C1_y = static_cast<double>(toFloating(C1.lat));
const double C1_x = static_cast<double>(toFloating(C1.lon));
@ -247,7 +248,7 @@ circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
(2 * (C3C2_slope - C2C1_slope));
const double lat = (0.5 * (C1_x + C2_x) - lon) / C2C1_slope + 0.5 * (C1_y + C2_y);
if (lon < -180.0 || lon > 180.0 || lat < -90.0 || lat > 90.0)
return boost::none;
return {};
else
return Coordinate(FloatLongitude{lon}, FloatLatitude{lat});
}

8
src/util/geojson_debug_policies.cpp
View File

@ -17,7 +17,7 @@ NodeIdVectorToLineString::NodeIdVectorToLineString(
// converts a vector of node ids into a linestring geojson feature
util::json::Object
NodeIdVectorToLineString::operator()(const std::vector<NodeID> &node_ids,
const boost::optional<json::Object> &properties) const
const std::optional<json::Object> &properties) const
{
util::json::Array coordinates;
std::transform(node_ids.begin(),
@ -37,7 +37,7 @@ NodeIdVectorToMultiPoint::NodeIdVectorToMultiPoint(
util::json::Object
NodeIdVectorToMultiPoint::operator()(const std::vector<NodeID> &node_ids,
const boost::optional<json::Object> &properties) const
const std::optional<json::Object> &properties) const
{
util::json::Array coordinates;
std::transform(node_ids.begin(),
@ -51,7 +51,7 @@ NodeIdVectorToMultiPoint::operator()(const std::vector<NodeID> &node_ids,
//----------------------------------------------------------------
util::json::Object
CoordinateVectorToMultiPoint::operator()(const std::vector<util::Coordinate> &input_coordinates,
const boost::optional<json::Object> &properties) const
const std::optional<json::Object> &properties) const
{
auto coordinates = makeJsonArray(input_coordinates);
return makeFeature("MultiPoint", std::move(coordinates), properties);
@ -60,7 +60,7 @@ CoordinateVectorToMultiPoint::operator()(const std::vector<util::Coordinate> &in
//----------------------------------------------------------------
util::json::Object
CoordinateVectorToLineString::operator()(const std::vector<util::Coordinate> &input_coordinates,
const boost::optional<json::Object> &properties) const
const std::optional<json::Object> &properties) const
{
auto coordinates = makeJsonArray(input_coordinates);
return makeFeature("LineString", std::move(coordinates), properties);

6
src/util/timezones.cpp
View File

@ -5,13 +5,13 @@
#include <boost/filesystem/fstream.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/optional.hpp>
#include <rapidjson/document.h>
#include <rapidjson/error/en.h>
#include <rapidjson/istreamwrapper.h>
#include <fstream>
#include <optional>
#include <regex>
#include <string>
#include <unordered_map>
@ -157,7 +157,7 @@ void Timezoner::LoadLocalTimesRTree(rapidjson::Document &geojson, std::time_t ut
rtree = rtree_t(polygons);
}
boost::optional<struct tm> Timezoner::operator()(const point_t &point) const
std::optional<struct tm> Timezoner::operator()(const point_t &point) const
{
std::vector<rtree_t::value_type> result;
rtree.query(boost::geometry::index::intersects(point), std::back_inserter(result));
@ -167,6 +167,6 @@ boost::optional<struct tm> Timezoner::operator()(const point_t &point) const
if (boost::geometry::within(point, local_times[index].first))
return local_times[index].second;
}
return boost::none;
return {};
}
} // namespace osrm::updater