Merge branch 'master' into avoid_samelookup_in_heap_map

.travis.yml

@@ -62,8 +62,8 @@ matrix:
         - npm ci --ignore-scripts
       script:
         - ./scripts/check_taginfo.py taginfo.json profiles/car.lua
-        - ${MASON} install clang-format 3.8.1
+        - ${MASON} install clang-format 10.0.0
-        - PATH=$(${MASON} prefix clang-format 3.8.1)/bin:${PATH} ./scripts/format.sh && ./scripts/error_on_dirty.sh
+        - PATH=$(${MASON} prefix clang-format 10.0.0)/bin:${PATH} ./scripts/format.sh && ./scripts/error_on_dirty.sh
         - node ./scripts/validate_changelog.js
         # See issue 4043
         #- npm run docs && ./scripts/error_on_dirty.sh

include/contractor/contract_excludable_graph.hpp

@@ -94,7 +94,7 @@ inline auto contractExcludableGraph(ContractorGraph contractor_graph_,
     return GraphAndFilter{QueryGraph{num_nodes, std::move(edge_container.edges)},
                           edge_container.MakeEdgeFilters()};
 }
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif

include/contractor/contracted_edge_container.hpp

@@ -164,7 +164,7 @@ struct ContractedEdgeContainer
     std::vector<MergedFlags> flags;
     std::vector<QueryEdge> edges;
 };
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif

include/contractor/contracted_metric.hpp

@@ -15,11 +15,11 @@ template <storage::Ownership Ownership> struct ContractedMetric
     detail::QueryGraph<Ownership> graph;
     std::vector<util::ViewOrVector<bool, Ownership>> edge_filter;
 };
-}
+} // namespace detail
 
 using ContractedMetric = detail::ContractedMetric<storage::Ownership::Container>;
 using ContractedMetricView = detail::ContractedMetric<storage::Ownership::View>;
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif

include/contractor/contractor.hpp

@@ -49,7 +49,7 @@ class Contractor
   private:
     ContractorConfig config;
 };
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif // PROCESSING_CHAIN_HPP

include/contractor/contractor_config.hpp

@@ -73,7 +73,7 @@ struct ContractorConfig final : storage::IOConfig
     //(e.g. 0.8 contracts 80 percent of the hierarchy, leaving a core of 20%)
     double core_factor;
 };
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif // EXTRACTOR_OPTIONS_HPP

include/contractor/crc32_processor.hpp

@@ -125,7 +125,7 @@ struct RangebasedCRC32
   private:
     IteratorbasedCRC32 crc32;
 };
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif /* ITERATOR_BASED_CRC32_H */

include/contractor/files.hpp

@@ -52,8 +52,8 @@ inline void writeGraph(const boost::filesystem::path &path,
         serialization::write(writer, "/ch/metrics/" + pair.first, pair.second);
     }
 }
-}
+} // namespace files
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif

include/contractor/query_edge.hpp

@@ -77,7 +77,7 @@ struct QueryEdge
                 data.distance == right.data.distance);
     }
 };
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif // QUERYEDGE_HPP

include/contractor/query_graph.hpp

@@ -19,7 +19,7 @@ using QueryGraph = util::StaticGraph<typename QueryEdge::EdgeData, Ownership>;
 
 using QueryGraph = detail::QueryGraph<storage::Ownership::Container>;
 using QueryGraphView = detail::QueryGraph<storage::Ownership::View>;
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif // QUERYEDGE_HPP

include/contractor/serialization.hpp

@@ -46,8 +46,8 @@ void read(storage::tar::FileReader &reader,
                                      metric.edge_filter[index]);
     }
 }
-}
+} // namespace serialization
-}
+} // namespace contractor
-}
+} // namespace osrm
 
 #endif

include/customizer/cell_customizer.hpp

@@ -212,9 +212,8 @@ class CellCustomizer
             }
 
             const auto &data = graph.GetEdgeData(edge);
-            if (data.forward &&
+            if (data.forward && (first_level || partition.GetCell(level - 1, node) !=
-                (first_level ||
+                                                    partition.GetCell(level - 1, to)))
-                 partition.GetCell(level - 1, node) != partition.GetCell(level - 1, to)))
             {
                 const EdgeWeight to_weight = weight + data.weight;
                 const EdgeDuration to_duration = duration + data.duration;
@@ -237,7 +236,7 @@ class CellCustomizer
 
     const partitioner::MultiLevelPartition &partition;
 };
-}
+} // namespace customizer
-}
+} // namespace osrm
 
 #endif // OSRM_CELLS_CUSTOMIZER_HPP

include/customizer/cell_metric.hpp

@@ -22,11 +22,11 @@ template <storage::Ownership Ownership> struct CellMetricImpl
     Vector<EdgeDuration> durations;
     Vector<EdgeDistance> distances;
 };
-}
+} // namespace detail
 
 using CellMetric = detail::CellMetricImpl<storage::Ownership::Container>;
 using CellMetricView = detail::CellMetricImpl<storage::Ownership::View>;
-}
+} // namespace customizer
-}
+} // namespace osrm
 
 #endif

