Change two enums to enum class

Author: mmd-osm

include/cgimap/output_formatter.hpp

@@ -25,20 +25,38 @@
 /**
  * What type of element the formatter is starting to write.
  */
-enum element_type {
-  element_type_changeset,
-  element_type_node,
-  element_type_way,
-  element_type_relation
+enum class element_type {
+  changeset,
+  node,
+  way,
+  relation
 };
 
-// TODO: document me.
-enum action_type {
-  action_type_create,
-  action_type_modify,
-  action_type_delete
+enum class action_type {
+  create,
+  modify,
+  del    // delete is a reserved keyword
 };
 
+namespace {
+
+const char* element_type_name(element_type elt) {
+
+  switch (elt) {
+  case element_type::node:
+    return "node";
+  case element_type::way:
+    return "way";
+  case element_type::relation:
+    return "relation";
+  case element_type::changeset:
+    return "changeset";
+  }
+  return "";
+}
+
+} // anonymous namespace
+
 struct element_info {
 
   element_info() = default;

src/backend/apidb/common_pgsql_selection.cpp

@@ -109,17 +109,17 @@ element_type type_from_name(const char *name) {
   switch (name[0]) {
   case 'N':
   case 'n':
-    type = element_type_node;
+    type = element_type::node;
     break;
 
   case 'W':
   case 'w':
-    type = element_type_way;
+    type = element_type::way;
     break;
 
   case 'R':
   case 'r':
-    type = element_type_relation;
+    type = element_type::relation;
     break;
 
   default:

src/backend/staticxml/staticxml.cpp

@@ -203,11 +203,11 @@ struct xml_parser {
         member_info m;
         auto member_type = get_attribute<std::string>("type", attributes);
         if (member_type == "node") {
-          m.type = element_type_node;
+          m.type = element_type::node;
         } else if (member_type == "way") {
-          m.type = element_type_way;
+          m.type = element_type::way;
         } else if (member_type == "relation") {
-          m.type = element_type_relation;
+          m.type = element_type::relation;
         } else {
           throw std::runtime_error(fmt::format("Unknown member type `{}'.", member_type));
         }
@@ -399,7 +399,7 @@ struct static_data_selection : public data_selection {
       auto r = find_current<relation>(id);
       if (r) {
         for (const member_info &m : r->get().m_members) {
-          if (m.type == element_type_node) {
+          if (m.type == element_type::node) {
             m_nodes.insert(m.ref);
           }
         }
@@ -430,7 +430,7 @@ struct static_data_selection : public data_selection {
       auto r = find_current<relation>(id);
       if (r) {
         for (const member_info &m : r->get().m_members) {
-          if (m.type == element_type_way) {
+          if (m.type == element_type::way) {
             m_ways.insert(m.ref);
           }
         }
@@ -447,7 +447,7 @@ struct static_data_selection : public data_selection {
       const relation &r = itr->second;
       if (next == end || next->second.m_info.id != r.m_info.id) {
         for (const member_info &m : r.m_members) {
-          if ((m.type == element_type_way) && (m_ways.count(m.ref) > 0)) {
+          if ((m.type == element_type::way) && (m_ways.count(m.ref) > 0)) {
             m_relations.insert(r.m_info.id);
             break;
           }
@@ -468,7 +468,7 @@ struct static_data_selection : public data_selection {
   void select_relations_from_nodes() override {
     for (auto const & [_, r] : m_db.m_relations) {
       for (const member_info &m : r.m_members) {
-        if ((m.type == element_type_node) && (m_nodes.count(m.ref) > 0)) {
+        if ((m.type == element_type::node) && (m_nodes.count(m.ref) > 0)) {
           m_relations.insert(r.m_info.id);
           break;
         }
@@ -480,7 +480,7 @@ struct static_data_selection : public data_selection {
     std::set<osm_nwr_id_t> tmp_relations;
     for (auto const & [_, r] : m_db.m_relations) {
       for (const member_info &m : r.m_members) {
-        if ((m.type == element_type_relation) &&
+        if ((m.type == element_type::relation) &&
             (m_relations.count(m.ref) > 0)) {
           tmp_relations.insert(r.m_info.id);
           break;
@@ -497,7 +497,7 @@ struct static_data_selection : public data_selection {
       auto r = find_current<relation>(id);
       if (r) {
         for (const member_info &m : r->get().m_members) {
-          if (m.type == element_type_relation) {
+          if (m.type == element_type::relation) {
             m_relations.insert(m.ref);
           }
         }

src/json_formatter.cpp

@@ -11,26 +11,6 @@
 
 #include <chrono>
 
-namespace {
-
-const std::string &element_type_name(element_type elt) {
-  static std::string name_node("node"), name_way("way"),
-      name_relation("relation");
-
-  switch (elt) {
-  case element_type_node:
-    return name_node;
-  case element_type_way:
-    return name_way;
-  case element_type_relation:
-    return name_relation;
-  default:
-    throw std::runtime_error("Unknown element type in element_type_name().");
-  }
-}
-
-} // anonymous namespace
-
 json_formatter::json_formatter(std::unique_ptr<json_writer> w) : writer(std::move(w)) {}
 
 json_formatter::~json_formatter() = default;

src/osm_current_responder.cpp

@@ -35,24 +35,24 @@ void osm_current_responder::write(output_formatter& fmt,
     }
 
     // write all selected changesets
-    fmt.start_element_type(element_type_changeset);
+    fmt.start_element_type(element_type::changeset);
     sel.write_changesets(fmt, now);
-    fmt.end_element_type(element_type_changeset);
+    fmt.end_element_type(element_type::changeset);
 
     // write all selected nodes
-    fmt.start_element_type(element_type_node);
+    fmt.start_element_type(element_type::node);
     sel.write_nodes(fmt);
-    fmt.end_element_type(element_type_node);
+    fmt.end_element_type(element_type::node);
 
     // all selected ways
-    fmt.start_element_type(element_type_way);
+    fmt.start_element_type(element_type::way);
     sel.write_ways(fmt);
-    fmt.end_element_type(element_type_way);
+    fmt.end_element_type(element_type::way);
 
     // all selected relations
-    fmt.start_element_type(element_type_relation);
+    fmt.start_element_type(element_type::relation);
     sel.write_relations(fmt);
-    fmt.end_element_type(element_type_relation);
+    fmt.end_element_type(element_type::relation);
 
   } catch (const std::exception &e) {
     logger::message(fmt::format("Caught error in osm_current_responder: {}",

src/osm_diffresult_responder.cpp

@@ -22,11 +22,11 @@ namespace {
     switch (o) {
 
       case object_type::node:
-	return element_type_node;
+	return element_type::node;
       case object_type::way:
-	return element_type_way;
+	return element_type::way;
       case object_type::relation:
-	return element_type_relation;
+	return element_type::relation;
 
     }
 

src/osmchange_responder.cpp

@@ -102,7 +102,7 @@ struct sorting_formatter : public output_formatter {
     const tags_t &tags) override {
 
     element node{
-      element_type_node, elem, tags, element::lonlat{lon, lat},
+      element_type::node, elem, tags, element::lonlat{lon, lat},
         nodes_t(), members_t()};
 
     m_elements.emplace_back(std::move(node));
@@ -114,7 +114,7 @@ struct sorting_formatter : public output_formatter {
     const tags_t &tags) override {
 
     element way{
-      element_type_way, elem, tags, element::lonlat{},
+      element_type::way, elem, tags, element::lonlat{},
         nodes, members_t()};
 
     m_elements.emplace_back(std::move(way));
@@ -126,7 +126,7 @@ struct sorting_formatter : public output_formatter {
     const tags_t &tags) override {
 
     element rel{
-      element_type_relation, elem, tags, element::lonlat{},
+      element_type::relation, elem, tags, element::lonlat{},
         nodes_t(), members};
 
     m_elements.emplace_back(std::move(rel));
@@ -181,19 +181,19 @@ struct sorting_formatter : public output_formatter {
     std::sort(m_elements.begin(), m_elements.end());
     for (const auto &e : m_elements) {
       if (e.m_info.version == 1) {
-        fmt.start_action(action_type_create);
+        fmt.start_action(action_type::create);
         write_element(e, fmt);
-        fmt.end_action(action_type_create);
+        fmt.end_action(action_type::create);
 
       } else if (e.m_info.visible) {
-        fmt.start_action(action_type_modify);
+        fmt.start_action(action_type::modify);
         write_element(e, fmt);
-        fmt.end_action(action_type_modify);
+        fmt.end_action(action_type::modify);
 
       } else {
-        fmt.start_action(action_type_delete);
+        fmt.start_action(action_type::del);
         write_element(e, fmt);
-        fmt.end_action(action_type_delete);
+        fmt.end_action(action_type::del);
       }
     }
   }
@@ -203,16 +203,16 @@ struct sorting_formatter : public output_formatter {
 
   void write_element(const element &e, output_formatter &fmt) {
     switch (e.m_type) {
-    case element_type_node:
+    case element_type::node:
       fmt.write_node(e.m_info, e.m_lonlat.m_lon, e.m_lonlat.m_lat, e.m_tags);
       break;
-    case element_type_way:
+    case element_type::way:
       fmt.write_way(e.m_info, e.m_nds, e.m_tags);
       break;
-    case element_type_relation:
+    case element_type::relation:
       fmt.write_relation(e.m_info, e.m_members, e.m_tags);
       break;
-    case element_type_changeset:
+    case element_type::changeset:
       break;
     }
   }

src/xml_formatter.cpp

@@ -14,26 +14,6 @@
 using std::string;
 using std::transform;
 
-namespace {
-
-const std::string &element_type_name(element_type elt) {
-  static std::string name_node("node"), name_way("way"),
-      name_relation("relation");
-
-  switch (elt) {
-  case element_type_node:
-    return name_node;
-  case element_type_way:
-    return name_way;
-  case element_type_relation:
-    return name_relation;
-  default:
-    // in case the switch isn't exhaustive?
-    throw std::runtime_error("Unhandled element type in element_type_name().");
-  }
-}
-
-} // anonymous namespace
 
 xml_formatter::xml_formatter(std::unique_ptr<xml_writer> w) : writer(std::move(w)) {}
 
@@ -74,23 +54,23 @@ void xml_formatter::end_element_type(element_type) {
 
 void xml_formatter::start_action(action_type type) {
   switch (type) {
-  case action_type_create:
+  case action_type::create:
     writer->start("create");
     break;
-  case action_type_modify:
+  case action_type::modify:
     writer->start("modify");
     break;
-  case action_type_delete:
+  case action_type::del:
     writer->start("delete");
     break;
   }
 }
 
 void xml_formatter::end_action(action_type type) {
   switch (type) {
-  case action_type_create:
-  case action_type_modify:
-  case action_type_delete:
+  case action_type::create:
+  case action_type::modify:
+  case action_type::del:
     writer->end();
     break;
   }

test/test_apidb_backend_changeset_downloads.cpp

@@ -222,7 +222,7 @@ TEST_CASE_METHOD( DatabaseTestsFixture, "test_changeset_select_relation", "[chan
     REQUIRE(
       test_formatter::relation_t(
         element_info(1, 1, 2, "2017-03-19T20:15:00Z", 1, std::string("user_1"), true),
-        members_t{member_info(element_type_node, 1, "foo")},
+        members_t{member_info(element_type::node, 1, "foo")},
         tags_t()) == f.m_relations.front());  // relation 1, version 1 in changeset 1
   }
 }