Replace codes with enum

library/osrm_impl.cpp

@@ -111,7 +111,7 @@ int OSRM::OSRM_impl::RunQuery(const RouteParameters &route_parameters, osrm::jso
     increase_concurrent_query_count();
     auto return_code = plugin_iterator->second->HandleRequest(route_parameters, json_result);
     decrease_concurrent_query_count();
-    return return_code;
+    return static_cast<int>(return_code);
 }
 
 // decrease number of concurrent queries

plugins/distance_table.hpp

@@ -67,13 +67,13 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
 
     const std::string GetDescriptor() const override final { return descriptor_string; }
 
-    int HandleRequest(const RouteParameters &route_parameters,
+    Status HandleRequest(const RouteParameters &route_parameters,
                       osrm::json::Object &json_result) override final
     {
         if (!check_all_coordinates(route_parameters.coordinates))
         {
             json_result.values["status_message"] = "Coordinates are invalid.";
-            return 400;
+            return Status::Error;
         }
 
         const auto &input_bearings = route_parameters.bearings;
@@ -82,7 +82,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
         {
             json_result.values["status_message"] =
                 "Number of bearings does not match number of coordinates.";
-            return 400;
+            return Status::Error;
         }
 
         auto number_of_sources =
@@ -106,7 +106,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
                 "Number of entries " + std::to_string(number_of_sources * number_of_destination) +
                 " is higher than current maximum (" +
                 std::to_string(max_locations_distance_table * max_locations_distance_table) + ")";
-            return 400;
+            return Status::Error;
         }
 
         const bool checksum_OK = (route_parameters.check_sum == facade->GetCheckSum());
@@ -160,7 +160,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
                 {
                     json_result.values["status_message"] =
                         std::string("Could not find matching road for via ") + std::to_string(i);
-                    return 400;
+                    return Status::NoSegment;
                 }
 
                 if (route_parameters.is_destination[i])
@@ -182,7 +182,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
                 {
                     json_result.values["status_message"] =
                         std::string("Could not find matching road for via ") + std::to_string(i);
-                    return 400;
+                    return Status::NoSegment;
                 }
                 phantom_node_target_out_iter++;
             }
@@ -204,7 +204,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
         if (!result_table)
         {
             json_result.values["status_message"] = "No distance table found.";
-            return 400;
+            return Status::EmptyResult;
         }
 
         osrm::json::Array matrix_json_array;
@@ -236,7 +236,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
             source_coord_json_array.values.push_back(json_coord);
         }
         json_result.values["source_coordinates"] = source_coord_json_array;
-        return 200;
+        return Status::Ok;
     }
 
   private:

plugins/hello_world.hpp

@@ -46,7 +46,7 @@ class HelloWorldPlugin final : public BasePlugin
     virtual ~HelloWorldPlugin() {}
     const std::string GetDescriptor() const override final { return descriptor_string; }
 
-    int HandleRequest(const RouteParameters &routeParameters,
+    Status HandleRequest(const RouteParameters &routeParameters,
                       osrm::json::Object &json_result) override final
     {
         std::string temp_string;
@@ -96,7 +96,7 @@ class HelloWorldPlugin final : public BasePlugin
             ++counter;
         }
         json_result.values["hints"] = json_hints;
-        return 200;
+        return Status::Ok;
     }
 
   private:

plugins/match.hpp

@@ -93,14 +93,17 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
         return label_with_confidence;
     }
 
