Fix formatting

include/util/bearing.hpp

@@ -142,6 +142,6 @@ inline double restrictAngleToValidRange(const double angle)
         return angle;
 }
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // BEARING_HPP

include/util/bit_range.hpp

@@ -90,6 +90,6 @@ template <typename T> auto makeBitRange(const T value)
 {
     return boost::make_iterator_range(BitIterator<T>{value}, BitIterator<T>{});
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/concurrent_id_map.hpp

@@ -72,6 +72,6 @@ struct ConcurrentIDMap
     }
 };
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // CONCURRENT_ID_MAP_HPP

include/util/conditional_restrictions.hpp

@@ -19,6 +19,6 @@ struct ConditionalRestriction
 
 std::vector<ConditionalRestriction> ParseConditionalRestrictions(const std::string &str);
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // OSRM_CONDITIONAL_RESTRICTIONS_HPP

include/util/connectivity_checksum.hpp

@@ -82,6 +82,6 @@ struct ConnectivityChecksum
     std::size_t byte_number;
     unsigned char bit_number;
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/coordinate_calculation.hpp

@@ -373,6 +373,6 @@ bool areParallel(const iterator_type lhs_begin,
 
 double computeArea(const std::vector<Coordinate> &polygon);
 
-} // namespace osrm
+} // namespace osrm::util::coordinate_calculation
 
 #endif // COORDINATE_CALCULATION

include/util/deallocating_vector.hpp

@@ -346,6 +346,6 @@ template <typename T> void swap(DeallocatingVector<T> &lhs, DeallocatingVector<T
 {
     lhs.swap(rhs);
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* DEALLOCATING_VECTOR_HPP */

include/util/debug.hpp

@@ -60,7 +60,7 @@ inline std::ostream &operator<<(std::ostream &out, const RouteStep &step)
 
     return out;
 }
-} // namespace engine
+} // namespace engine::guidance
 
 namespace guidance
 {

include/util/dist_table_wrapper.hpp

@@ -75,6 +75,6 @@ template <typename T> class DistTableWrapper
     std::vector<T> table_;
     const std::size_t number_of_nodes_;
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // DIST_TABLE_WRAPPER_H

include/util/dynamic_graph.hpp

@@ -466,6 +466,6 @@ template <typename EdgeDataT> class DynamicGraph
     std::vector<Node> node_array;
     DeallocatingVector<Edge> edge_list;
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // DYNAMICGRAPH_HPP

include/util/exception.hpp

@@ -122,6 +122,6 @@ class RuntimeError : public exception
         return result;
     }
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* OSRM_EXCEPTION_HPP */

include/util/exclude_flag.hpp

@@ -27,6 +27,6 @@ excludeFlagsToNodeFilter(const NodeID number_of_nodes,
     }
     return filters;
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/filtered_graph.hpp

@@ -157,6 +157,6 @@ template <typename GraphT>
 using FilteredGraphContainer = detail::FilteredGraphImpl<GraphT, storage::Ownership::Container>;
 template <typename GraphT>
 using FilteredGraphView = detail::FilteredGraphImpl<GraphT, storage::Ownership::View>;
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/filtered_integer_range.hpp

@@ -92,6 +92,6 @@ filtered_range<Integer, Filter> filtered_irange(
 {
     return filtered_range<Integer, Filter>(first, last, filter);
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // INTEGER_RANGE_HPP

include/util/fingerprint.hpp

@@ -34,6 +34,6 @@ struct FingerPrint
 static_assert(sizeof(FingerPrint) == 8, "FingerPrint has unexpected size");
 static_assert(std::is_trivial<FingerPrint>::value, "FingerPrint needs to be trivial.");
 static_assert(std::is_pod<FingerPrint>::value, "FingerPrint needs to be a POD.");
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* FingerPrint_H */

include/util/for_each_indexed.hpp

@@ -23,6 +23,6 @@ void for_each_indexed(ContainerT &container, Function function)
     for_each_indexed(std::begin(container), std::end(container), function);
 }
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* FOR_EACH_INDEXED_HPP */

include/util/for_each_pair.hpp

@@ -37,6 +37,6 @@ void for_each_pair(ContainerT &container, Function &&function)
     for_each_pair(begin(container), end(container), std::forward<Function>(function));
 }
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* FOR_EACH_PAIR_HPP */