include/customizer/customizer_config.hpp

@@ -39,7 +39,7 @@ struct CustomizationConfig final : storage::IOConfig
 
     updater::UpdaterConfig updater_config;
 };
-}
+} // namespace customizer
-}
+} // namespace osrm
 
 #endif // OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP

include/customizer/edge_based_graph.hpp

@@ -34,7 +34,7 @@ template <typename EdgeDataT, storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
            const MultiLevelGraph<EdgeDataT, Ownership> &graph);
-}
+} // namespace serialization
 
 template <typename EdgeDataT, storage::Ownership Ownership>
 class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership>
@@ -126,7 +126,7 @@ using MultiLevelEdgeBasedGraph =
     MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
 using MultiLevelEdgeBasedGraphView =
     MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
-}
+} // namespace customizer
-}
+} // namespace osrm
 
 #endif

include/customizer/files.hpp

@@ -106,8 +106,8 @@ inline void writeGraph(const boost::filesystem::path &path,
     writer.WriteFrom("/mld/connectivity_checksum", connectivity_checksum);
     serialization::write(writer, "/mld/multilevelgraph", graph);
 }
-}
+} // namespace files
-}
+} // namespace customizer
-}
+} // namespace osrm
 
 #endif

include/customizer/serialization.hpp

@@ -65,8 +65,8 @@ inline void write(storage::tar::FileWriter &writer,
     storage::serialization::write(writer, name + "/is_backward_edge", graph.is_backward_edge);
     storage::serialization::write(writer, name + "/node_to_edge_offset", graph.node_to_edge_offset);
 }
-}
+} // namespace serialization
-}
+} // namespace customizer
-}
+} // namespace osrm
 
 #endif

include/engine/algorithm.hpp

@@ -16,14 +16,14 @@ namespace ch
 struct Algorithm final
 {
 };
-}
+} // namespace ch
 // Multi-Level Dijkstra
 namespace mld
 {
 struct Algorithm final
 {
 };
-}
+} // namespace mld
 
 // Algorithm names
 template <typename AlgorithmT> const char *name();
@@ -111,8 +111,8 @@ template <> struct HasGetTileTurns<mld::Algorithm> final : std::true_type
 template <> struct HasExcludeFlags<mld::Algorithm> final : std::true_type
 {
 };
-}
+} // namespace routing_algorithms
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/api/base_api.hpp

@@ -128,8 +128,8 @@ class BaseAPI
     const BaseParameters &parameters;
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/base_parameters.hpp

@@ -124,8 +124,8 @@ struct BaseParameters
                            });
     }
 };
-}
+} // namespace api
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // ROUTE_PARAMETERS_HPP

include/engine/api/base_result.hpp

@@ -16,8 +16,8 @@ namespace api
 {
 using ResultT =
     mapbox::util::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/json_factory.hpp

@@ -112,8 +112,8 @@ util::json::Object makeRouteLeg(guidance::RouteLeg leg, util::json::Array steps)
 util::json::Array makeRouteLegs(std::vector<guidance::RouteLeg> legs,
                                 std::vector<util::json::Value> step_geometries,
                                 std::vector<util::json::Object> annotations);
-}
+} // namespace json
-}
+} // namespace api
 } // namespace engine
 } // namespace osrm
 

include/engine/api/match_api.hpp

@@ -248,8 +248,8 @@ class MatchAPI final : public RouteAPI
     const tidy::Result &tidy_result;
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/match_parameters.hpp

@@ -79,8 +79,9 @@ struct MatchParameters : public RouteParameters
                     bool tidy_,
                     std::vector<std::size_t> waypoints_,
                     Args... args_)
-        : RouteParameters{std::forward<Args>(args_)..., waypoints_},
+        : RouteParameters{std::forward<Args>(args_)..., waypoints_}, timestamps{std::move(
-          timestamps{std::move(timestamps_)}, gaps(gaps_), tidy(tidy_)
+                                                                         timestamps_)},
+          gaps(gaps_), tidy(tidy_)
     {
     }
 
@@ -94,8 +95,8 @@ struct MatchParameters : public RouteParameters
                (timestamps.empty() || timestamps.size() == coordinates.size());
     }
 };
-}
+} // namespace api
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/api/match_parameters_tidy.hpp

@@ -200,9 +200,9 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
     return result;
 }
 
-} // ns tidy
+} // namespace tidy
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/nearest_api.hpp

@@ -159,8 +159,8 @@ class NearestAPI final : public BaseAPI
     }
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/nearest_parameters.hpp

@@ -52,8 +52,8 @@ struct NearestParameters : public BaseParameters
 
     bool IsValid() const { return BaseParameters::IsValid() && number_of_results >= 1; }
 };
-}
+} // namespace api
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // ENGINE_API_NEAREST_PARAMETERS_HPP

include/engine/api/route_api.hpp

@@ -988,8 +988,8 @@ class RouteAPI : public BaseAPI
     }
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/route_parameters.hpp

@@ -90,16 +90,10 @@ struct RouteParameters : public BaseParameters
                     Args... args_)
         // Once we perfectly-forward `args` (see #2990) this constructor can delegate to the one
         // below.
