Fix formatting

Author: deniskoronchik

include/extractor/extraction_relation.hpp

@@ -20,45 +20,34 @@ struct ExtractionRelation
 {
     class OsmIDTyped
     {
-    public:
-        OsmIDTyped(osmium::object_id_type _id, osmium::item_type _type)
-            : id(_id), type(_type)
-        {
-        }
+      public:
+        OsmIDTyped(osmium::object_id_type _id, osmium::item_type _type) : id(_id), type(_type) {}
 
         std::uint64_t GetID() const { return std::uint64_t(id); }
         osmium::item_type GetType() const { return type; }
 
-        std::uint64_t Hash() const
-        {
-            return id ^ (static_cast<std::uint64_t>(type) << 56);
-        }
+        std::uint64_t Hash() const { return id ^ (static_cast<std::uint64_t>(type) << 56); }
 
-    private:
+      private:
         osmium::object_id_type id;
         osmium::item_type type;
     };
 
     using AttributesList = std::vector<std::pair<std::string, std::string>>;
     using MembersRolesList = std::vector<std::pair<std::uint64_t, std::string>>;
 
-    explicit ExtractionRelation(const OsmIDTyped & _id)
-        : id(_id)
-    {
-    }
+    explicit ExtractionRelation(const OsmIDTyped &_id) : id(_id) {}
 
     void Clear()
     {
         attributes.clear();
         members_role.clear();
     }
 
-    const char * GetAttr(const std::string & attr) const
+    const char *GetAttr(const std::string &attr) const
     {
         auto it = std::lower_bound(
-                    attributes.begin(),
-                    attributes.end(),
-                    std::make_pair(attr, std::string()));
+            attributes.begin(), attributes.end(), std::make_pair(attr, std::string()));
 
         if (it != attributes.end() && (*it).first == attr)
             return (*it).second.c_str();
@@ -72,18 +61,16 @@ struct ExtractionRelation
         std::sort(members_role.begin(), members_role.end());
     }
 
-    void AddMember(const OsmIDTyped & member_id, const char * role)
+    void AddMember(const OsmIDTyped &member_id, const char *role)
     {
         members_role.emplace_back(std::make_pair(member_id.Hash(), std::string(role)));
     }
 
-    const char * GetRole(const OsmIDTyped & member_id) const
+    const char *GetRole(const OsmIDTyped &member_id) const
     {
         const auto hash = member_id.Hash();
         auto it = std::lower_bound(
-                    members_role.begin(),
-                    members_role.end(),
-                    std::make_pair(hash, std::string()));
+            members_role.begin(), members_role.end(), std::make_pair(hash, std::string()));
 
         if (it != members_role.end() && (*it).first == hash)
             return (*it).second.c_str();
@@ -106,15 +93,15 @@ class ExtractionRelationContainer
     using RelationIDList = std::vector<ExtractionRelation::OsmIDTyped>;
     using RelationRefMap = std::unordered_map<std::uint64_t, RelationIDList>;
 
-    void AddRelation(ExtractionRelation && rel)
+    void AddRelation(ExtractionRelation &&rel)
     {
         rel.Prepare();
 
         BOOST_ASSERT(relations_data.find(rel.id.GetID()) == relations_data.end());
         relations_data.insert(std::make_pair(rel.id.GetID(), std::move(rel)));
     }
 
-    void AddRelationMember(const OsmIDTyped & relation_id, const OsmIDTyped & member_id)
+    void AddRelationMember(const OsmIDTyped &relation_id, const OsmIDTyped &member_id)
     {
         switch (member_id.GetType())
         {
@@ -135,7 +122,7 @@ class ExtractionRelationContainer
         };
     }
 