include/util/for_each_range.hpp

@@ -18,6 +18,6 @@ template <typename Iter, typename Func> void for_each_range(Iter begin, Iter end
         f(begin_range, iter);
     }
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/geojson_debug_logger.hpp

@@ -181,6 +181,6 @@ std::ofstream GeojsonLogger<geojson_conversion_policy, scenario>::ofs;
 template <class geojson_conversion_policy, LoggingScenario scenario>
 geojson_conversion_policy *GeojsonLogger<geojson_conversion_policy, scenario>::policy;
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* OSRM_GEOJSON_DEBUG_LOGGER_HPP */

include/util/geojson_debug_policies.hpp

@@ -50,6 +50,6 @@ struct CoordinateVectorToMultiPoint
                                   const boost::optional<json::Object> &properties = {}) const;
 };
 
-} /* namespace osrm */
+} // namespace osrm::util
 
 #endif /* OSRM_GEOJSON_DEBUG_POLICIES */

include/util/geojson_debug_policy_toolkit.hpp

@@ -107,6 +107,6 @@ inline util::json::Array makeJsonArray(const std::vector<util::Coordinate> &inpu
                    CoordinateToJsonArray());
     return coordinates;
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* OSRM_GEOJSON_DEBUG_POLICY_TOOLKIT_HPP */

include/util/geojson_validation.hpp

@@ -83,5 +83,5 @@ inline void validateFeature(const rapidjson::Value &feature)
         }
     }
 }
-} // namespace osrm
+} // namespace osrm::util
 #endif // OSRM_GEOJSON_VALIDATION_HPP

include/util/graph_traits.hpp

@@ -44,6 +44,6 @@ struct HasFirstEdgeMember<T, decltype((void)(sizeof(std::declval<T>().first_edge
 {
 };
 
-} // namespace osrm
+} // namespace osrm::util::traits
 
 #endif // STATIC_GRAPH_TRAITS_HPP

include/util/graph_utils.hpp

@@ -94,6 +94,6 @@ std::vector<OutputEdgeT> directedEdgesFromCompressed(const std::vector<InputEdge
 
     return output_edge_list;
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/group_by.hpp

@@ -32,6 +32,6 @@ Fn group_by(Iter first, Iter last, Pred pred, Fn fn)
     return fn;
 }
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/guidance/bearing_class.hpp

@@ -13,7 +13,7 @@
 namespace osrm::util::guidance
 {
 class BearingClass;
-} // namespace osrm
+} // namespace osrm::util::guidance
 
 namespace std
 {
@@ -54,7 +54,7 @@ class BearingClass
     friend std::size_t std::hash<BearingClass>::operator()(const BearingClass &) const;
 };
 
-} // namespace osrm
+} // namespace osrm::util::guidance
 
 // make Bearing Class hasbable
 namespace std

include/util/guidance/entry_class.hpp

@@ -11,7 +11,7 @@
 namespace osrm::util::guidance
 {
 class EntryClass;
-} // namespace osrm
+} // namespace osrm::util::guidance
 
 namespace std
 {
@@ -63,7 +63,7 @@ static_assert(std::is_trivially_copyable<EntryClass>::value,
               "requires trivially copyable type");
 #endif
 
-} // namespace util
+} // namespace util::guidance
 
 constexpr const util::guidance::EntryClass EMPTY_ENTRY_CLASS{};
 } // namespace osrm

include/util/guidance/name_announcements.hpp