-        : BaseParameters{std::forward<Args>(args_)...},
+        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          steps{steps_},
+          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{false},
-          alternatives{alternatives_},
+          annotations_type{AnnotationsType::None}, geometries{geometries_}, overview{overview_},
-          number_of_alternatives{alternatives_ ? 1u : 0u},
+          continue_straight{continue_straight_}, waypoints()
-          annotations{false},
-          annotations_type{AnnotationsType::None},
-          geometries{geometries_},
-          overview{overview_},
-          continue_straight{continue_straight_},
-          waypoints()
     {
     }
 
@@ -151,8 +145,8 @@ struct RouteParameters : public BaseParameters
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
           annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
-          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},
+          geometries{geometries_}, overview{overview_},
-          waypoints{waypoints_}
+          continue_straight{continue_straight_}, waypoints{waypoints_}
     {
     }
 
@@ -217,8 +211,8 @@ inline RouteParameters::AnnotationsType operator|=(RouteParameters::AnnotationsT
 {
     return lhs = lhs | rhs;
 }
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/table_api.hpp

@@ -407,8 +407,8 @@ class TableAPI final : public BaseAPI
     const TableParameters &parameters;
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/table_parameters.hpp

@@ -166,8 +166,8 @@ inline TableParameters::AnnotationsType &operator|=(TableParameters::Annotations
 {
     return lhs = lhs | rhs;
 }
-}
+} // namespace api
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // ENGINE_API_TABLE_PARAMETERS_HPP

include/engine/api/tile_parameters.hpp

@@ -70,8 +70,8 @@ struct TileParameters final
         return valid_x && valid_y && valid_z;
     }
 };
-}
+} // namespace api
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/api/trip_api.hpp

@@ -175,8 +175,8 @@ class TripAPI final : public RouteAPI
     const TripParameters &parameters;
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/trip_parameters.hpp

@@ -65,8 +65,8 @@ struct TripParameters : public RouteParameters
                    DestinationType destination_,
                    bool roundtrip_,
                    Args &&... args_)
-        : RouteParameters{std::forward<Args>(args_)...}, source{source_}, destination{destination_},
+        : RouteParameters{std::forward<Args>(args_)...}, source{source_},
-          roundtrip{roundtrip_}
+          destination{destination_}, roundtrip{roundtrip_}
     {
     }
 
@@ -76,8 +76,8 @@ struct TripParameters : public RouteParameters
 
     bool IsValid() const { return RouteParameters::IsValid(); }
 };
-}
+} // namespace api
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/approach.hpp

@@ -42,5 +42,5 @@ enum class Approach : std::uint8_t
 
 };
 }
-}
+} // namespace osrm
 #endif

include/engine/base64.hpp

@@ -38,7 +38,7 @@ using BinaryFromBase64 = boost::archive::iterators::transform_width<
     8, // get a view of 8 bit
     6  // from a sequence of 6 bit
     >;
-} // ns detail
+} // namespace detail
 namespace engine
 {
 
@@ -135,7 +135,7 @@ template <typename T> T decodeBase64Bytewise(const std::string &encoded)
     return x;
 }
 
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif /* OSRM_BASE64_HPP */

include/engine/bearing.hpp

@@ -46,7 +46,7 @@ inline bool operator==(const Bearing lhs, const Bearing rhs)
     return lhs.bearing == rhs.bearing && lhs.range == rhs.range;
 }
 inline bool operator!=(const Bearing lhs, const Bearing rhs) { return !(lhs == rhs); }
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/data_watchdog.hpp

@@ -142,14 +142,14 @@ class DataWatchdogImpl<AlgorithmT, datafacade::ContiguousInternalMemoryDataFacad
     storage::SharedRegion *updatable_shared_region;
     DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT> facade_factory;
 };
-}
+} // namespace detail
 
 // This class monitors the shared memory region that contains the pointers to
 // the data and layout regions that should be used. This region is updated
 // once a new dataset arrives.
 template <typename AlgorithmT, template <typename A> class FacadeT>
 using DataWatchdog = detail::DataWatchdogImpl<AlgorithmT, FacadeT<AlgorithmT>>;
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/datafacade.hpp

@@ -11,7 +11,7 @@ namespace engine
 using DataFacadeBase = datafacade::ContiguousInternalMemoryDataFacadeBase;
 template <typename AlgorithmT>
 using DataFacade = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/datafacade/algorithm_datafacade.hpp

@@ -99,8 +99,8 @@ template <> class AlgorithmDataFacade<MLD>
     // searches for a specific edge
     virtual EdgeID FindEdge(const NodeID from, const NodeID to) const = 0;
 };
-}
+} // namespace datafacade
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -609,7 +609,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         auto found_range = std::equal_range(
             m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});
 