-    void Merge(ExtractionRelationContainer && other)
+    void Merge(ExtractionRelationContainer &&other)
     {
         for (auto it : other.relations_data)
         {
@@ -144,11 +131,10 @@ class ExtractionRelationContainer
             (void)res; // prevent unused warning in release
         }
 
-        auto MergeRefMap = [&](RelationRefMap & source, RelationRefMap & target)
-        {
+        auto MergeRefMap = [&](RelationRefMap &source, RelationRefMap &target) {
             for (auto it : source)
             {
-                auto & v = target[it.first];
+                auto &v = target[it.first];
                 v.insert(v.end(), it.second.begin(), it.second.end());
             }
         };
@@ -158,15 +144,12 @@ class ExtractionRelationContainer
         MergeRefMap(other.rel_refs, rel_refs);
     }
 
-    std::size_t GetRelationsNum() const
-    {
-        return relations_data.size();
-    }
+    std::size_t GetRelationsNum() const { return relations_data.size(); }
 
-    const RelationIDList & GetRelations(const OsmIDTyped & member_id) const
+    const RelationIDList &GetRelations(const OsmIDTyped &member_id) const
     {
-        auto getFromMap = [this](std::uint64_t id, const RelationRefMap & map) -> const RelationIDList &
-        {
+        auto getFromMap = [this](std::uint64_t id,
+                                 const RelationRefMap &map) -> const RelationIDList & {
             auto it = map.find(id);
             if (it != map.end())
                 return it->second;
@@ -192,11 +175,12 @@ class ExtractionRelationContainer
         return empty_rel_list;
     }
 
-    const ExtractionRelation & GetRelationData(const ExtractionRelation::OsmIDTyped & rel_id) const
+    const ExtractionRelation &GetRelationData(const ExtractionRelation::OsmIDTyped &rel_id) const
     {
         auto it = relations_data.find(rel_id.GetID());
         if (it == relations_data.end())
-            throw osrm::util::exception("Can't find relation data for " + std::to_string(rel_id.GetID()));
+            throw osrm::util::exception("Can't find relation data for " +
+                                        std::to_string(rel_id.GetID()));
 
         return it->second;
     }

include/extractor/scripting_environment.hpp

@@ -62,13 +62,13 @@ class ScriptingEnvironment
     virtual void ProcessTurn(ExtractionTurn &turn) = 0;
     virtual void ProcessSegment(ExtractionSegment &segment) = 0;
 
-    virtual void ProcessElements(
-        const osmium::memory::Buffer &buffer,
-        const RestrictionParser &restriction_parser,
-        const ExtractionRelationContainer &relations,
-        std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
-        std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
-        std::vector<InputConditionalTurnRestriction> &resulting_restrictions) = 0;
+    virtual void
+    ProcessElements(const osmium::memory::Buffer &buffer,
+                    const RestrictionParser &restriction_parser,
+                    const ExtractionRelationContainer &relations,
+                    std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
+                    std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
+                    std::vector<InputConditionalTurnRestriction> &resulting_restrictions) = 0;
 
     virtual bool HasLocationDependentData() const = 0;
 };

include/extractor/scripting_environment_lua.hpp

@@ -85,13 +85,13 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment
     void ProcessTurn(ExtractionTurn &turn) override;
     void ProcessSegment(ExtractionSegment &segment) override;
 
-    void ProcessElements(
-        const osmium::memory::Buffer &buffer,
-        const RestrictionParser &restriction_parser,
-        const ExtractionRelationContainer &relations,
-        std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
-        std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
-        std::vector<InputConditionalTurnRestriction> &resulting_restrictions) override;
+    void
+    ProcessElements(const osmium::memory::Buffer &buffer,
+                    const RestrictionParser &restriction_parser,
+                    const ExtractionRelationContainer &relations,
+                    std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
+                    std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
+                    std::vector<InputConditionalTurnRestriction> &resulting_restrictions) override;
 
     bool HasLocationDependentData() const override { return !location_dependent_data.empty(); }
 

src/extractor/extractor.cpp

@@ -491,17 +491,19 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
                 if (entity->type() != osmium::item_type::relation)
                     continue;
 
-                const auto & rel = static_cast<const osmium::Relation &>(*entity);
+                const auto &rel = static_cast<const osmium::Relation &>(*entity);
 
-                const char * rel_type = rel.get_value_by_key("type");
-                if (!rel_type || !std::binary_search(relation_types.begin(), relation_types.end(), std::string(rel_type)))
+                const char *rel_type = rel.get_value_by_key("type");
+                if (!rel_type ||
+                    !std::binary_search(
+                        relation_types.begin(), relation_types.end(), std::string(rel_type)))
                     continue;
 
                 ExtractionRelation extracted_rel({rel.id(), osmium::item_type::relation});
-                for (auto const & t : rel.tags())
+                for (auto const &t : rel.tags())
                     extracted_rel.attributes.emplace_back(std::make_pair(t.key(), t.value()));
 
-                for (auto const & m : rel.members())
+                for (auto const &m : rel.members())
                 {
                     ExtractionRelation::OsmIDTyped const mid(m.ref(), m.type());
                     extracted_rel.AddMember(mid, m.role());
@@ -515,7 +517,8 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
 
     unsigned number_of_relations = 0;
     tbb::filter_t<std::shared_ptr<ExtractionRelationContainer>, void> buffer_storage_relation(
-        tbb::filter::serial_in_order, [&](const std::shared_ptr<ExtractionRelationContainer> parsed_relations) {
+        tbb::filter::serial_in_order,
+        [&](const std::shared_ptr<ExtractionRelationContainer> parsed_relations) {
 
             number_of_relations += parsed_relations->GetRelationsNum();
             relations.Merge(std::move(*parsed_relations));
@@ -536,8 +539,10 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
 
     { // Nodes and ways reading pipeline
         util::Log() << "Parse ways and nodes ...";
-        osmium::io::Reader reader(
-            input_file, osmium::osm_entity_bits::node | osmium::osm_entity_bits::way | osmium::osm_entity_bits::relation, read_meta);
+        osmium::io::Reader reader(input_file,
+                                  osmium::osm_entity_bits::node | osmium::osm_entity_bits::way |
+                                      osmium::osm_entity_bits::relation,
+                                  read_meta);
 
         const auto pipeline =
             scripting_environment.HasLocationDependentData() && config.use_locations_cache

src/extractor/scripting_environment_lua.cpp

@@ -323,7 +323,6 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
             return boost::apply_visitor(to_lua_object(context.state), value);
         });
 
-
     context.state.new_usertype<osmium::Node>("Node",
                                              "location",
                                              &osmium::Node::location,

unit_tests/mocks/mock_scripting_environment.hpp

@@ -35,13 +35,12 @@ class MockScriptingEnvironment : public extractor::ScriptingEnvironment
     void ProcessTurn(extractor::ExtractionTurn &) override final {}
     void ProcessSegment(extractor::ExtractionSegment &) override final {}
 
-    void ProcessElements(
-        const osmium::memory::Buffer &,
-        const extractor::RestrictionParser &,
-        const extractor::ExtractionRelationContainer &,
-        std::vector<std::pair<const osmium::Node &, extractor::ExtractionNode>> &,
-        std::vector<std::pair<const osmium::Way &, extractor::ExtractionWay>> &,
-        std::vector<extractor::InputConditionalTurnRestriction> &) override final
+    void ProcessElements(const osmium::memory::Buffer &,
+                         const extractor::RestrictionParser &,
+                         const extractor::ExtractionRelationContainer &,
+                         std::vector<std::pair<const osmium::Node &, extractor::ExtractionNode>> &,
+                         std::vector<std::pair<const osmium::Way &, extractor::ExtractionWay>> &,
+                         std::vector<extractor::InputConditionalTurnRestriction> &) override final
     {
     }