@@ -236,6 +236,6 @@ inline bool requiresNameAnnounced(const NameID from_name_id,
                                      suffix_table);
 }
 
-} // namespace osrm
+} // namespace osrm::util::guidance
 
 #endif /* OSRM_UTIL_GUIDANCE_NAME_ANNOUNCEMENT_HPP_ */

include/util/guidance/turn_lanes.hpp

@@ -16,7 +16,7 @@ namespace osrm::util::guidance
 {
 class LaneTuple;
 class LaneTupleIdPair;
-} // namespace osrm
+} // namespace osrm::util::guidance
 
 namespace std
 {
@@ -90,6 +90,6 @@ class LaneTupleIdPair
 
 using LaneDataIdMap = ConcurrentIDMap<LaneTupleIdPair, LaneDataID, boost::hash<LaneTupleIdPair>>;
 
-} // namespace osrm
+} // namespace osrm::util::guidance
 
 #endif /* OSRM_UTIL_GUIDANCE_TURN_LANES_HPP */

include/util/hilbert_value.hpp

@@ -67,6 +67,6 @@ inline std::uint64_t GetHilbertCode(const Coordinate &coordinate)
                             static_cast<std::int32_t>(90 * COORDINATE_PRECISION);
     return HilbertToLinear(x, y);
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* HILBERT_VALUE_HPP */

include/util/indexed_data.hpp

@@ -387,5 +387,5 @@ template <typename GroupBlockPolicy>
 using IndexedData = detail::IndexedDataImpl<GroupBlockPolicy, storage::Ownership::Container>;
 template <typename GroupBlockPolicy>
 using IndexedDataView = detail::IndexedDataImpl<GroupBlockPolicy, storage::Ownership::View>;
-} // namespace osrm
+} // namespace osrm::util
 #endif // OSRM_INDEXED_DATA_HPP

include/util/integer_range.hpp

@@ -87,6 +87,6 @@ irange(const Integer first,
 {
     return range<Integer>(first, last);
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // INTEGER_RANGE_HPP

include/util/isatty.hpp

@@ -24,6 +24,6 @@ namespace osrm::util
 //   output is redirected to a logfile
 inline bool IsStdoutATTY() { return isatty(fileno(stdout)); }
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/json_container.hpp

@@ -124,6 +124,6 @@ struct Array
     std::vector<Value> values;
 };
 
-} // namespace osrm
+} // namespace osrm::util::json
 
 #endif // JSON_CONTAINER_HPP

include/util/json_deep_compare.hpp

@@ -154,6 +154,6 @@ inline bool compare(const Value &reference, const Value &result, std::string &re
     return mapbox::util::apply_visitor(
         Comparator(reason, "reference", "result"), reference, result);
 }
-} // namespace osrm
+} // namespace osrm::util::json
 
 #endif

include/util/json_renderer.hpp

@@ -161,6 +161,6 @@ inline void render(std::vector<char> &out, const Object &object)
     renderer(object);
 }
 
-} // namespace osrm
+} // namespace osrm::util::json
 
 #endif // JSON_RENDERER_HPP

include/util/json_util.hpp

@@ -22,6 +22,6 @@ template <typename T> T clamp_float(T d)
 
     return d;
 }
-} // namespace osrm
+} // namespace osrm::util::json
 
 #endif // JSON_UTIL_HPP

include/util/log.hpp

@@ -102,6 +102,6 @@ class UnbufferedLog : public Log
   public:
     UnbufferedLog(LogLevel level_ = logINFO);
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* LOG_HPP */

include/util/lua_util.hpp