-        std::for_each(found_range.first, found_range.second, [&](const auto & override) {
+        std::for_each(found_range.first, found_range.second, [&](const auto &override) {
             std::vector<NodeID> sequence(
                 m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_begin,
                 m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_end);
@@ -760,8 +760,8 @@ class ContiguousInternalMemoryDataFacade<MLD> final
     {
     }
 };
-}
+} // namespace datafacade
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // CONTIGUOUS_INTERNALMEM_DATAFACADE_HPP

include/engine/datafacade/datafacade_base.hpp

@@ -223,8 +223,8 @@ class BaseDataFacade
     virtual std::vector<extractor::ManeuverOverride>
     GetOverridesThatStartAt(const NodeID edge_based_node_id) const = 0;
 };
-}
+} // namespace datafacade
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // DATAFACADE_BASE_HPP

include/engine/datafacade_factory.hpp

@@ -152,7 +152,7 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
     std::unordered_map<std::string, extractor::ClassData> name_to_class;
     const extractor::ProfileProperties *properties = nullptr;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/datafacade_provider.hpp

@@ -93,7 +93,7 @@ class WatchingProvider : public DataFacadeProvider<AlgorithmT, FacadeT>
         return watchdog.Get(params);
     }
 };
-}
+} // namespace detail
 
 template <typename AlgorithmT>
 using DataFacadeProvider = detail::DataFacadeProvider<AlgorithmT, DataFacade>;
@@ -103,7 +103,7 @@ template <typename AlgorithmT>
 using ImmutableProvider = detail::ImmutableProvider<AlgorithmT, DataFacade>;
 template <typename AlgorithmT>
 using ExternalProvider = detail::ExternalProvider<AlgorithmT, DataFacade>;
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/douglas_peucker.hpp

@@ -57,7 +57,7 @@ const constexpr std::uint64_t DOUGLAS_PEUCKER_THRESHOLDS[19] = {
 
 const constexpr auto DOUGLAS_PEUCKER_THRESHOLDS_SIZE =
     sizeof(DOUGLAS_PEUCKER_THRESHOLDS) / sizeof(*DOUGLAS_PEUCKER_THRESHOLDS);
-} // ns detail
+} // namespace detail
 
 // These functions compute the bitvector of indicating generalized input
 // points according to the (Ramer-)Douglas-Peucker algorithm.
@@ -75,7 +75,7 @@ inline std::vector<util::Coordinate> douglasPeucker(const std::vector<util::Coor
 {
     return douglasPeucker(begin(geometry), end(geometry), zoom_level);
 }
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* DOUGLAS_PEUCKER_HPP_ */

include/engine/engine.hpp

@@ -130,7 +130,7 @@ template <typename Algorithm> class Engine final : public EngineInterface
     const plugins::MatchPlugin match_plugin;
     const plugins::TilePlugin tile_plugin;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // OSRM_IMPL_HPP

include/engine/engine_config.hpp

@@ -94,7 +94,7 @@ struct EngineConfig final
     std::string verbosity;
     std::string dataset_name;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // SERVER_CONFIG_HPP

include/engine/geospatial_query.hpp

@@ -715,7 +715,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     const CoordinateList &coordinates;
     DataFacadeT &datafacade;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/assemble_geometry.hpp

@@ -167,8 +167,8 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
 
     return geometry;
 }
-}
+} // namespace guidance
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/assemble_leg.hpp

@@ -122,7 +122,7 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
                    [](const NamedSegment &segment) { return segment.name_id; });
     return summary;
 }
-}
+} // namespace detail
 
 inline RouteLeg assembleLeg(const datafacade::BaseDataFacade &facade,
                             const std::vector<PathData> &route_data,

include/engine/guidance/assemble_steps.hpp

@@ -35,7 +35,7 @@ std::pair<short, short> getDepartBearings(const LegGeometry &leg_geometry,
 std::pair<short, short> getArriveBearings(const LegGeometry &leg_geometry,
                                           const PhantomNode &target_node,
                                           const bool traversed_in_reverse);
-} // ns detail
+} // namespace detail
 
 inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &facade,
                                             const std::vector<PathData> &leg_data,

include/engine/guidance/collapse_turns.hpp

@@ -163,7 +163,7 @@ void combineRouteSteps(RouteStep &step_at_turn_location,
 void suppressStep(RouteStep &step_at_turn_location, RouteStep &step_after_turn_location);
 
 } /* namespace guidance */
-} /* namespace osrm */
+} // namespace engine
 } /* namespace osrm */
 
 #endif /* OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP_ */

include/engine/guidance/leg_geometry.hpp

@@ -64,8 +64,8 @@ struct LegGeometry
         return segment_offsets.size() - 1;
     }
 };
-}
+} // namespace guidance
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/route.hpp

@@ -14,8 +14,8 @@ struct Route
     double duration;
     double weight;
 };
-}
+} // namespace guidance
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/route_leg.hpp

@@ -23,8 +23,8 @@ struct RouteLeg
     std::string summary;
     std::vector<RouteStep> steps;
 };
-}
+} // namespace guidance
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/step_maneuver.hpp

@@ -46,5 +46,5 @@ inline StepManeuver getInvalidStepManeuver()
 
 } // namespace guidance
 } // namespace engine
-} // namespace osrmn
+} // namespace osrm
 #endif

include/engine/hint.hpp

