Added flatbuffers output support to the 'Trip' service.

include/engine/api/flatbuffers/fbresult_generated.h

@@ -1927,7 +1927,7 @@ flatbuffers::Offset<Table> CreateTable(flatbuffers::FlatBufferBuilder &_fbb, con
 struct TripT : public flatbuffers::NativeTable {
   typedef Trip TableType;
   std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> waypoints;
-  std::vector<std::unique_ptr<osrm::engine::api::fbresult::RouteT>> trips;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::RouteObjectT>> trips;
   TripT() {
   }
 };
@@ -1941,8 +1941,8 @@ struct Trip FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_WAYPOINTS);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *trips() const {
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *trips() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *>(VT_TRIPS);
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *>(VT_TRIPS);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -1965,7 +1965,7 @@ struct TripBuilder {
   void add_waypoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
     fbb_.AddOffset(Trip::VT_WAYPOINTS, waypoints);
   }
-  void add_trips(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>> trips) {
+  void add_trips(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> trips) {
     fbb_.AddOffset(Trip::VT_TRIPS, trips);
   }
   explicit TripBuilder(flatbuffers::FlatBufferBuilder &_fbb)
@@ -1983,7 +1983,7 @@ struct TripBuilder {
 inline flatbuffers::Offset<Trip> CreateTrip(
     flatbuffers::FlatBufferBuilder &_fbb,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>> trips = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> trips = 0) {
   TripBuilder builder_(_fbb);
   builder_.add_trips(trips);
   builder_.add_waypoints(waypoints);
@@ -1993,9 +1993,9 @@ inline flatbuffers::Offset<Trip> CreateTrip(
 inline flatbuffers::Offset<Trip> CreateTripDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr,
-    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *trips = nullptr) {
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *trips = nullptr) {
   auto waypoints__ = waypoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
-  auto trips__ = trips ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>(*trips) : 0;
+  auto trips__ = trips ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>(*trips) : 0;
   return osrm::engine::api::fbresult::CreateTrip(
       _fbb,
       waypoints__,
@@ -2774,7 +2774,7 @@ inline void Trip::UnPackTo(TripT *_o, const flatbuffers::resolver_function_t *_r
   (void)_o;
   (void)_resolver;
   { auto _e = waypoints(); if (_e) { _o->waypoints.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->waypoints[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
-  { auto _e = trips(); if (_e) { _o->trips.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->trips[_i] = std::unique_ptr<osrm::engine::api::fbresult::RouteT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = trips(); if (_e) { _o->trips.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->trips[_i] = std::unique_ptr<osrm::engine::api::fbresult::RouteObjectT>(_e->Get(_i)->UnPack(_resolver)); } } };
 }
 
 inline flatbuffers::Offset<Trip> Trip::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TripT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2786,7 +2786,7 @@ inline flatbuffers::Offset<Trip> CreateTrip(flatbuffers::FlatBufferBuilder &_fbb
   (void)_o;
   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TripT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
   auto _waypoints = _o->waypoints.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->waypoints.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->waypoints[i].get(), __va->__rehasher); }, &_va ) : 0;
-  auto _trips = _o->trips.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> (_o->trips.size(), [](size_t i, _VectorArgs *__va) { return CreateRoute(*__va->__fbb, __va->__o->trips[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _trips = _o->trips.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> (_o->trips.size(), [](size_t i, _VectorArgs *__va) { return CreateRouteObject(*__va->__fbb, __va->__o->trips[i].get(), __va->__rehasher); }, &_va ) : 0;
   return osrm::engine::api::fbresult::CreateTrip(
       _fbb,
       _waypoints,

include/engine/api/flatbuffers/trip.fbs

@@ -3,5 +3,5 @@ namespace osrm.engine.api.fbresult;
 
 table Trip {
     waypoints: [Waypoint];
-    trips: [Route];
+    trips: [RouteObject];
 }

include/engine/api/trip_api.hpp

@@ -24,7 +24,45 @@ class TripAPI final : public RouteAPI
         : RouteAPI(facade_, parameters_), parameters(parameters_)
     {
     }
+    void MakeResponse(const std::vector<std::vector<NodeID>> &sub_trips,
+                      const std::vector<InternalRouteResult> &sub_routes,
+                      const std::vector<PhantomNode> &phantoms,
+                      osrm::engine::api::ResultT &response) const
+    {
+        BOOST_ASSERT(sub_trips.size() == sub_routes.size());
 
+        if (response.is<flatbuffers::FlatBufferBuilder>()) {
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            MakeResponse(sub_trips, sub_routes, phantoms, fb_result);
+        } else {
+            auto &json_result = response.get<util::json::Object>();
+            MakeResponse(sub_trips, sub_routes, phantoms, json_result);
+        }
+
+    }
+    void MakeResponse(const std::vector<std::vector<NodeID>> &sub_trips,
+                      const std::vector<InternalRouteResult> &sub_routes,
+                      const std::vector<PhantomNode> &phantoms,
+                      flatbuffers::FlatBufferBuilder &fb_result) const
+    {
+        fbresult::FBResultBuilder response(fb_result);
+        fbresult::TripBuilder trip(fb_result);
+
+        std::vector<flatbuffers::Offset<fbresult::RouteObject>> routes;
+        routes.reserve(sub_trips.size());
+        for (auto index : util::irange<std::size_t>(0UL, sub_trips.size()))
+        {
+            routes.push_back(MakeRoute(fb_result,
+                                   sub_routes[index].segment_end_coordinates,
+                                   sub_routes[index].unpacked_path_segments,
+                                   sub_routes[index].source_traversed_in_reverse,
+                                   sub_routes[index].target_traversed_in_reverse));
+        }
+        trip.add_trips(fb_result.CreateVector(routes));
+        trip.add_waypoints(fb_result.CreateVector(MakeWaypoints(fb_result, sub_trips, phantoms)));
+        response.add_trip(trip.Finish());
+        fb_result.Finish(response.Finish());
+    }
     void MakeResponse(const std::vector<std::vector<NodeID>> &sub_trips,
                       const std::vector<InternalRouteResult> &sub_routes,
                       const std::vector<PhantomNode> &phantoms,
@@ -33,7 +71,6 @@ class TripAPI final : public RouteAPI
         auto number_of_routes = sub_trips.size();
         util::json::Array routes;
         routes.values.reserve(number_of_routes);
-        BOOST_ASSERT(sub_trips.size() == sub_routes.size());
         for (auto index : util::irange<std::size_t>(0UL, sub_trips.size()))
         {
             auto route = MakeRoute(sub_routes[index].segment_end_coordinates,
@@ -50,39 +87,53 @@ class TripAPI final : public RouteAPI
   protected:
     // FIXME this logic is a little backwards. We should change the output format of the
     // trip plugin routing algorithm to be easier to consume here.
+
+    struct TripIndex {
+        TripIndex() = default;
+
+        TripIndex(unsigned sub_trip_index_, unsigned point_index_)
+                : sub_trip_index(sub_trip_index_), point_index(point_index_) {
+        }
+
+        unsigned sub_trip_index = std::numeric_limits<unsigned>::max();
+        unsigned point_index = std::numeric_limits<unsigned>::max();
+
+        bool NotUsed() {
+            return sub_trip_index == std::numeric_limits<unsigned>::max() &&
+                   point_index == std::numeric_limits<unsigned>::max();
+        }
+    };
+
+    std::vector<flatbuffers::Offset<fbresult::Waypoint>> MakeWaypoints(flatbuffers::FlatBufferBuilder &fb_result,
+                                                                       const std::vector<std::vector<NodeID>> &sub_trips,
+                                                                       const std::vector<PhantomNode> &phantoms) const
+    {
+        std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
+        waypoints.reserve(parameters.coordinates.size());
+
+        auto input_idx_to_trip_idx = MakeTripIndices(sub_trips);
+
+        for (auto input_index : util::irange<std::size_t>(0UL, parameters.coordinates.size()))
+        {
+            auto trip_index = input_idx_to_trip_idx[input_index];
+            BOOST_ASSERT(!trip_index.NotUsed());
+
+            auto waypoint = BaseAPI::MakeWaypoint(fb_result, phantoms[input_index]);
+            waypoint.add_waypoint_index(trip_index.point_index);
+            waypoint.add_trips_index(trip_index.sub_trip_index);
+            waypoints.push_back(waypoint.Finish());
+        }
+
+        return waypoints;
+    }
+
     util::json::Array MakeWaypoints(const std::vector<std::vector<NodeID>> &sub_trips,
                                     const std::vector<PhantomNode> &phantoms) const
     {
         util::json::Array waypoints;
         waypoints.values.reserve(parameters.coordinates.size());
 
-        struct TripIndex
+        auto input_idx_to_trip_idx = MakeTripIndices(sub_trips);
-        {
-            TripIndex() = default;
-            TripIndex(unsigned sub_trip_index_, unsigned point_index_)
-                : sub_trip_index(sub_trip_index_), point_index(point_index_)
-            {
-            }
-
-            unsigned sub_trip_index = std::numeric_limits<unsigned>::max();
-            unsigned point_index = std::numeric_limits<unsigned>::max();
-
-            bool NotUsed()
-            {
-                return sub_trip_index == std::numeric_limits<unsigned>::max() &&
-                       point_index == std::numeric_limits<unsigned>::max();
-            }
-        };
-
-        std::vector<TripIndex> input_idx_to_trip_idx(parameters.coordinates.size());
-        for (auto sub_trip_index : util::irange<unsigned>(0u, sub_trips.size()))
-        {
-            for (auto point_index : util::irange<unsigned>(0u, sub_trips[sub_trip_index].size()))
-            {
-                input_idx_to_trip_idx[sub_trips[sub_trip_index][point_index]] =
-                    TripIndex{sub_trip_index, point_index};
-            }
-        }
 
         for (auto input_index : util::irange<std::size_t>(0UL, parameters.coordinates.size()))
         {
@@ -98,6 +149,18 @@ class TripAPI final : public RouteAPI
         return waypoints;
     }
 
+    std::vector<TripIndex>
+    MakeTripIndices(const std::vector<std::vector<NodeID>> &sub_trips) const {
+        std::vector<TripIndex> input_idx_to_trip_idx(parameters.coordinates.size());
+        for (auto sub_trip_index : util::irange<unsigned>(0u, sub_trips.size())) {
+            for (auto point_index : util::irange<unsigned>(0u, sub_trips[sub_trip_index].size())) {
+                input_idx_to_trip_idx[sub_trips[sub_trip_index][point_index]] =
+                        TripIndex{sub_trip_index, point_index};
+            }
+        }
+        return input_idx_to_trip_idx;
+    }
+
     const TripParameters &parameters;
 };
 

src/engine/plugins/trip.cpp

@@ -146,7 +146,6 @@ Status TripPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                                  const api::TripParameters &parameters,
                                  osrm::engine::api::ResultT &result) const
 {
-    auto& json_result = result.get<util::json::Object>();
     if (!algorithms.HasShortestPathSearch())
     {
         return Error("NotImplemented",
@@ -276,7 +275,7 @@ Status TripPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
     const std::vector<std::vector<NodeID>> trips = {duration_trip};
     const std::vector<InternalRouteResult> routes = {route};
     api::TripAPI trip_api{facade, parameters};
-    trip_api.MakeResponse(trips, routes, snapped_phantoms, json_result);
+    trip_api.MakeResponse(trips, routes, snapped_phantoms, result);
 
     return Status::Ok;
 }

src/server/service/trip_service.cpp

@@ -69,6 +69,12 @@ engine::Status TripService::RunQuery(std::size_t prefix_length, std::string &que
     }
     BOOST_ASSERT(parameters->IsValid());
 
+    if (parameters->format)
+    {
+        if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) {
+            result = flatbuffers::FlatBufferBuilder();
+        }
+    }
     return BaseService::routing_machine.Trip(*parameters, result);
 }
 }