@@ -26,6 +26,6 @@ inline void luaAddScriptFolderToLoadPath(lua_State *lua_state, const char *file_
     const std::string lua_code = "package.path = \"" + folder + "/?.lua;\" .. package.path";
     luaL_dostring(lua_state, lua_code.c_str());
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // LUA_UTIL_HPP

include/util/matrix_graph_wrapper.hpp

@@ -44,6 +44,6 @@ template <typename T> class MatrixGraphWrapper
     const std::vector<T> table_;
     const std::size_t number_of_nodes_;
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // MATRIX_GRAPH_WRAPPER_H

include/util/meminfo.hpp

@@ -26,6 +26,6 @@ inline void DumpMemoryStats()
     util::Log() << "RAM: peak bytes used: <not implemented on Windows>";
 #endif // _WIN32
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/mmap_file.hpp

@@ -81,6 +81,6 @@ util::vector_view<T> mmapFile(const boost::filesystem::path &file,
 {
     return detail::mmapFile<T>(file, mmap_container, size);
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/mmap_tar.hpp

@@ -36,6 +36,6 @@ inline DataMap mmapTarFile(const boost::filesystem::path &path,
 
     return map;
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/msb.hpp

@@ -45,6 +45,6 @@ inline std::size_t msb(unsigned int v)
     return MSB_INDEX - __builtin_clz(v);
 }
 #endif
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/node_based_graph.hpp

@@ -95,6 +95,6 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
 
     return NodeBasedDynamicGraph(number_of_nodes, edges_list);
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // NODE_BASED_GRAPH_HPP

include/util/opening_hours.hpp

@@ -221,6 +221,6 @@ std::vector<OpeningHours> ParseOpeningHours(const std::string &str);
 
 bool CheckOpeningHours(const std::vector<OpeningHours> &input, const struct tm &time);
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // OSRM_OPENING_HOURS_HPP

include/util/packed_vector.hpp

@@ -599,6 +599,6 @@ template <typename T, std::size_t Bits>
 using PackedVector = detail::PackedVector<T, Bits, storage::Ownership::Container>;
 template <typename T, std::size_t Bits>
 using PackedVectorView = detail::PackedVector<T, Bits, storage::Ownership::View>;
-} // namespace osrm
+} // namespace osrm::util
 
 #endif /* PACKED_VECTOR_HPP */

include/util/percent.hpp

@@ -85,6 +85,6 @@ class Percent
         }
     }
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // PERCENT_HPP

include/util/permutation.hpp

@@ -65,6 +65,6 @@ std::vector<IndexT> orderingToPermutation(const std::vector<IndexT> &ordering)
 
     return permutation;
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/query_heap.hpp

@@ -370,6 +370,6 @@ class QueryHeap
     HeapContainer heap;
     IndexStorage node_index;
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // OSRM_UTIL_QUERY_HEAP_HPP

include/util/range_table.hpp

@@ -213,6 +213,6 @@ unsigned RangeTable<BLOCK_SIZE, Ownership>::PrefixSumAtIndex(int index, const Bl
 
     return sum;
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // RANGE_TABLE_HPP

include/util/rectangle.hpp

@@ -169,6 +169,6 @@ struct RectangleInt2D
                max_lat != FixedLatitude{std::numeric_limits<std::int32_t>::min()};
     }
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/serialization.hpp

@@ -139,6 +139,6 @@ void write(storage::tar::FileWriter &writer,
     storage::serialization::write(
         writer, name + "/search_tree_level_starts", rtree.m_tree_level_starts);
 }
-} // namespace osrm
+} // namespace osrm::util::serialization
 
 #endif

include/util/static_assert.hpp

@@ -18,6 +18,6 @@ template <typename It, typename Category> inline void static_assert_iter_categor
     static_assert(std::is_base_of<Category, IterCategoryType>::value, "");
 }
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // OSRM_STATIC_ASSERT_HPP

include/util/static_graph.hpp

@@ -318,6 +318,6 @@ class StaticGraph
     Vector<EdgeArrayEntry> edge_array;
 };
 
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // STATIC_GRAPH_HPP

include/util/static_rtree.hpp