@@ -67,7 +67,7 @@ static_assert(sizeof(Hint) == 80 + 4, "Hint is bigger than expected");
 constexpr std::size_t ENCODED_HINT_SIZE = 112;
 static_assert(ENCODED_HINT_SIZE / 4 * 3 >= sizeof(Hint),
               "ENCODED_HINT_SIZE does not match size of Hint");
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/internal_route_result.hpp

@@ -173,7 +173,7 @@ inline InternalRouteResult CollapseInternalRouteResult(const InternalRouteResult
                  collapsed.unpacked_path_segments.size());
     return collapsed;
 }
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // RAW_ROUTE_DATA_H

include/engine/map_matching/bayes_classifier.hpp

@@ -98,8 +98,8 @@ class BayesClassifier
     double positive_apriori_probability;
     double negative_apriori_probability;
 };
-}
+} // namespace map_matching
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // BAYES_CLASSIFIER_HPP

include/engine/map_matching/hidden_markov_model.hpp

@@ -137,8 +137,8 @@ template <class CandidateLists> struct HiddenMarkovModel
         return initial_timestamp;
     }
 };
-}
+} // namespace map_matching
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // HIDDEN_MARKOV_MODEL

include/engine/map_matching/matching_confidence.hpp

@@ -51,8 +51,8 @@ struct MatchingConfidence
   private:
     ClassifierT classifier;
 };
-}
+} // namespace map_matching
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/map_matching/sub_matching.hpp

@@ -19,8 +19,8 @@ struct SubMatching
     std::vector<unsigned> alternatives_count;
     double confidence;
 };
-}
+} // namespace map_matching
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/phantom_node.hpp

@@ -44,14 +44,15 @@ namespace engine
 struct PhantomNode
 {
     PhantomNode()
-        : forward_segment_id{SPECIAL_SEGMENTID, false},
+        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
-          reverse_segment_id{SPECIAL_SEGMENTID, false}, forward_weight(INVALID_EDGE_WEIGHT),
+                                                                           false},
-          reverse_weight(INVALID_EDGE_WEIGHT), forward_weight_offset(0), reverse_weight_offset(0),
+          forward_weight(INVALID_EDGE_WEIGHT), reverse_weight(INVALID_EDGE_WEIGHT),
+          forward_weight_offset(0), reverse_weight_offset(0),
           forward_distance(INVALID_EDGE_DISTANCE), reverse_distance(INVALID_EDGE_DISTANCE),
           forward_distance_offset(0), reverse_distance_offset(0),
           forward_duration(MAXIMAL_EDGE_DURATION), reverse_duration(MAXIMAL_EDGE_DURATION),
-          forward_duration_offset(0), reverse_duration_offset(0), fwd_segment_position(0),
+          forward_duration_offset(0), reverse_duration_offset(0),
-          is_valid_forward_source{false}, is_valid_forward_target{false},
+          fwd_segment_position(0), is_valid_forward_source{false}, is_valid_forward_target{false},
           is_valid_reverse_source{false}, is_valid_reverse_target{false}, bearing(0)
 
     {
@@ -109,8 +110,9 @@ struct PhantomNode
 
     bool IsValid(const unsigned number_of_nodes) const
     {
-        return location.IsValid() && ((forward_segment_id.id < number_of_nodes) ||
+        return location.IsValid() &&
-                                      (reverse_segment_id.id < number_of_nodes)) &&
+               ((forward_segment_id.id < number_of_nodes) ||
+                (reverse_segment_id.id < number_of_nodes)) &&
                ((forward_weight != INVALID_EDGE_WEIGHT) ||
                 (reverse_weight != INVALID_EDGE_WEIGHT)) &&
                ((forward_duration != MAXIMAL_EDGE_DURATION) ||
@@ -234,7 +236,7 @@ struct PhantomNodes
     PhantomNode source_phantom;
     PhantomNode target_phantom;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // PHANTOM_NODES_H

include/engine/plugins/match.hpp

@@ -38,8 +38,8 @@ class MatchPlugin : public BasePlugin
     const int max_locations_map_matching;
     const double max_radius_map_matching;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // MATCH_HPP

include/engine/plugins/nearest.hpp

@@ -26,8 +26,8 @@ class NearestPlugin final : public BasePlugin
   private:
     const int max_results;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* NEAREST_HPP */

include/engine/plugins/plugin_base.hpp

@@ -131,8 +131,10 @@ class BasePlugin
                 return phantom_pair.first;
             };
 
-        const auto use_closed_phantom = [](
+        const auto use_closed_phantom =
-            const std::pair<PhantomNode, PhantomNode> &phantom_pair) { return phantom_pair.first; };
+            [](const std::pair<PhantomNode, PhantomNode> &phantom_pair) {
+                return phantom_pair.first;
+            };
 
         const bool every_phantom_is_in_tiny_cc = std::all_of(std::begin(phantom_node_pair_list),
                                                              std::end(phantom_node_pair_list),
@@ -388,8 +390,8 @@ class BasePlugin
                std::to_string(missing_index);
     }
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* BASE_PLUGIN_HPP */

include/engine/plugins/table.hpp

@@ -27,8 +27,8 @@ class TablePlugin final : public BasePlugin
   private:
     const int max_locations_distance_table;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // TABLE_HPP

include/engine/plugins/tile.hpp

@@ -30,8 +30,8 @@ class TilePlugin final : public BasePlugin
                          const api::TileParameters &parameters,
                          osrm::engine::api::ResultT &pbf_buffer) const;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* TILEPLUGIN_HPP */

include/engine/plugins/trip.hpp

@@ -42,8 +42,8 @@ class TripPlugin final : public BasePlugin
                          const api::TripParameters &parameters,
                          osrm::engine::api::ResultT &json_result) const;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // TRIP_HPP

