Change mime type 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,

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/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

@@ -15,7 +15,7 @@ json_formatter::json_formatter(std::unique_ptr<json_writer> w) : writer(std::mov
 
 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;
 }
 }

src/osm_responder.cpp

@@ -14,9 +14,9 @@ osm_responder::osm_responder(mime::type mt, std::optional<bbox> b)
 
 std::vector<mime::type> osm_responder::types_available() const {
   std::vector<mime::type> types;
-  types.push_back(mime::application_xml);
+  types.push_back(mime::type::application_xml);
 #if HAVE_YAJL
-  types.push_back(mime::application_json);
+  types.push_back(mime::type::application_json);
 #endif
   return types;
 }

src/osmchange_responder.cpp

@@ -227,7 +227,7 @@ osmchange_responder::osmchange_responder(mime::type mt, data_selection &s)
 
 std::vector<mime::type> osmchange_responder::types_available() const {
   std::vector<mime::type> types; // TODO: don't reconstruct on every call
-  types.push_back(mime::application_xml);
+  types.push_back(mime::type::application_xml);
   return types;
 }
 

src/routes.cpp

@@ -297,7 +297,7 @@ namespace {
       std::size_t json_found = path.rfind(".json");
 
       if (json_found != string::npos && json_found == path.length() - 5) {
-	  return make_pair(path.substr(0, json_found), mime::application_json);
+	  return make_pair(path.substr(0, json_found), mime::type::application_json);
       }
     }
 #endif
@@ -306,11 +306,11 @@ namespace {
       std::size_t xml_found = path.rfind(".xml");
 
       if (xml_found != string::npos && xml_found == path.length() - 4) {
-	  return make_pair(path.substr(0, xml_found), mime::application_xml);
+	  return make_pair(path.substr(0, xml_found), mime::type::application_xml);
       }
     }
 
-    return make_pair(path, mime::unspecified_type);
+    return make_pair(path, mime::type::unspecified_type);
 }
 
 handler_ptr_t route_resource(request &req, const string &path,

src/text_formatter.cpp

@@ -18,7 +18,7 @@ using std::transform;
 
 text_formatter::text_formatter(std::unique_ptr<text_writer> w) : writer(std::move(w)) {}
 
-mime::type text_formatter::mime_type() const { return mime::text_plain; }
+mime::type text_formatter::mime_type() const { return mime::type::text_plain; }
 
 void text_formatter::start_document(
   const std::string &generator, const std::string &root_name) {

src/text_responder.cpp

@@ -14,7 +14,7 @@ text_responder::text_responder(mime::type mt)
 
 std::vector<mime::type> text_responder::types_available() const {
   std::vector<mime::type> types;
-  types.push_back(mime::text_plain);
+  types.push_back(mime::type::text_plain);
   return types;
 }
 

src/xml_formatter.cpp

@@ -17,7 +17,7 @@ using std::transform;
 
 xml_formatter::xml_formatter(std::unique_ptr<xml_writer> w) : writer(std::move(w)) {}
 
-mime::type xml_formatter::mime_type() const { return mime::application_xml; }
+mime::type xml_formatter::mime_type() const { return mime::type::application_xml; }
 
 void xml_formatter::start_document(
   const std::string &generator, const std::string &root_name) {