@@ -772,6 +772,6 @@ class StaticRTree
 //[2] "Nearest Neighbor Queries", N. Roussopulos et al; 1995; DOI: 10.1145/223784.223794
 //[3] "Distance Browsing in Spatial Databases"; G. Hjaltason, H. Samet; 1999; ACM Trans. DB Sys
 // Vol.24 No.2, pp.265-318
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // STATIC_RTREE_HPP

include/util/string_util.hpp

@@ -141,6 +141,6 @@ inline std::size_t URIDecode(const std::string &input, std::string &output)
 }
 
 inline std::size_t URIDecodeInPlace(std::string &URI) { return URIDecode(URI, URI); }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // STRING_UTIL_HPP

include/util/timed_histogram.hpp

@@ -86,6 +86,6 @@ template <std::size_t TimeBinSize = 1000, std::size_t IndexBinSize = 1000> class
     std::vector<std::uint32_t> frame_offsets;
     std::vector<std::uint32_t> frame_counters;
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/timezones.hpp

@@ -42,6 +42,6 @@ class Timezoner
     rtree_t rtree;
     std::vector<local_time_t> local_times;
 };
-} // namespace osrm
+} // namespace osrm::updater
 
 #endif

include/util/timing_util.hpp

@@ -21,6 +21,6 @@ namespace osrm::util
      std::chrono::duration_cast<std::chrono::microseconds>(_X##_stop - _X##_start).count())
 #define TIMER_MIN(_X)                                                                              \
     std::chrono::duration_cast<std::chrono::minutes>(_X##_stop - _X##_start).count()
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // TIMING_UTIL_HPP

include/util/to_osm_link.hpp

@@ -23,6 +23,6 @@ inline std::string toOSMLink(const util::Coordinate &c)
          << toFloating(c.lat) << "&mlon=" << toFloating(c.lon);
     return link.str();
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif

include/util/trigonometry_table.hpp

@@ -429,6 +429,6 @@ inline double atan2_lookup(double y, double x)
     }
     return angle;
 }
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // TRIGONOMETRY_TABLE_HPP

include/util/vector_tile.hpp

@@ -8,5 +8,5 @@ namespace osrm::util::vector_tile
 // Vector tiles are 4096 virtual pixels on each side
 const constexpr double EXTENT = 4096.0;
 const constexpr double BUFFER = 128.0;
-} // namespace osrm
+} // namespace osrm::util::vector_tile
 #endif

include/util/vector_view.hpp

@@ -265,6 +265,6 @@ struct is_view_or_vector
                                  std::is_same<util::vector_view<ValueT>, VectorT>::value>
 {
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // SHARED_MEMORY_VECTOR_WRAPPER_HPP

include/util/viewport.hpp

@@ -40,6 +40,6 @@ inline unsigned getFittedZoom(util::Coordinate south_west, util::Coordinate nort
     else
         return detail::MIN_ZOOM;
 }
-} // namespace osrm
+} // namespace osrm::util::viewport
 
 #endif

include/util/web_mercator.hpp

@@ -165,6 +165,6 @@ inline void xyzToMercator(
     maxx = static_cast<double>(clamp(util::FloatLongitude{maxx})) * DEGREE_TO_PX;
     maxy = latToY(util::FloatLatitude{maxy}) * DEGREE_TO_PX;
 }
-} // namespace osrm
+} // namespace osrm::util::web_mercator
 
 #endif

include/util/xor_fast_hash.hpp

@@ -63,6 +63,6 @@ template <std::size_t MaxNumElements = (1u << 16u)> class XORFastHash
         return table1[lsb] ^ table2[msb];
     }
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // XOR_FAST_HASH_HPP

include/util/xor_fast_hash_storage.hpp

@@ -76,6 +76,6 @@ class XORFastHashStorage
     XORFastHash<MaxNumElements> fast_hasher;
     unsigned current_timestamp;
 };
-} // namespace osrm
+} // namespace osrm::util
 
 #endif // XOR_FAST_HASH_STORAGE_HPP