include/engine/plugins/viaroute.hpp

@@ -35,8 +35,8 @@ class ViaRoutePlugin final : public BasePlugin
                          const api::RouteParameters &route_parameters,
                          osrm::engine::api::ResultT &json_result) const;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // VIA_ROUTE_HPP

include/engine/polyline_compressor.hpp

@@ -17,7 +17,7 @@ namespace detail
 std::string encode(std::vector<int> &numbers);
 std::int32_t decode_polyline_integer(std::string::const_iterator &first,
                                      std::string::const_iterator last);
-}
+} // namespace detail
 using CoordVectorForwardIter = std::vector<util::Coordinate>::const_iterator;
 // Encodes geometry into polyline format.
 // See: https://developers.google.com/maps/documentation/utilities/polylinealgorithm
@@ -80,7 +80,7 @@ std::vector<util::Coordinate> decodePolyline(const std::string &polyline)
     }
     return coordinates;
 }
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* POLYLINECOMPRESSOR_H_ */

include/engine/routing_algorithms.hpp

@@ -230,7 +230,7 @@ inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<Algorithm>::G
     return routing_algorithms::getTileTurns(*facade, edges, sorted_edge_indexes);
 }
 
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/routing_algorithms/shortest_path_impl.hpp

@@ -226,7 +226,7 @@ inline void initializeHeap<mld::Algorithm>(SearchEngineData<mld::Algorithm> &eng
     const auto border_nodes_number = facade.GetMaxBorderNodeID() + 1;
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(nodes_number, border_nodes_number);
 }
-}
+} // namespace
 
 template <typename Algorithm>
 InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,

include/engine/search_engine_data.hpp

@@ -120,7 +120,7 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
     void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                        unsigned number_of_boundary_nodes);
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // SEARCH_ENGINE_DATA_HPP

include/engine/status.hpp

@@ -42,7 +42,7 @@ enum class Status
     Ok,
     Error
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/trip/trip_nearest_neighbour.hpp

@@ -92,8 +92,8 @@ std::vector<NodeID> NearestNeighbourTrip(const NodeIDIterator &start,
     }
     return route;
 }
-}
+} // namespace trip
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // TRIP_NEAREST_NEIGHBOUR_HPP

include/extractor/class_data.hpp

@@ -33,7 +33,7 @@ inline bool isValidClassName(const std::string &name)
                return std::isalnum(c);
            }) == name.end();
 }
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/compressed_edge_container.hpp

@@ -82,7 +82,7 @@ class CompressedEdgeContainer
     std::unordered_map<EdgeID, unsigned> m_reverse_edge_id_to_zipped_index_map;
     std::unique_ptr<SegmentDataContainer> segment_data;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // GEOMETRY_COMPRESSOR_HPP_

include/extractor/compressed_node_based_graph_edge.hpp

@@ -14,7 +14,7 @@ struct CompressedNodeBasedGraphEdge
     NodeID source;
     NodeID target;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // OSRM_EXTRACTOR_COMPRESSED_NODE_BASED_GRAPH_EDGE_HPP

include/extractor/datasources.hpp

@@ -42,7 +42,7 @@ class Datasources
     std::array<std::uint32_t, MAX_NUM_SOURES> lengths;
     std::array<char, MAX_LENGTH_NAME * MAX_NUM_SOURES> sources;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/edge_based_edge.hpp

@@ -96,7 +96,7 @@ inline bool EdgeBasedEdge::operator<(const EdgeBasedEdge &other) const
     return std::tie(source, target, data.weight, unidirectional) <
            std::tie(other.source, other.target, other.data.weight, other_is_unidirectional);
 }
-} // ns extractor
+} // namespace extractor
-} // ns osrm
+} // namespace osrm
 
 #endif /* EDGE_BASED_EDGE_HPP */

include/extractor/edge_based_graph_factory.hpp

@@ -54,7 +54,7 @@ struct TurnIndexBlock
 #pragma pack(pop)
 static_assert(std::is_trivial<TurnIndexBlock>::value, "TurnIndexBlock is not trivial");
 static_assert(sizeof(TurnIndexBlock) == 12, "TurnIndexBlock is not packed correctly");
-} // ns lookup
+} // namespace lookup
 
 struct NodeBasedGraphToEdgeBasedGraphMappingWriter; // fwd. decl
 

include/extractor/edge_based_node_segment.hpp

