Merge pull request zerebubuth#372 from mmd-osm/patch/formatter1

Change some enums to enum class

Author: mmd-osm

include/cgimap/handler.hpp

@@ -61,7 +61,7 @@ class handler {
                                                   http::method::HEAD | 
                                                   http::method::OPTIONS;
 
-  handler(mime::type default_type = mime::unspecified_type,
+  handler(mime::type default_type = mime::type::unspecified_type,
           http::method methods = default_methods);
   virtual ~handler() = default;
 
@@ -90,7 +90,7 @@ using handler_ptr_t = std::unique_ptr<handler>;
 
 class payload_enabled_handler : public handler {
 public:
-  payload_enabled_handler(mime::type default_type = mime::unspecified_type,
+  payload_enabled_handler(mime::type default_type = mime::type::unspecified_type,
                           http::method methods = http::method::POST | http::method::OPTIONS);
 
   // Responder used to update the database

include/cgimap/mime_types.hpp

@@ -16,7 +16,7 @@
  * simple set of supported mime types.
  */
 namespace mime {
-enum type {
+enum class type {
   unspecified_type, // a "null" type, used to indicate no choice.
   text_plain,
   application_xml,

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/api06/changeset_close_handler.cpp

@@ -40,7 +40,7 @@ changeset_close_responder::changeset_close_responder(mime::type mt,
 
 changeset_close_handler::changeset_close_handler(const request &,
                                                  osm_changeset_id_t id)
-    : payload_enabled_handler(mime::text_plain,
+    : payload_enabled_handler(mime::type::text_plain,
                               http::method::PUT | http::method::OPTIONS),
       id(id) {}
 

src/api06/changeset_create_handler.cpp

@@ -42,7 +42,7 @@ changeset_create_responder::changeset_create_responder(mime::type mt,
 }
 
 changeset_create_handler::changeset_create_handler(const request &)
-    : payload_enabled_handler(mime::text_plain,
+    : payload_enabled_handler(mime::type::text_plain,
                               http::method::PUT | http::method::OPTIONS) {}
 
 std::string changeset_create_handler::log_name() const {

src/api06/changeset_update_handler.cpp

@@ -54,7 +54,7 @@ changeset_update_sel_responder::changeset_update_sel_responder(
 
 
 changeset_update_handler::changeset_update_handler(const request &req, osm_changeset_id_t id)
-    : payload_enabled_handler(mime::application_xml,
+    : payload_enabled_handler(mime::type::application_xml,
                               http::method::PUT | http::method::OPTIONS),
       id(id) {}
 

src/api06/changeset_upload_handler.cpp

@@ -75,7 +75,7 @@ changeset_upload_responder::changeset_upload_responder(mime::type mt,
 
 changeset_upload_handler::changeset_upload_handler(const request &,
                                                    osm_changeset_id_t id)
-    : payload_enabled_handler(mime::unspecified_type,
+    : payload_enabled_handler(mime::type::unspecified_type,
                               http::method::POST | http::method::OPTIONS),
       id(id) {}
 

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/choose_formatter.cpp

@@ -54,7 +54,7 @@ class acceptable_types {
 public:
   explicit acceptable_types(const std::string &accept_header);
   bool is_acceptable(mime::type) const;
-  // note: returns mime::unspecified_type if none were acceptable
+  // note: returns mime::type::unspecified_type if none were acceptable
   mime::type most_acceptable_of(const std::vector<mime::type> &available) const;
 
 private:
@@ -121,10 +121,10 @@ struct http_accept_grammar
 };
 /*
       = lit("* / *")      [_val = mime::any_type]
-      | lit("text/xml") [_val = mime::application_xml]
-      | lit("application/xml") [_val = mime::application_xml]
+      | lit("text/xml") [_val = mime::type::application_xml]
+      | lit("application/xml") [_val = mime::type::application_xml]
 #if HAVE_YAJL
-      | lit("application/json")[_val = mime::application_json]
+      | lit("application/json")[_val = mime::type::application_json]
 #endif
       ;
 */
@@ -144,7 +144,7 @@ acceptable_types::acceptable_types(const std::string &accept_header) {
     for (media_range range : ranges) {
       // figure out the mime::type from the string.
       mime::type mime_type = mime::parse_from(range.mime_type);
-      if (mime_type == mime::unspecified_type) {
+      if (mime_type == mime::type::unspecified_type) {
         // if it's unknown then skip this type...
         continue;
       }
@@ -174,7 +174,7 @@ bool acceptable_types::is_acceptable(mime::type mt) const {
 }
 
 mime::type acceptable_types::most_acceptable_of(const std::vector<mime::type> &available) const {
-  mime::type best = mime::unspecified_type;
+  mime::type best = mime::type::unspecified_type;
   float score = std::numeric_limits<float>::min();
   for (mime::type type : available) {
     auto itr = mapping.find(type);
@@ -188,7 +188,7 @@ mime::type acceptable_types::most_acceptable_of(const std::vector<mime::type> &a
 
   // also check the full wildcard.
   if (!available.empty()) {
-    auto itr = mapping.find(mime::any_type);
+    auto itr = mapping.find(mime::type::any_type);
     if ((itr != mapping.end()) && (itr->second > score)) {
       best = available.front();
     }
@@ -230,7 +230,7 @@ mime::type choose_best_mime_type(const request &req, const responder& hptr) {
   mime::type best_type = hptr.resource_type();
   // check if the handler is capable of supporting an acceptable set of mime
   // types.
-  if (best_type != mime::unspecified_type) {
+  if (best_type != mime::type::unspecified_type) {
     // check that this doesn't conflict with anything in the Accept header.
     if (!hptr.is_available(best_type))
       throw http::not_acceptable(fmt::format("Acceptable formats for {} are: {}",
@@ -243,11 +243,11 @@ mime::type choose_best_mime_type(const request &req, const responder& hptr) {
   } else {
     best_type = types.most_acceptable_of(types_available);
     // if none were acceptable then...
-    if (best_type == mime::unspecified_type) {
+    if (best_type == mime::type::unspecified_type) {
 	      throw http::not_acceptable(fmt::format("Acceptable formats for {} are: {}",
 	                                get_request_path(req),
 					mime_types_to_string(types_available)));
-    } else if (best_type == mime::any_type) {
+    } else if (best_type == mime::type::any_type) {
       // choose the first of the available types if nothing is preferred.
       best_type = *(hptr.types_available().begin());
     }
@@ -260,14 +260,14 @@ mime::type choose_best_mime_type(const request &req, const responder& hptr) {
 std::unique_ptr<output_formatter> create_formatter(mime::type best_type, output_buffer& out) {
 
   switch (best_type) {
-    case mime::application_xml:
+    case mime::type::application_xml:
       return std::make_unique<xml_formatter>(std::make_unique<xml_writer>(out, true));
 
 #if HAVE_YAJL
-    case mime::application_json:
+    case mime::type::application_json:
       return std::make_unique<json_formatter>(std::make_unique<json_writer>(out, false));
 #endif
-    case mime::text_plain:
+    case mime::type::text_plain:
       return std::make_unique<text_formatter>(std::make_unique<text_writer>(out, true));
 
     default:

src/json_formatter.cpp

@@ -11,31 +11,11 @@
 
 #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;
 
-mime::type json_formatter::mime_type() const { return mime::application_json; }
+mime::type json_formatter::mime_type() const { return mime::type::application_json; }
 
 void json_formatter::write_tags(const tags_t &tags) {
 

src/mime_types.cpp

@@ -15,14 +15,14 @@ using std::runtime_error;
 
 namespace mime {
 string to_string(type t) {
-  if (any_type == t) {
+  if (mime::type::any_type == t) {
     return "*/*";
-  } else if (text_plain == t) {
+  } else if (mime::type::text_plain == t) {
     return "text/plain";
-  } else if (application_xml == t) {
+  } else if (mime::type::application_xml == t) {
     return "application/xml";
 #if HAVE_YAJL
-  } else if (application_json == t) {
+  } else if (mime::type::application_json == t) {
     return "application/json";
 #endif
   } else {
@@ -31,26 +31,25 @@ string to_string(type t) {
 }
 
 type parse_from(const std::string &name) {
-  type t = unspecified_type;
 
   if (name == "*") {
-    t = any_type;
+    return mime::type::any_type;
   } else if (name == "*/*") {
-    t = any_type;
+    return mime::type::any_type;
   } else if (name == "text/*") {
-    t = any_type;
+    return mime::type::any_type;
   } else if (name == "text/plain") {
-    t = text_plain;
+    return mime::type::text_plain;
   } else if (name == "text/xml") {     // alias according to RFC 7303, section 9.2
-    t = application_xml;
+    return mime::type:: application_xml;
   } else if (name == "application/xml") {
-    t = application_xml;
+    return mime::type::application_xml;
 #if HAVE_YAJL
   } else if (name == "application/json") {
-    t = application_json;
+    return mime::type::application_json;
 #endif
   }
 
-  return t;
+  return mime::type::unspecified_type;
 }
 }