-    bool getCandidates(const std::vector<FixedPointCoordinate> &input_coords,
+    osrm::matching::CandidateLists getCandidates(
-                      const std::vector<std::pair<const int,const boost::optional<int>>> &input_bearings,
+        const std::vector<FixedPointCoordinate> &input_coords,
-                      const double gps_precision,
+        const std::vector<std::pair<const int, const boost::optional<int>>> &input_bearings,
-                      std::vector<double> &sub_trace_lengths,
+        const double gps_precision,
-                      osrm::matching::CandidateLists &candidates_lists)
+        std::vector<double> &sub_trace_lengths)
     {
+        osrm::matching::CandidateLists candidates_lists;
+
         double query_radius = 10 * gps_precision;
-        double last_distance = coordinate_calculation::haversine_distance(input_coords[0], input_coords[1]);
+        double last_distance =
+            coordinate_calculation::haversine_distance(input_coords[0], input_coords[1]);
 
         sub_trace_lengths.resize(input_coords.size());
         sub_trace_lengths[0] = 0;
@@ -109,7 +112,8 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
             bool allow_uturn = false;
             if (0 < current_coordinate)
             {
-                last_distance = coordinate_calculation::haversine_distance(input_coords[current_coordinate - 1], input_coords[current_coordinate]);
+                last_distance = coordinate_calculation::haversine_distance(
+                    input_coords[current_coordinate - 1], input_coords[current_coordinate]);
 
                 sub_trace_lengths[current_coordinate] +=
                     sub_trace_lengths[current_coordinate - 1] + last_distance;
@@ -130,26 +134,36 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
 
             // Use bearing values if supplied, otherwise fallback to 0,180 defaults
             auto bearing = input_bearings.size() > 0 ? input_bearings[current_coordinate].first : 0;
-            auto range = input_bearings.size() > 0 ? (input_bearings[current_coordinate].second ? *input_bearings[current_coordinate].second : 10 ) : 180;
+            auto range = input_bearings.size() > 0
-            auto candidates = facade->NearestPhantomNodesInRange(input_coords[current_coordinate], query_radius, bearing, range);
+                             ? (input_bearings[current_coordinate].second
+                                    ? *input_bearings[current_coordinate].second
+                                    : 10)
+                             : 180;
+            auto candidates = facade->NearestPhantomNodesInRange(input_coords[current_coordinate],
+                                                                 query_radius, bearing, range);
 
             if (candidates.size() == 0)
             {
-                return false;
+                break;
             }
 
             // sort by foward id, then by reverse id and then by distance
-            std::sort(candidates.begin(), candidates.end(),
+            std::sort(
-                [](const PhantomNodeWithDistance& lhs, const PhantomNodeWithDistance& rhs) {
+                candidates.begin(), candidates.end(),
+                [](const PhantomNodeWithDistance &lhs, const PhantomNodeWithDistance &rhs)
+                {
                     return lhs.phantom_node.forward_node_id < rhs.phantom_node.forward_node_id ||
-                            (lhs.phantom_node.forward_node_id == rhs.phantom_node.forward_node_id &&
+                           (lhs.phantom_node.forward_node_id == rhs.phantom_node.forward_node_id &&
-                             (lhs.phantom_node.reverse_node_id < rhs.phantom_node.reverse_node_id ||
+                            (lhs.phantom_node.reverse_node_id < rhs.phantom_node.reverse_node_id ||
-                              (lhs.phantom_node.reverse_node_id == rhs.phantom_node.reverse_node_id &&
+                             (lhs.phantom_node.reverse_node_id ==
-                               lhs.distance < rhs.distance)));
+                                  rhs.phantom_node.reverse_node_id &&
+                              lhs.distance < rhs.distance)));
                 });
 
-            auto new_end = std::unique(candidates.begin(), candidates.end(),
+            auto new_end = std::unique(
-                [](const PhantomNodeWithDistance& lhs, const PhantomNodeWithDistance& rhs) {
+                candidates.begin(), candidates.end(),
+                [](const PhantomNodeWithDistance &lhs, const PhantomNodeWithDistance &rhs)
+                {
                     return lhs.phantom_node.forward_node_id == rhs.phantom_node.forward_node_id &&
                            lhs.phantom_node.reverse_node_id == rhs.phantom_node.reverse_node_id;
                 });
@@ -166,7 +180,8 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
                     {
                         PhantomNode reverse_node(candidates[i].phantom_node);
                         reverse_node.forward_node_id = SPECIAL_NODEID;
-                        candidates.push_back(PhantomNodeWithDistance { reverse_node, candidates[i].distance});
+                        candidates.push_back(
+                            PhantomNodeWithDistance{reverse_node, candidates[i].distance});
 
                         candidates[i].phantom_node.reverse_node_id = SPECIAL_NODEID;
                     }
@@ -175,14 +190,15 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
 
             // sort by distance to make pruning effective
             std::sort(candidates.begin(), candidates.end(),
-                [](const PhantomNodeWithDistance& lhs, const PhantomNodeWithDistance& rhs) {
+                      [](const PhantomNodeWithDistance &lhs, const PhantomNodeWithDistance &rhs)
-                    return lhs.distance < rhs.distance;
+                      {
-                });
+                          return lhs.distance < rhs.distance;
+                      });
 
             candidates_lists.push_back(std::move(candidates));
         }
 
-        return true;
+        return candidates_lists;
     }
 
     osrm::json::Object submatchingToJSON(const osrm::matching::SubMatching &sub,
@@ -230,18 +246,18 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
 
             if (route_parameters.geometry)
             {
-                subtrace.values["geometry"] = factory.AppendGeometryString(route_parameters.compression);
+                subtrace.values["geometry"] =
+                    factory.AppendGeometryString(route_parameters.compression);
             }
 
-
             if (route_parameters.print_instructions)
             {
                 std::vector<typename JSONDescriptor<DataFacadeT>::Segment> temp_segments;
-                subtrace.values["instructions"] = json_descriptor.BuildTextualDescription(factory, temp_segments);
+                subtrace.values["instructions"] =
+                    json_descriptor.BuildTextualDescription(factory, temp_segments);
             }
 
-            factory.BuildRouteSummary(factory.get_entire_length(),
+            factory.BuildRouteSummary(factory.get_entire_length(), raw_route.shortest_path_length);
-                                              raw_route.shortest_path_length);
             osrm::json::Object json_route_summary;
             json_route_summary.values["total_distance"] = factory.summary.distance;
             json_route_summary.values["total_time"] = factory.summary.duration;
@@ -262,61 +278,65 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
         osrm::json::Array names;
         for (const auto &node : sub.nodes)
         {
-            names.values.emplace_back( facade->get_name_for_id(node.name_id) );
+            names.values.emplace_back(facade->get_name_for_id(node.name_id));
         }
         subtrace.values["matched_names"] = names;
 
         return subtrace;
     }
 
-    int HandleRequest(const RouteParameters &route_parameters,
+    Status HandleRequest(const RouteParameters &route_parameters,
-                      osrm::json::Object &json_result) final override
+                         osrm::json::Object &json_result) final override
     {
         // enforce maximum number of locations for performance reasons
         if (max_locations_map_matching > 0 &&
             static_cast<int>(route_parameters.coordinates.size()) > max_locations_map_matching)
         {
             json_result.values["status_message"] = "Too many coodindates.";
-            return 400;
+            return Status::Error;
         }
 
         // check number of parameters
         if (!check_all_coordinates(route_parameters.coordinates))
         {
             json_result.values["status_message"] = "Invalid coordinates.";
-            return 400;
+            return Status::Error;
         }
 
         std::vector<double> sub_trace_lengths;
-        osrm::matching::CandidateLists candidates_lists;
         const auto &input_coords = route_parameters.coordinates;
         const auto &input_timestamps = route_parameters.timestamps;
         const auto &input_bearings = route_parameters.bearings;
         if (input_timestamps.size() > 0 && input_coords.size() != input_timestamps.size())
         {
-            json_result.values["status_message"] = "Number of timestamps does not match number of coordinates.";
+            json_result.values["status_message"] =
-            return 400;
+                "Number of timestamps does not match number of coordinates.";
+            return Status::Error;
         }
 
         if (input_bearings.size() > 0 && input_coords.size() != input_bearings.size())
         {
-            json_result.values["status_message"] = "Number of bearings does not match number of coordinates.";
+            json_result.values["status_message"] =
-            return 400;
+                "Number of bearings does not match number of coordinates.";
+            return Status::Error;
         }
 
         // enforce maximum number of locations for performance reasons
         if (static_cast<int>(input_coords.size()) < 2)
         {
             json_result.values["status_message"] = "At least two coordinates needed.";
-            return 400;
+            return Status::Error;
         }
 
-        const bool found_candidates =
+        const auto candidates_lists = getCandidates(
-            getCandidates(input_coords, input_bearings, route_parameters.gps_precision, sub_trace_lengths, candidates_lists);
+            input_coords, input_bearings, route_parameters.gps_precision, sub_trace_lengths);
-        if (!found_candidates)
+        if (candidates_lists.size() != input_coords.size())
         {
-            json_result.values["status_message"] = "No suitable matching candidates found.";
+            BOOST_ASSERT(candidates_lists.size() < input_coords.size());
-            return 400;
+            json_result.values["status_message"] =
+                std::string("Could not find a matching segment for coordinate ") +
+                std::to_string(candidates_lists.size());
+            return Status::NoSegment;
         }
 
         // setup logging if enabled
@@ -380,11 +400,11 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
         if (sub_matchings.empty())
         {
             json_result.values["status_message"] = "Cannot find matchings.";
-            return 207;
+            return Status::EmptyResult;
         }
 
         json_result.values["status_message"] = "Found matchings.";
-        return 200;
+        return Status::Ok;
     }
 
   private:

plugins/nearest.hpp

@@ -49,32 +49,39 @@ template <class DataFacadeT> class NearestPlugin final : public BasePlugin
 
     const std::string GetDescriptor() const override final { return descriptor_string; }
 
-    int HandleRequest(const RouteParameters &route_parameters,
+    Status HandleRequest(const RouteParameters &route_parameters,
                       osrm::json::Object &json_result) override final
     {
         // check number of parameters
         if (route_parameters.coordinates.empty() ||
             !route_parameters.coordinates.front().is_valid())
         {
-            return 400;
+            return Status::Error;
         }
 
         const auto &input_bearings = route_parameters.bearings;
-        if (input_bearings.size() > 0 && route_parameters.coordinates.size() != input_bearings.size())
+        if (input_bearings.size() > 0 &&
+            route_parameters.coordinates.size() != input_bearings.size())
         {
-            json_result.values["status_message"] = "Number of bearings does not match number of coordinates.";
+            json_result.values["status_message"] =
-            return 400;
+                "Number of bearings does not match number of coordinates.";
+            return Status::Error;
         }
 
         auto number_of_results = static_cast<std::size_t>(route_parameters.num_results);
         const int bearing = input_bearings.size() > 0 ? input_bearings.front().first : 0;
-        const int range = input_bearings.size() > 0 ? (input_bearings.front().second?*input_bearings.front().second:10) : 180;
+        const int range =
-        auto phantom_node_vector = facade->NearestPhantomNodes(route_parameters.coordinates.front(), number_of_results, bearing, range);
+            input_bearings.size() > 0
+                ? (input_bearings.front().second ? *input_bearings.front().second : 10)
+                : 180;
+        auto phantom_node_vector = facade->NearestPhantomNodes(route_parameters.coordinates.front(),
+                                                               number_of_results, bearing, range);
 
-        if (phantom_node_vector.empty() || !phantom_node_vector.front().phantom_node.is_valid())
+        if (phantom_node_vector.empty())
         {
-            json_result.values["status_message"] = "No nearest edge found.";
+            json_result.values["status_message"] =
-            return 207;
+                std::string("Could not find a matching segments for coordinate.");
+            return Status::NoSegment;
         }
         else
         {
@@ -87,14 +94,13 @@ template <class DataFacadeT> class NearestPlugin final : public BasePlugin
                 for (const auto i :
                      osrm::irange<std::size_t>(0, std::min(number_of_results, vector_length)))
                 {
-                    const auto& node = phantom_node_vector[i].phantom_node;
+                    const auto &node = phantom_node_vector[i].phantom_node;
                     osrm::json::Array json_coordinate;
                     osrm::json::Object result;
                     json_coordinate.values.push_back(node.location.lat / COORDINATE_PRECISION);
                     json_coordinate.values.push_back(node.location.lon / COORDINATE_PRECISION);
                     result.values["mapped coordinate"] = json_coordinate;
-                    result.values["name"] =
+                    result.values["name"] = facade->get_name_for_id(node.name_id);
-                        facade->get_name_for_id(node.name_id);
                     results.values.push_back(result);
                 }
                 json_result.values["results"] = results;
@@ -102,16 +108,16 @@ template <class DataFacadeT> class NearestPlugin final : public BasePlugin
             else
             {
                 osrm::json::Array json_coordinate;
-                json_coordinate.values.push_back(phantom_node_vector.front().phantom_node.location.lat /
+                json_coordinate.values.push_back(
-                                                 COORDINATE_PRECISION);
+                    phantom_node_vector.front().phantom_node.location.lat / COORDINATE_PRECISION);
-                json_coordinate.values.push_back(phantom_node_vector.front().phantom_node.location.lon /
+                json_coordinate.values.push_back(
-                                                 COORDINATE_PRECISION);
+                    phantom_node_vector.front().phantom_node.location.lon / COORDINATE_PRECISION);
                 json_result.values["mapped_coordinate"] = json_coordinate;
                 json_result.values["name"] =
                     facade->get_name_for_id(phantom_node_vector.front().phantom_node.name_id);
             }
         }
-        return 200;
+        return Status::Ok;
     }
 
   private:

plugins/plugin_base.hpp

@@ -41,11 +41,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 class BasePlugin
 {
   public:
+    enum class Status : int
+    {
+      Ok = 200,
+      EmptyResult = 207,
+      NoSegment = 208,
+      Error = 400
+    };
+
     BasePlugin() {}
     // Maybe someone can explain the pure virtual destructor thing to me (dennis)
     virtual ~BasePlugin() {}
     virtual const std::string GetDescriptor() const = 0;
-    virtual int HandleRequest(const RouteParameters &, osrm::json::Object &) = 0;
+    virtual Status HandleRequest(const RouteParameters &, osrm::json::Object &) = 0;
     virtual bool check_all_coordinates(const std::vector<FixedPointCoordinate> &coordinates,
                                        const unsigned min = 2) const final
     {

plugins/timestamp.hpp

@@ -44,15 +44,14 @@ template <class DataFacadeT> class TimestampPlugin final : public BasePlugin
     {
     }
     const std::string GetDescriptor() const override final { return descriptor_string; }
-    int HandleRequest(const RouteParameters &route_parameters,
+    Status HandleRequest(const RouteParameters &route_parameters,
                       osrm::json::Object &json_result) override final
     {
         (void)route_parameters; // unused
 
-        json_result.values["status"] = 0;
         const std::string timestamp = facade->GetTimestamp();
         json_result.values["timestamp"] = timestamp;
-        return 200;
+        return Status::Ok;
     }
 
   private:

plugins/trip.hpp

@@ -42,7 +42,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../descriptors/json_descriptor.hpp"          // to make json output
 #include "../util/make_unique.hpp"
 #include "../util/timing_util.hpp"        // to time runtime
-#include "../util/simple_logger.hpp"      // for logging output
+//#include "../util/simple_logger.hpp"      // for logging output
 #include "../util/dist_table_wrapper.hpp" // to access the dist
                                           // table more easily
 
@@ -101,10 +101,12 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
             const int range = input_bearings.size() > 0
                                   ? (input_bearings[i].second ? *input_bearings[i].second : 10)
                                   : 180;
-            phantom_node_list.push_back(
+            auto results = facade->NearestPhantomNodes(route_parameters.coordinates[i], 1, bearing, range);
-                facade->NearestPhantomNodes(route_parameters.coordinates[i], 1, bearing, range)
+            if (results.empty())
-                    .front()
+            {
-                    .phantom_node);
+                break;
+            }
+            phantom_node_list.push_back(std::move(results.front().phantom_node));
             BOOST_ASSERT(phantom_node_list.back().is_valid(facade->GetNumberOfNodes()));
         }
 
@@ -246,7 +248,7 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
         return min_route;
     }
 
-    int HandleRequest(const RouteParameters &route_parameters,
+    Status HandleRequest(const RouteParameters &route_parameters,
                       osrm::json::Object &json_result) override final
     {
         if (max_locations_trip > 0 &&
@@ -255,14 +257,14 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
             json_result.values["status_message"] =
                 "Number of entries " + std::to_string(route_parameters.coordinates.size()) +
                 " is higher than current maximum (" + std::to_string(max_locations_trip) + ")";
-            return 400;
+            return Status::Error;
         }
 
         // check if all inputs are coordinates
         if (!check_all_coordinates(route_parameters.coordinates))
         {
             json_result.values["status_message"] = "Invalid coordinates.";
-            return 400;
+            return Status::Error;
         }
 
         const auto &input_bearings = route_parameters.bearings;
@@ -271,11 +273,20 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
         {
             json_result.values["status_message"] =
                 "Number of bearings does not match number of coordinates.";
-            return 400;
+            return Status::Error;
         }
 
         // get phantom nodes
         auto phantom_node_list = GetPhantomNodes(route_parameters);
+        if (phantom_node_list.size() != route_parameters.coordinates.size())
+        {
+            BOOST_ASSERT(phantom_node_list.size() < route_parameters.coordinates.size());
+            json_result.values["status_message"] =
+                std::string("Could not find a matching segment for coordinate ") +
+                std::to_string(phantom_node_list.size());
+            return Status::NoSegment;
+        }
+
         const auto number_of_locations = phantom_node_list.size();
 
         // compute the distance table of all phantom nodes
@@ -285,7 +296,7 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
 
         if (result_table.size() == 0)
         {
-            return 400;
+            return Status::Error;
         }
 
         const constexpr std::size_t BF_MAX_FEASABLE = 10;
@@ -354,9 +365,6 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
 
         TIMER_STOP(TRIP_TIMER);
 
-        SimpleLogger().Write() << "Trip calculation took: " << TIMER_MSEC(TRIP_TIMER) / 1000.
-                               << "s";
-
         // prepare JSON output
         // create a json object for every trip
         osrm::json::Array trip;
@@ -381,11 +389,11 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
         if (trip.values.empty())
         {
             json_result.values["status_message"] = "Cannot find trips.";
-            return 207;
+            return Status::EmptyResult;
         }
 
         json_result.values["status_message"] = "Found trips.";
-        return 200;
+        return Status::Ok;
     }
 };
 

plugins/viaroute.hpp

@@ -75,7 +75,7 @@ template <class DataFacadeT> class ViaRoutePlugin final : public BasePlugin
 
     const std::string GetDescriptor() const override final { return descriptor_string; }
 
-    int HandleRequest(const RouteParameters &route_parameters,
+    Status HandleRequest(const RouteParameters &route_parameters,
                       osrm::json::Object &json_result) override final
     {
         if (max_locations_viaroute > 0 &&
@@ -84,13 +84,13 @@ template <class DataFacadeT> class ViaRoutePlugin final : public BasePlugin
             json_result.values["status_message"] =
                 "Number of entries " + std::to_string(route_parameters.coordinates.size()) +
                 " is higher than current maximum (" + std::to_string(max_locations_viaroute) + ")";
-            return 400;
+            return Status::Error;
         }
 
         if (!check_all_coordinates(route_parameters.coordinates))
         {
             json_result.values["status_message"] = "Invalid coordinates.";
-            return 400;
+            return Status::Error;
         }
 
         const auto &input_bearings = route_parameters.bearings;
@@ -99,7 +99,7 @@ template <class DataFacadeT> class ViaRoutePlugin final : public BasePlugin
         {
             json_result.values["status_message"] =
                 "Number of bearings does not match number of coordinates.";
-            return 400;
+            return Status::Error;
         }
 
         std::vector<PhantomNodePair> phantom_node_pair_list(route_parameters.coordinates.size());
@@ -129,7 +129,7 @@ template <class DataFacadeT> class ViaRoutePlugin final : public BasePlugin
                 json_result.values["status_message"] =
                     std::string("Could not find a matching segment for coordinate ") +
                     std::to_string(i);
-                return 400;
+                return Status::NoSegment;
             }
             BOOST_ASSERT(phantom_node_pair_list[i].first.is_valid(facade->GetNumberOfNodes()));
             BOOST_ASSERT(phantom_node_pair_list[i].second.is_valid(facade->GetNumberOfNodes()));
@@ -166,11 +166,6 @@ template <class DataFacadeT> class ViaRoutePlugin final : public BasePlugin
 
         bool no_route = INVALID_EDGE_WEIGHT == raw_route.shortest_path_length;
 
-        if (no_route)
-        {
-            SimpleLogger().Write(logDEBUG) << "Error occurred, single path not found";
-        }
-
         std::unique_ptr<BaseDescriptor<DataFacadeT>> descriptor;
         switch (descriptor_table.get_id(route_parameters.output_format))
         {
@@ -201,13 +196,12 @@ template <class DataFacadeT> class ViaRoutePlugin final : public BasePlugin
                             });
             if (not_in_same_component)
             {
-                SimpleLogger().Write(logDEBUG) << "Coordinates not in same component.";
                 json_result.values["status_message"] = "Impossible route between points.";
-                return 207;
+                return Status::EmptyResult;
             }
         }
 
-        return 200;
+        return Status::Ok;
     }
 };