@@ -20,8 +20,9 @@ namespace extractor
 struct EdgeBasedNodeSegment
 {
     EdgeBasedNodeSegment()
-        : forward_segment_id{SPECIAL_SEGMENTID, false},
+        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
-          reverse_segment_id{SPECIAL_SEGMENTID, false}, u(SPECIAL_NODEID), v(SPECIAL_NODEID),
+                                                                           false},
+          u(SPECIAL_NODEID), v(SPECIAL_NODEID),
           fwd_segment_position(std::numeric_limits<unsigned short>::max() >>
                                1), // >> 1 because we've only got 15 bits
           is_startpoint(false)
@@ -47,7 +48,7 @@ struct EdgeBasedNodeSegment
     unsigned short fwd_segment_position : 15; // segment id in a compressed geometry
     bool is_startpoint : 1;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // OSRM_EXTRACT_EDGE_BASED_NODE_SEGMENT_HPP

include/extractor/extraction_containers.hpp

@@ -73,7 +73,7 @@ class ExtractionContainers
                      const std::string &osrm_path,
                      const std::string &names_data_path);
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif /* EXTRACTION_CONTAINERS_HPP */

include/extractor/extraction_helper_functions.hpp

@@ -82,7 +82,7 @@ template <typename Iterator> struct iso_8601_grammar : qi::grammar<Iterator, uns
     qi::uint_parser<unsigned, 10, 1, 2> uint_p;
     qi::uint_parser<unsigned, 10, 2, 2> uint2_p;
 };
-}
+} // namespace detail
 
 inline bool durationIsValid(const std::string &s)
 {
@@ -136,7 +136,7 @@ inline std::string canonicalizeStringList(std::string strlist, const std::string
     return strlist;
 }
 
-} // extractor
+} // namespace extractor
-} // osrm
+} // namespace osrm
 
 #endif // EXTRACTION_HELPER_FUNCTIONS_HPP

include/extractor/extraction_node.hpp

@@ -13,7 +13,7 @@ struct ExtractionNode
     bool traffic_lights;
     bool barrier;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // EXTRACTION_NODE_HPP

include/extractor/extraction_segment.hpp

@@ -26,7 +26,7 @@ struct ExtractionSegment
     double weight;
     double duration;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/extraction_turn.hpp

@@ -130,7 +130,7 @@ struct ExtractionTurn
     double weight;
     double duration;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/extraction_way.hpp

@@ -26,7 +26,7 @@ inline void maybeSetString(std::string &str, const char *value)
         str = std::string(value);
     }
 }
-}
+} // namespace detail
 
 /**
  * This struct is the direct result of the call to ```way_function```
@@ -130,7 +130,7 @@ struct ExtractionWay
     std::uint8_t highway_turn_classification : 4;
     std::uint8_t access_turn_classification : 4;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // EXTRACTION_WAY_HPP

include/extractor/extractor.hpp

@@ -115,7 +115,7 @@ class Extractor
         LaneDescriptionMap lane_description_map,
         ScriptingEnvironment &scripting_environment);
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif /* EXTRACTOR_HPP */

include/extractor/extractor_callbacks.hpp

@@ -16,15 +16,15 @@ namespace osmium
 class Node;
 class Way;
 class Relation;
-}
+} // namespace osmium
 
 namespace std
 {
 template <> struct hash<std::tuple<std::string, std::string, std::string, std::string, std::string>>
 {
     std::size_t operator()(
-        const std::tuple<std::string, std::string, std::string, std::string, std::string> &mk) const
+        const std::tuple<std::string, std::string, std::string, std::string, std::string> &mk)
-        noexcept
+        const noexcept
     {
         std::size_t seed = 0;
         boost::hash_combine(seed, std::get<0>(mk));
@@ -35,7 +35,7 @@ template <> struct hash<std::tuple<std::string, std::string, std::string, std::s
         return seed;
     }
 };
-}
+} // namespace std
 
 namespace osrm
 {
@@ -93,9 +93,9 @@ class ExtractorCallbacks
     void ProcessWay(const osmium::Way &current_way, const ExtractionWay &result_way);
 
     // warning: caller needs to take care of synchronization!
-    void ProcessManeuverOverride(const InputManeuverOverride & override);
+    void ProcessManeuverOverride(const InputManeuverOverride &override);
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif /* EXTRACTOR_CALLBACKS_HPP */

include/extractor/extractor_config.hpp

@@ -42,36 +42,35 @@ namespace extractor
 
 struct ExtractorConfig final : storage::IOConfig
 {
-    ExtractorConfig() noexcept : IOConfig(
+    ExtractorConfig() noexcept
-                                     {
+        : IOConfig(
-                                         "",
+              {
-                                     },
+                  "",
-                                     {},
+              },
-                                     {".osrm",
+              {},
-                                      ".osrm.restrictions",
+              {".osrm",
-                                      ".osrm.names",
+               ".osrm.restrictions",
-                                      ".osrm.tls",
+               ".osrm.names",
-                                      ".osrm.tld",
+               ".osrm.tls",
-                                      ".osrm.geometry",
+               ".osrm.tld",
-                                      ".osrm.nbg_nodes",
+               ".osrm.geometry",
-                                      ".osrm.ebg_nodes",
+               ".osrm.nbg_nodes",
-                                      ".osrm.timestamp",
+               ".osrm.ebg_nodes",
-                                      ".osrm.edges",
+               ".osrm.timestamp",
-                                      ".osrm.ebg",
+               ".osrm.edges",
-                                      ".osrm.ramIndex",
+               ".osrm.ebg",
-                                      ".osrm.fileIndex",
+               ".osrm.ramIndex",
-                                      ".osrm.turn_duration_penalties",
+               ".osrm.fileIndex",
-                                      ".osrm.turn_weight_penalties",
+               ".osrm.turn_duration_penalties",
-                                      ".osrm.turn_penalties_index",
+               ".osrm.turn_weight_penalties",
-                                      ".osrm.enw",
+               ".osrm.turn_penalties_index",
-                                      ".osrm.properties",
+               ".osrm.enw",
-                                      ".osrm.icd",
+               ".osrm.properties",
-                                      ".osrm.cnbg",
+               ".osrm.icd",
-                                      ".osrm.cnbg_to_ebg",
+               ".osrm.cnbg",
-                                      ".osrm.maneuver_overrides"}),
+               ".osrm.cnbg_to_ebg",
-                                 requested_num_threads(0),
+               ".osrm.maneuver_overrides"}),
-                                 parse_conditionals(false),
+          requested_num_threads(0), parse_conditionals(false), use_locations_cache(true)
-                                 use_locations_cache(true)
     {
     }
 
@@ -94,7 +93,7 @@ struct ExtractorConfig final : storage::IOConfig
     bool parse_conditionals;
     bool use_locations_cache;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // EXTRACTOR_CONFIG_HPP

include/extractor/files.hpp

@@ -586,8 +586,8 @@ void readCompressedNodeBasedGraph(const boost::filesystem::path &path, EdgeListT
 
     storage::serialization::read(reader, "/extractor/cnbg", edge_list);
 }
-}
+} // namespace files
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/first_and_last_segment_of_way.hpp

@@ -53,7 +53,7 @@ struct FirstAndLastSegmentOfWayCompare
     value_type max_value() { return FirstAndLastSegmentOfWay::max_value(); }
     value_type min_value() { return FirstAndLastSegmentOfWay::min_value(); }
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif /* FIRST_AND_LAST_SEGMENT_OF_WAY_HPP */

include/extractor/geojson_debug_policies.hpp

@@ -53,11 +53,11 @@ IntersectionPrinter<IntersectionType>::IntersectionPrinter(
 }
 
 template <typename IntersectionType>
-util::json::Array IntersectionPrinter<IntersectionType>::
+util::json::Array IntersectionPrinter<IntersectionType>::operator()(
-operator()(const NodeID intersection_node,
+    const NodeID intersection_node,
-           const IntersectionType &intersection,
+    const IntersectionType &intersection,
-           const boost::optional<util::json::Object> &node_style,
+    const boost::optional<util::json::Object> &node_style,
-           const boost::optional<util::json::Object> &way_style) const
+    const boost::optional<util::json::Object> &way_style) const
 {
     // request the number of lanes. This process needs to be in sync with what happens over at
     // intersection analysis

include/extractor/graph_compressor.hpp

@@ -39,7 +39,7 @@ class GraphCompressor
                          unsigned original_number_of_edges,
                          const util::NodeBasedDynamicGraph &graph) const;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/internal_extractor_edge.hpp

@@ -49,7 +49,7 @@ struct ByEdgeOrByMeterValue
     using value_type = float;
     value_type value;
 };
-}
+} // namespace detail
 
 struct InternalExtractorEdge
 {
@@ -86,7 +86,7 @@ struct InternalExtractorEdge
     // coordinate of the source node
     util::Coordinate source_coordinate;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // INTERNAL_EXTRACTOR_EDGE_HPP

include/extractor/intersection/intersection_analysis.hpp

@@ -79,8 +79,8 @@ IntersectionView getConnectedRoads(const util::NodeBasedDynamicGraph &graph,
 // for getConnectedRoads.
 IntersectionEdge skipDegreeTwoNodes(const util::NodeBasedDynamicGraph &graph,
                                     IntersectionEdge road);
-}
+} // namespace intersection
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/intersection/intersection_edge.hpp

@@ -42,8 +42,8 @@ struct IntersectionEdgeGeometry
 };
 
 using IntersectionEdgeGeometries = std::vector<IntersectionEdgeGeometry>;
-}
+} // namespace intersection
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/intersection_bearings_container.hpp

@@ -30,7 +30,7 @@ template <storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
            const detail::IntersectionBearingsContainer<Ownership> &turn_data);
-}
+} // namespace serialization
 
 namespace detail
 {
@@ -99,12 +99,12 @@ template <storage::Ownership Ownership> class IntersectionBearingsContainer
     Vector<BearingClassID> node_to_class_id;
     RangeTable<16> class_id_to_ranges_table;
 };
-}
+} // namespace detail
 
 using IntersectionBearingsContainer =
     detail::IntersectionBearingsContainer<storage::Ownership::Container>;
 using IntersectionBearingsView = detail::IntersectionBearingsContainer<storage::Ownership::View>;
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif