osrm-backend/include/engine/api/flatbuffers/fbresult_generated.h

// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
#define FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_

#include "flatbuffers/flatbuffers.h"

namespace osrm {
namespace engine {
namespace api {
namespace fbresult {

struct Position;
struct PositionT;

struct Waypoint;
struct WaypointT;

struct Metadata;
struct MetadataT;

struct Annotation;
struct AnnotationT;

struct StepManeuver;
struct StepManeuverT;

struct Lane;
struct LaneT;

struct Intersection;
struct IntersectionT;

struct Polyline;
struct PolylineT;

struct Step;
struct StepT;

struct Leg;
struct LegT;

struct RouteObject;
struct RouteObjectT;

struct Route;
struct RouteT;

struct Match;
struct MatchT;

struct Nearest;
struct NearestT;

struct VectorDouble;
struct VectorDoubleT;

struct Table;
struct TableT;

struct Trip;
struct TripT;

struct FBResult;
struct FBResultT;

enum ManeuverType {
  ManeuverType_Turn = 0,
  ManeuverType_NewName = 1,
  ManeuverType_Depart = 2,
  ManeuverType_Arrive = 3,
  ManeuverType_Merge = 4,
  ManeuverType_OnRamp = 5,
  ManeuverType_OffRamp = 6,
  ManeuverType_Fork = 7,
  ManeuverType_EndOfRoad = 8,
  ManeuverType_Continue = 9,
  ManeuverType_Roundabout = 10,
  ManeuverType_Rotary = 11,
  ManeuverType_RoundaboutTurn = 12,
  ManeuverType_Notification = 13,
  ManeuverType_ExitRoundabout = 14,
  ManeuverType_ExitRotary = 15,
  ManeuverType_MIN = ManeuverType_Turn,
  ManeuverType_MAX = ManeuverType_ExitRotary
};

inline const ManeuverType (&EnumValuesManeuverType())[16] {
  static const ManeuverType values[] = {
    ManeuverType_Turn,
    ManeuverType_NewName,
    ManeuverType_Depart,
    ManeuverType_Arrive,
    ManeuverType_Merge,
    ManeuverType_OnRamp,
    ManeuverType_OffRamp,
    ManeuverType_Fork,
    ManeuverType_EndOfRoad,
    ManeuverType_Continue,
    ManeuverType_Roundabout,
    ManeuverType_Rotary,
    ManeuverType_RoundaboutTurn,
    ManeuverType_Notification,
    ManeuverType_ExitRoundabout,
    ManeuverType_ExitRotary
  };
  return values;
}

inline const char * const *EnumNamesManeuverType() {
  static const char * const names[17] = {
    "Turn",
    "NewName",
    "Depart",
    "Arrive",
    "Merge",
    "OnRamp",
    "OffRamp",
    "Fork",
    "EndOfRoad",
    "Continue",
    "Roundabout",
    "Rotary",
    "RoundaboutTurn",
    "Notification",
    "ExitRoundabout",
    "ExitRotary",
    nullptr
  };
  return names;
}

inline const char *EnumNameManeuverType(ManeuverType e) {
  if (e < ManeuverType_Turn || e > ManeuverType_ExitRotary) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesManeuverType()[index];
}

enum Turn {
  Turn_None = 0,
  Turn_UTurn = 1,
  Turn_SharpRight = 2,
  Turn_Right = 3,
  Turn_SlightRight = 4,
  Turn_Straight = 5,
  Turn_SlightLeft = 6,
  Turn_Left = 7,
  Turn_SharpLeft = 8,
  Turn_MIN = Turn_None,
  Turn_MAX = Turn_SharpLeft
};

inline const Turn (&EnumValuesTurn())[9] {
  static const Turn values[] = {
    Turn_None,
    Turn_UTurn,
    Turn_SharpRight,
    Turn_Right,
    Turn_SlightRight,
    Turn_Straight,
    Turn_SlightLeft,
    Turn_Left,
    Turn_SharpLeft
  };
  return values;
}

inline const char * const *EnumNamesTurn() {
  static const char * const names[10] = {
    "None",
    "UTurn",
    "SharpRight",
    "Right",
    "SlightRight",
    "Straight",
    "SlightLeft",
    "Left",
    "SharpLeft",
    nullptr
  };
  return names;
}

inline const char *EnumNameTurn(Turn e) {
  if (e < Turn_None || e > Turn_SharpLeft) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesTurn()[index];
}

enum Geometry {
  Geometry_NONE = 0,
  Geometry_polyline = 1,
  Geometry_polyline6 = 2,
  Geometry_coordinates = 3,
  Geometry_MIN = Geometry_NONE,
  Geometry_MAX = Geometry_coordinates
};

inline const Geometry (&EnumValuesGeometry())[4] {
  static const Geometry values[] = {
    Geometry_NONE,
    Geometry_polyline,
    Geometry_polyline6,
    Geometry_coordinates
  };
  return values;
}

inline const char * const *EnumNamesGeometry() {
  static const char * const names[5] = {
    "NONE",
    "polyline",
    "polyline6",
    "coordinates",
    nullptr
  };
  return names;
}

inline const char *EnumNameGeometry(Geometry e) {
  if (e < Geometry_NONE || e > Geometry_coordinates) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesGeometry()[index];
}

struct GeometryUnion {
  Geometry type;
  void *value;

  GeometryUnion() : type(Geometry_NONE), value(nullptr) {}
  GeometryUnion(GeometryUnion&& u) FLATBUFFERS_NOEXCEPT :
    type(Geometry_NONE), value(nullptr)
    { std::swap(type, u.type); std::swap(value, u.value); }
  GeometryUnion(const GeometryUnion &) FLATBUFFERS_NOEXCEPT;
  GeometryUnion &operator=(const GeometryUnion &u) FLATBUFFERS_NOEXCEPT
    { GeometryUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
  GeometryUnion &operator=(GeometryUnion &&u) FLATBUFFERS_NOEXCEPT
    { std::swap(type, u.type); std::swap(value, u.value); return *this; }
  ~GeometryUnion() { Reset(); }

  void Reset();

  static void *UnPack(const void *obj, Geometry type, const flatbuffers::resolver_function_t *resolver);
  flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;

  std::string *Aspolyline() {
    return type == Geometry_polyline ?
      reinterpret_cast<std::string *>(value) : nullptr;
  }
  const std::string *Aspolyline() const {
    return type == Geometry_polyline ?
      reinterpret_cast<const std::string *>(value) : nullptr;
  }
  std::string *Aspolyline6() {
    return type == Geometry_polyline6 ?
      reinterpret_cast<std::string *>(value) : nullptr;
  }
  const std::string *Aspolyline6() const {
    return type == Geometry_polyline6 ?
      reinterpret_cast<const std::string *>(value) : nullptr;
  }
  osrm::engine::api::fbresult::PolylineT *Ascoordinates() {
    return type == Geometry_coordinates ?
      reinterpret_cast<osrm::engine::api::fbresult::PolylineT *>(value) : nullptr;
  }
  const osrm::engine::api::fbresult::PolylineT *Ascoordinates() const {
    return type == Geometry_coordinates ?
      reinterpret_cast<const osrm::engine::api::fbresult::PolylineT *>(value) : nullptr;
  }
};

bool VerifyGeometry(flatbuffers::Verifier &verifier, const void *obj, Geometry type);
bool VerifyGeometryVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);

enum ServiceResponse {
  ServiceResponse_NONE = 0,
  ServiceResponse_match = 1,
  ServiceResponse_nearest = 2,
  ServiceResponse_route = 3,
  ServiceResponse_table = 4,
  ServiceResponse_trip = 5,
  ServiceResponse_MIN = ServiceResponse_NONE,
  ServiceResponse_MAX = ServiceResponse_trip
};

inline const ServiceResponse (&EnumValuesServiceResponse())[6] {
  static const ServiceResponse values[] = {
    ServiceResponse_NONE,
    ServiceResponse_match,
    ServiceResponse_nearest,
    ServiceResponse_route,
    ServiceResponse_table,
    ServiceResponse_trip
  };
  return values;
}

inline const char * const *EnumNamesServiceResponse() {
  static const char * const names[7] = {
    "NONE",
    "match",
    "nearest",
    "route",
    "table",
    "trip",
    nullptr
  };
  return names;
}

inline const char *EnumNameServiceResponse(ServiceResponse e) {
  if (e < ServiceResponse_NONE || e > ServiceResponse_trip) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesServiceResponse()[index];
}

template<typename T> struct ServiceResponseTraits {
  static const ServiceResponse enum_value = ServiceResponse_NONE;
};

template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Match> {
  static const ServiceResponse enum_value = ServiceResponse_match;
};

template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Nearest> {
  static const ServiceResponse enum_value = ServiceResponse_nearest;
};

template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Route> {
  static const ServiceResponse enum_value = ServiceResponse_route;
};

template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Table> {
  static const ServiceResponse enum_value = ServiceResponse_table;
};

template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Trip> {
  static const ServiceResponse enum_value = ServiceResponse_trip;
};

struct ServiceResponseUnion {
  ServiceResponse type;
  void *value;

  ServiceResponseUnion() : type(ServiceResponse_NONE), value(nullptr) {}
  ServiceResponseUnion(ServiceResponseUnion&& u) FLATBUFFERS_NOEXCEPT :
    type(ServiceResponse_NONE), value(nullptr)
    { std::swap(type, u.type); std::swap(value, u.value); }
  ServiceResponseUnion(const ServiceResponseUnion &) FLATBUFFERS_NOEXCEPT;
  ServiceResponseUnion &operator=(const ServiceResponseUnion &u) FLATBUFFERS_NOEXCEPT
    { ServiceResponseUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
  ServiceResponseUnion &operator=(ServiceResponseUnion &&u) FLATBUFFERS_NOEXCEPT
    { std::swap(type, u.type); std::swap(value, u.value); return *this; }
  ~ServiceResponseUnion() { Reset(); }

  void Reset();

#ifndef FLATBUFFERS_CPP98_STL
  template <typename T>
  void Set(T&& val) {
    using RT = typename std::remove_reference<T>::type;
    Reset();
    type = ServiceResponseTraits<typename RT::TableType>::enum_value;
    if (type != ServiceResponse_NONE) {
      value = new RT(std::forward<T>(val));
    }
  }
#endif  // FLATBUFFERS_CPP98_STL

  static void *UnPack(const void *obj, ServiceResponse type, const flatbuffers::resolver_function_t *resolver);
  flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;

  osrm::engine::api::fbresult::MatchT *Asmatch() {
    return type == ServiceResponse_match ?
      reinterpret_cast<osrm::engine::api::fbresult::MatchT *>(value) : nullptr;
  }
  const osrm::engine::api::fbresult::MatchT *Asmatch() const {
    return type == ServiceResponse_match ?
      reinterpret_cast<const osrm::engine::api::fbresult::MatchT *>(value) : nullptr;
  }
  osrm::engine::api::fbresult::NearestT *Asnearest() {
    return type == ServiceResponse_nearest ?
      reinterpret_cast<osrm::engine::api::fbresult::NearestT *>(value) : nullptr;
  }
  const osrm::engine::api::fbresult::NearestT *Asnearest() const {
    return type == ServiceResponse_nearest ?
      reinterpret_cast<const osrm::engine::api::fbresult::NearestT *>(value) : nullptr;
  }
  osrm::engine::api::fbresult::RouteT *Asroute() {
    return type == ServiceResponse_route ?
      reinterpret_cast<osrm::engine::api::fbresult::RouteT *>(value) : nullptr;
  }
  const osrm::engine::api::fbresult::RouteT *Asroute() const {
    return type == ServiceResponse_route ?
      reinterpret_cast<const osrm::engine::api::fbresult::RouteT *>(value) : nullptr;
  }
  osrm::engine::api::fbresult::TableT *Astable() {
    return type == ServiceResponse_table ?
      reinterpret_cast<osrm::engine::api::fbresult::TableT *>(value) : nullptr;
  }
  const osrm::engine::api::fbresult::TableT *Astable() const {
    return type == ServiceResponse_table ?
      reinterpret_cast<const osrm::engine::api::fbresult::TableT *>(value) : nullptr;
  }
  osrm::engine::api::fbresult::TripT *Astrip() {
    return type == ServiceResponse_trip ?
      reinterpret_cast<osrm::engine::api::fbresult::TripT *>(value) : nullptr;
  }
  const osrm::engine::api::fbresult::TripT *Astrip() const {
    return type == ServiceResponse_trip ?
      reinterpret_cast<const osrm::engine::api::fbresult::TripT *>(value) : nullptr;
  }
};

bool VerifyServiceResponse(flatbuffers::Verifier &verifier, const void *obj, ServiceResponse type);
bool VerifyServiceResponseVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);

struct PositionT : public flatbuffers::NativeTable {
  typedef Position TableType;
  double longitute;
  double latitude;
  PositionT()
      : longitute(0.0),
        latitude(0.0) {
  }
};

struct Position FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PositionT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_LONGITUTE = 4,
    VT_LATITUDE = 6
  };
  double longitute() const {
    return GetField<double>(VT_LONGITUTE, 0.0);
  }
  double latitude() const {
    return GetField<double>(VT_LATITUDE, 0.0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<double>(verifier, VT_LONGITUTE) &&
           VerifyField<double>(verifier, VT_LATITUDE) &&
           verifier.EndTable();
  }
  PositionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PositionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Position> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PositionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PositionBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_longitute(double longitute) {
    fbb_.AddElement<double>(Position::VT_LONGITUTE, longitute, 0.0);
  }
  void add_latitude(double latitude) {
    fbb_.AddElement<double>(Position::VT_LATITUDE, latitude, 0.0);
  }
  explicit PositionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PositionBuilder &operator=(const PositionBuilder &);
  flatbuffers::Offset<Position> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Position>(end);
    return o;
  }
};

inline flatbuffers::Offset<Position> CreatePosition(
    flatbuffers::FlatBufferBuilder &_fbb,
    double longitute = 0.0,
    double latitude = 0.0) {
  PositionBuilder builder_(_fbb);
  builder_.add_latitude(latitude);
  builder_.add_longitute(longitute);
  return builder_.Finish();
}

flatbuffers::Offset<Position> CreatePosition(flatbuffers::FlatBufferBuilder &_fbb, const PositionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct WaypointT : public flatbuffers::NativeTable {
  typedef Waypoint TableType;
  std::string hint;
  double distance;
  std::string name;
  std::unique_ptr<osrm::engine::api::fbresult::PositionT> location;
  std::vector<double> nodes;
  uint32_t matchings_index;
  uint32_t waypoint_index;
  uint32_t alternatives_count;
  uint32_t trips_index;
  WaypointT()
      : distance(0.0),
        matchings_index(0),
        waypoint_index(0),
        alternatives_count(0),
        trips_index(0) {
  }
};

struct Waypoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef WaypointT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_HINT = 4,
    VT_DISTANCE = 6,
    VT_NAME = 8,
    VT_LOCATION = 10,
    VT_NODES = 12,
    VT_MATCHINGS_INDEX = 14,
    VT_WAYPOINT_INDEX = 16,
    VT_ALTERNATIVES_COUNT = 18,
    VT_TRIPS_INDEX = 20
  };
  const flatbuffers::String *hint() const {
    return GetPointer<const flatbuffers::String *>(VT_HINT);
  }
  double distance() const {
    return GetField<double>(VT_DISTANCE, 0.0);
  }
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  const osrm::engine::api::fbresult::Position *location() const {
    return GetPointer<const osrm::engine::api::fbresult::Position *>(VT_LOCATION);
  }
  const flatbuffers::Vector<double> *nodes() const {
    return GetPointer<const flatbuffers::Vector<double> *>(VT_NODES);
  }
  uint32_t matchings_index() const {
    return GetField<uint32_t>(VT_MATCHINGS_INDEX, 0);
  }
  uint32_t waypoint_index() const {
    return GetField<uint32_t>(VT_WAYPOINT_INDEX, 0);
  }
  uint32_t alternatives_count() const {
    return GetField<uint32_t>(VT_ALTERNATIVES_COUNT, 0);
  }
  uint32_t trips_index() const {
    return GetField<uint32_t>(VT_TRIPS_INDEX, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_HINT) &&
           verifier.VerifyString(hint()) &&
           VerifyField<double>(verifier, VT_DISTANCE) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_LOCATION) &&
           verifier.VerifyTable(location()) &&
           VerifyOffset(verifier, VT_NODES) &&
           verifier.VerifyVector(nodes()) &&
           VerifyField<uint32_t>(verifier, VT_MATCHINGS_INDEX) &&
           VerifyField<uint32_t>(verifier, VT_WAYPOINT_INDEX) &&
           VerifyField<uint32_t>(verifier, VT_ALTERNATIVES_COUNT) &&
           VerifyField<uint32_t>(verifier, VT_TRIPS_INDEX) &&
           verifier.EndTable();
  }
  WaypointT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(WaypointT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Waypoint> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WaypointT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct WaypointBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_hint(flatbuffers::Offset<flatbuffers::String> hint) {
    fbb_.AddOffset(Waypoint::VT_HINT, hint);
  }
  void add_distance(double distance) {
    fbb_.AddElement<double>(Waypoint::VT_DISTANCE, distance, 0.0);
  }
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(Waypoint::VT_NAME, name);
  }
  void add_location(flatbuffers::Offset<osrm::engine::api::fbresult::Position> location) {
    fbb_.AddOffset(Waypoint::VT_LOCATION, location);
  }
  void add_nodes(flatbuffers::Offset<flatbuffers::Vector<double>> nodes) {
    fbb_.AddOffset(Waypoint::VT_NODES, nodes);
  }
  void add_matchings_index(uint32_t matchings_index) {
    fbb_.AddElement<uint32_t>(Waypoint::VT_MATCHINGS_INDEX, matchings_index, 0);
  }
  void add_waypoint_index(uint32_t waypoint_index) {
    fbb_.AddElement<uint32_t>(Waypoint::VT_WAYPOINT_INDEX, waypoint_index, 0);
  }
  void add_alternatives_count(uint32_t alternatives_count) {
    fbb_.AddElement<uint32_t>(Waypoint::VT_ALTERNATIVES_COUNT, alternatives_count, 0);
  }
  void add_trips_index(uint32_t trips_index) {
    fbb_.AddElement<uint32_t>(Waypoint::VT_TRIPS_INDEX, trips_index, 0);
  }
  explicit WaypointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  WaypointBuilder &operator=(const WaypointBuilder &);
  flatbuffers::Offset<Waypoint> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Waypoint>(end);
    return o;
  }
};

inline flatbuffers::Offset<Waypoint> CreateWaypoint(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> hint = 0,
    double distance = 0.0,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
    flatbuffers::Offset<flatbuffers::Vector<double>> nodes = 0,
    uint32_t matchings_index = 0,
    uint32_t waypoint_index = 0,
    uint32_t alternatives_count = 0,
    uint32_t trips_index = 0) {
  WaypointBuilder builder_(_fbb);
  builder_.add_distance(distance);
  builder_.add_trips_index(trips_index);
  builder_.add_alternatives_count(alternatives_count);
  builder_.add_waypoint_index(waypoint_index);
  builder_.add_matchings_index(matchings_index);
  builder_.add_nodes(nodes);
  builder_.add_location(location);
  builder_.add_name(name);
  builder_.add_hint(hint);
  return builder_.Finish();
}

inline flatbuffers::Offset<Waypoint> CreateWaypointDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *hint = nullptr,
    double distance = 0.0,
    const char *name = nullptr,
    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
    const std::vector<double> *nodes = nullptr,
    uint32_t matchings_index = 0,
    uint32_t waypoint_index = 0,
    uint32_t alternatives_count = 0,
    uint32_t trips_index = 0) {
  auto hint__ = hint ? _fbb.CreateString(hint) : 0;
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto nodes__ = nodes ? _fbb.CreateVector<double>(*nodes) : 0;
  return osrm::engine::api::fbresult::CreateWaypoint(
      _fbb,
      hint__,
      distance,
      name__,
      location,
      nodes__,
      matchings_index,
      waypoint_index,
      alternatives_count,
      trips_index);
}

flatbuffers::Offset<Waypoint> CreateWaypoint(flatbuffers::FlatBufferBuilder &_fbb, const WaypointT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct MetadataT : public flatbuffers::NativeTable {
  typedef Metadata TableType;
  std::vector<std::string> datasource_names;
  MetadataT() {
  }
};

struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef MetadataT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATASOURCE_NAMES = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *datasource_names() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DATASOURCE_NAMES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATASOURCE_NAMES) &&
           verifier.VerifyVector(datasource_names()) &&
           verifier.VerifyVectorOfStrings(datasource_names()) &&
           verifier.EndTable();
  }
  MetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Metadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct MetadataBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_datasource_names(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> datasource_names) {
    fbb_.AddOffset(Metadata::VT_DATASOURCE_NAMES, datasource_names);
  }
  explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  MetadataBuilder &operator=(const MetadataBuilder &);
  flatbuffers::Offset<Metadata> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Metadata>(end);
    return o;
  }
};

inline flatbuffers::Offset<Metadata> CreateMetadata(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> datasource_names = 0) {
  MetadataBuilder builder_(_fbb);
  builder_.add_datasource_names(datasource_names);
  return builder_.Finish();
}

inline flatbuffers::Offset<Metadata> CreateMetadataDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *datasource_names = nullptr) {
  auto datasource_names__ = datasource_names ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*datasource_names) : 0;
  return osrm::engine::api::fbresult::CreateMetadata(
      _fbb,
      datasource_names__);
}

flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct AnnotationT : public flatbuffers::NativeTable {
  typedef Annotation TableType;
  std::vector<uint32_t> distance;
  std::vector<uint32_t> duration;
  std::vector<uint32_t> datasources;
  std::vector<uint32_t> nodes;
  std::vector<uint32_t> weight;
  std::vector<double> speed;
  std::unique_ptr<osrm::engine::api::fbresult::MetadataT> metadata;
  AnnotationT() {
  }
};

struct Annotation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef AnnotationT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DISTANCE = 4,
    VT_DURATION = 6,
    VT_DATASOURCES = 8,
    VT_NODES = 10,
    VT_WEIGHT = 12,
    VT_SPEED = 14,
    VT_METADATA = 16
  };
  const flatbuffers::Vector<uint32_t> *distance() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DISTANCE);
  }
  const flatbuffers::Vector<uint32_t> *duration() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DURATION);
  }
  const flatbuffers::Vector<uint32_t> *datasources() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DATASOURCES);
  }
  const flatbuffers::Vector<uint32_t> *nodes() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_NODES);
  }
  const flatbuffers::Vector<uint32_t> *weight() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_WEIGHT);
  }
  const flatbuffers::Vector<double> *speed() const {
    return GetPointer<const flatbuffers::Vector<double> *>(VT_SPEED);
  }
  const osrm::engine::api::fbresult::Metadata *metadata() const {
    return GetPointer<const osrm::engine::api::fbresult::Metadata *>(VT_METADATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DISTANCE) &&
           verifier.VerifyVector(distance()) &&
           VerifyOffset(verifier, VT_DURATION) &&
           verifier.VerifyVector(duration()) &&
           VerifyOffset(verifier, VT_DATASOURCES) &&
           verifier.VerifyVector(datasources()) &&
           VerifyOffset(verifier, VT_NODES) &&
           verifier.VerifyVector(nodes()) &&
           VerifyOffset(verifier, VT_WEIGHT) &&
           verifier.VerifyVector(weight()) &&
           VerifyOffset(verifier, VT_SPEED) &&
           verifier.VerifyVector(speed()) &&
           VerifyOffset(verifier, VT_METADATA) &&
           verifier.VerifyTable(metadata()) &&
           verifier.EndTable();
  }
  AnnotationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(AnnotationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Annotation> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct AnnotationBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_distance(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> distance) {
    fbb_.AddOffset(Annotation::VT_DISTANCE, distance);
  }
  void add_duration(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration) {
    fbb_.AddOffset(Annotation::VT_DURATION, duration);
  }
  void add_datasources(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> datasources) {
    fbb_.AddOffset(Annotation::VT_DATASOURCES, datasources);
  }
  void add_nodes(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> nodes) {
    fbb_.AddOffset(Annotation::VT_NODES, nodes);
  }
  void add_weight(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> weight) {
    fbb_.AddOffset(Annotation::VT_WEIGHT, weight);
  }
  void add_speed(flatbuffers::Offset<flatbuffers::Vector<double>> speed) {
    fbb_.AddOffset(Annotation::VT_SPEED, speed);
  }
  void add_metadata(flatbuffers::Offset<osrm::engine::api::fbresult::Metadata> metadata) {
    fbb_.AddOffset(Annotation::VT_METADATA, metadata);
  }
  explicit AnnotationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  AnnotationBuilder &operator=(const AnnotationBuilder &);
  flatbuffers::Offset<Annotation> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Annotation>(end);
    return o;
  }
};

inline flatbuffers::Offset<Annotation> CreateAnnotation(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> distance = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> datasources = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> nodes = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> weight = 0,
    flatbuffers::Offset<flatbuffers::Vector<double>> speed = 0,
    flatbuffers::Offset<osrm::engine::api::fbresult::Metadata> metadata = 0) {
  AnnotationBuilder builder_(_fbb);
  builder_.add_metadata(metadata);
  builder_.add_speed(speed);
  builder_.add_weight(weight);
  builder_.add_nodes(nodes);
  builder_.add_datasources(datasources);
  builder_.add_duration(duration);
  builder_.add_distance(distance);
  return builder_.Finish();
}

inline flatbuffers::Offset<Annotation> CreateAnnotationDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint32_t> *distance = nullptr,
    const std::vector<uint32_t> *duration = nullptr,
    const std::vector<uint32_t> *datasources = nullptr,
    const std::vector<uint32_t> *nodes = nullptr,
    const std::vector<uint32_t> *weight = nullptr,
    const std::vector<double> *speed = nullptr,
    flatbuffers::Offset<osrm::engine::api::fbresult::Metadata> metadata = 0) {
  auto distance__ = distance ? _fbb.CreateVector<uint32_t>(*distance) : 0;
  auto duration__ = duration ? _fbb.CreateVector<uint32_t>(*duration) : 0;
  auto datasources__ = datasources ? _fbb.CreateVector<uint32_t>(*datasources) : 0;
  auto nodes__ = nodes ? _fbb.CreateVector<uint32_t>(*nodes) : 0;
  auto weight__ = weight ? _fbb.CreateVector<uint32_t>(*weight) : 0;
  auto speed__ = speed ? _fbb.CreateVector<double>(*speed) : 0;
  return osrm::engine::api::fbresult::CreateAnnotation(
      _fbb,
      distance__,
      duration__,
      datasources__,
      nodes__,
      weight__,
      speed__,
      metadata);
}

flatbuffers::Offset<Annotation> CreateAnnotation(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct StepManeuverT : public flatbuffers::NativeTable {
  typedef StepManeuver TableType;
  std::unique_ptr<osrm::engine::api::fbresult::PositionT> location;
  uint16_t bearing_before;
  uint16_t bearing_after;
  osrm::engine::api::fbresult::ManeuverType type;
  osrm::engine::api::fbresult::Turn modifier;
  uint8_t exit;
  StepManeuverT()
      : bearing_before(0),
        bearing_after(0),
        type(osrm::engine::api::fbresult::ManeuverType_Turn),
        modifier(osrm::engine::api::fbresult::Turn_None),
        exit(0) {
  }
};

struct StepManeuver FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef StepManeuverT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_LOCATION = 4,
    VT_BEARING_BEFORE = 6,
    VT_BEARING_AFTER = 8,
    VT_TYPE = 10,
    VT_MODIFIER = 12,
    VT_EXIT = 14
  };
  const osrm::engine::api::fbresult::Position *location() const {
    return GetPointer<const osrm::engine::api::fbresult::Position *>(VT_LOCATION);
  }
  uint16_t bearing_before() const {
    return GetField<uint16_t>(VT_BEARING_BEFORE, 0);
  }
  uint16_t bearing_after() const {
    return GetField<uint16_t>(VT_BEARING_AFTER, 0);
  }
  osrm::engine::api::fbresult::ManeuverType type() const {
    return static_cast<osrm::engine::api::fbresult::ManeuverType>(GetField<int8_t>(VT_TYPE, 0));
  }
  osrm::engine::api::fbresult::Turn modifier() const {
    return static_cast<osrm::engine::api::fbresult::Turn>(GetField<int8_t>(VT_MODIFIER, 0));
  }
  uint8_t exit() const {
    return GetField<uint8_t>(VT_EXIT, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_LOCATION) &&
           verifier.VerifyTable(location()) &&
           VerifyField<uint16_t>(verifier, VT_BEARING_BEFORE) &&
           VerifyField<uint16_t>(verifier, VT_BEARING_AFTER) &&
           VerifyField<int8_t>(verifier, VT_TYPE) &&
           VerifyField<int8_t>(verifier, VT_MODIFIER) &&
           VerifyField<uint8_t>(verifier, VT_EXIT) &&
           verifier.EndTable();
  }
  StepManeuverT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(StepManeuverT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<StepManeuver> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StepManeuverT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct StepManeuverBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_location(flatbuffers::Offset<osrm::engine::api::fbresult::Position> location) {
    fbb_.AddOffset(StepManeuver::VT_LOCATION, location);
  }
  void add_bearing_before(uint16_t bearing_before) {
    fbb_.AddElement<uint16_t>(StepManeuver::VT_BEARING_BEFORE, bearing_before, 0);
  }
  void add_bearing_after(uint16_t bearing_after) {
    fbb_.AddElement<uint16_t>(StepManeuver::VT_BEARING_AFTER, bearing_after, 0);
  }
  void add_type(osrm::engine::api::fbresult::ManeuverType type) {
    fbb_.AddElement<int8_t>(StepManeuver::VT_TYPE, static_cast<int8_t>(type), 0);
  }
  void add_modifier(osrm::engine::api::fbresult::Turn modifier) {
    fbb_.AddElement<int8_t>(StepManeuver::VT_MODIFIER, static_cast<int8_t>(modifier), 0);
  }
  void add_exit(uint8_t exit) {
    fbb_.AddElement<uint8_t>(StepManeuver::VT_EXIT, exit, 0);
  }
  explicit StepManeuverBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  StepManeuverBuilder &operator=(const StepManeuverBuilder &);
  flatbuffers::Offset<StepManeuver> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<StepManeuver>(end);
    return o;
  }
};

inline flatbuffers::Offset<StepManeuver> CreateStepManeuver(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
    uint16_t bearing_before = 0,
    uint16_t bearing_after = 0,
    osrm::engine::api::fbresult::ManeuverType type = osrm::engine::api::fbresult::ManeuverType_Turn,
    osrm::engine::api::fbresult::Turn modifier = osrm::engine::api::fbresult::Turn_None,
    uint8_t exit = 0) {
  StepManeuverBuilder builder_(_fbb);
  builder_.add_location(location);
  builder_.add_bearing_after(bearing_after);
  builder_.add_bearing_before(bearing_before);
  builder_.add_exit(exit);
  builder_.add_modifier(modifier);
  builder_.add_type(type);
  return builder_.Finish();
}

flatbuffers::Offset<StepManeuver> CreateStepManeuver(flatbuffers::FlatBufferBuilder &_fbb, const StepManeuverT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct LaneT : public flatbuffers::NativeTable {
  typedef Lane TableType;
  std::vector<osrm::engine::api::fbresult::Turn> indications;
  bool valid;
  LaneT()
      : valid(false) {
  }
};

struct Lane FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LaneT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INDICATIONS = 4,
    VT_VALID = 6
  };
  const flatbuffers::Vector<int8_t> *indications() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_INDICATIONS);
  }
  bool valid() const {
    return GetField<uint8_t>(VT_VALID, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INDICATIONS) &&
           verifier.VerifyVector(indications()) &&
           VerifyField<uint8_t>(verifier, VT_VALID) &&
           verifier.EndTable();
  }
  LaneT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(LaneT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Lane> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LaneT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct LaneBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_indications(flatbuffers::Offset<flatbuffers::Vector<int8_t>> indications) {
    fbb_.AddOffset(Lane::VT_INDICATIONS, indications);
  }
  void add_valid(bool valid) {
    fbb_.AddElement<uint8_t>(Lane::VT_VALID, static_cast<uint8_t>(valid), 0);
  }
  explicit LaneBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LaneBuilder &operator=(const LaneBuilder &);
  flatbuffers::Offset<Lane> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Lane>(end);
    return o;
  }
};

inline flatbuffers::Offset<Lane> CreateLane(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> indications = 0,
    bool valid = false) {
  LaneBuilder builder_(_fbb);
  builder_.add_indications(indications);
  builder_.add_valid(valid);
  return builder_.Finish();
}

inline flatbuffers::Offset<Lane> CreateLaneDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int8_t> *indications = nullptr,
    bool valid = false) {
  auto indications__ = indications ? _fbb.CreateVector<int8_t>(*indications) : 0;
  return osrm::engine::api::fbresult::CreateLane(
      _fbb,
      indications__,
      valid);
}

flatbuffers::Offset<Lane> CreateLane(flatbuffers::FlatBufferBuilder &_fbb, const LaneT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct IntersectionT : public flatbuffers::NativeTable {
  typedef Intersection TableType;
  std::unique_ptr<osrm::engine::api::fbresult::PositionT> location;
  std::vector<uint16_t> bearings;
  std::vector<std::string> classes;
  std::vector<bool> entry;
  uint32_t in;
  uint32_t out;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::LaneT>> lanes;
  IntersectionT()
      : in(0),
        out(0) {
  }
};

struct Intersection FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef IntersectionT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_LOCATION = 4,
    VT_BEARINGS = 6,
    VT_CLASSES = 8,
    VT_ENTRY = 10,
    VT_IN = 12,
    VT_OUT = 14,
    VT_LANES = 16
  };
  const osrm::engine::api::fbresult::Position *location() const {
    return GetPointer<const osrm::engine::api::fbresult::Position *>(VT_LOCATION);
  }
  const flatbuffers::Vector<uint16_t> *bearings() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_BEARINGS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *classes() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_CLASSES);
  }
  const flatbuffers::Vector<uint8_t> *entry() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_ENTRY);
  }
  uint32_t in() const {
    return GetField<uint32_t>(VT_IN, 0);
  }
  uint32_t out() const {
    return GetField<uint32_t>(VT_OUT, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>> *lanes() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>> *>(VT_LANES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_LOCATION) &&
           verifier.VerifyTable(location()) &&
           VerifyOffset(verifier, VT_BEARINGS) &&
           verifier.VerifyVector(bearings()) &&
           VerifyOffset(verifier, VT_CLASSES) &&
           verifier.VerifyVector(classes()) &&
           verifier.VerifyVectorOfStrings(classes()) &&
           VerifyOffset(verifier, VT_ENTRY) &&
           verifier.VerifyVector(entry()) &&
           VerifyField<uint32_t>(verifier, VT_IN) &&
           VerifyField<uint32_t>(verifier, VT_OUT) &&
           VerifyOffset(verifier, VT_LANES) &&
           verifier.VerifyVector(lanes()) &&
           verifier.VerifyVectorOfTables(lanes()) &&
           verifier.EndTable();
  }
  IntersectionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(IntersectionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Intersection> Pack(flatbuffers::FlatBufferBuilder &_fbb, const IntersectionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct IntersectionBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_location(flatbuffers::Offset<osrm::engine::api::fbresult::Position> location) {
    fbb_.AddOffset(Intersection::VT_LOCATION, location);
  }
  void add_bearings(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> bearings) {
    fbb_.AddOffset(Intersection::VT_BEARINGS, bearings);
  }
  void add_classes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> classes) {
    fbb_.AddOffset(Intersection::VT_CLASSES, classes);
  }
  void add_entry(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> entry) {
    fbb_.AddOffset(Intersection::VT_ENTRY, entry);
  }
  void add_in(uint32_t in) {
    fbb_.AddElement<uint32_t>(Intersection::VT_IN, in, 0);
  }
  void add_out(uint32_t out) {
    fbb_.AddElement<uint32_t>(Intersection::VT_OUT, out, 0);
  }
  void add_lanes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>>> lanes) {
    fbb_.AddOffset(Intersection::VT_LANES, lanes);
  }
  explicit IntersectionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  IntersectionBuilder &operator=(const IntersectionBuilder &);
  flatbuffers::Offset<Intersection> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Intersection>(end);
    return o;
  }
};

inline flatbuffers::Offset<Intersection> CreateIntersection(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> bearings = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> classes = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> entry = 0,
    uint32_t in = 0,
    uint32_t out = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>>> lanes = 0) {
  IntersectionBuilder builder_(_fbb);
  builder_.add_lanes(lanes);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_entry(entry);
  builder_.add_classes(classes);
  builder_.add_bearings(bearings);
  builder_.add_location(location);
  return builder_.Finish();
}

inline flatbuffers::Offset<Intersection> CreateIntersectionDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
    const std::vector<uint16_t> *bearings = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *classes = nullptr,
    const std::vector<uint8_t> *entry = nullptr,
    uint32_t in = 0,
    uint32_t out = 0,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>> *lanes = nullptr) {
  auto bearings__ = bearings ? _fbb.CreateVector<uint16_t>(*bearings) : 0;
  auto classes__ = classes ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*classes) : 0;
  auto entry__ = entry ? _fbb.CreateVector<uint8_t>(*entry) : 0;
  auto lanes__ = lanes ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>>(*lanes) : 0;
  return osrm::engine::api::fbresult::CreateIntersection(
      _fbb,
      location,
      bearings__,
      classes__,
      entry__,
      in,
      out,
      lanes__);
}

flatbuffers::Offset<Intersection> CreateIntersection(flatbuffers::FlatBufferBuilder &_fbb, const IntersectionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PolylineT : public flatbuffers::NativeTable {
  typedef Polyline TableType;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::PositionT>> polyline;
  PolylineT() {
  }
};

struct Polyline FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PolylineT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_POLYLINE = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>> *polyline() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>> *>(VT_POLYLINE);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_POLYLINE) &&
           verifier.VerifyVector(polyline()) &&
           verifier.VerifyVectorOfTables(polyline()) &&
           verifier.EndTable();
  }
  PolylineT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PolylineT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Polyline> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PolylineT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PolylineBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_polyline(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>>> polyline) {
    fbb_.AddOffset(Polyline::VT_POLYLINE, polyline);
  }
  explicit PolylineBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PolylineBuilder &operator=(const PolylineBuilder &);
  flatbuffers::Offset<Polyline> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Polyline>(end);
    return o;
  }
};

inline flatbuffers::Offset<Polyline> CreatePolyline(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>>> polyline = 0) {
  PolylineBuilder builder_(_fbb);
  builder_.add_polyline(polyline);
  return builder_.Finish();
}

inline flatbuffers::Offset<Polyline> CreatePolylineDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>> *polyline = nullptr) {
  auto polyline__ = polyline ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>>(*polyline) : 0;
  return osrm::engine::api::fbresult::CreatePolyline(
      _fbb,
      polyline__);
}

flatbuffers::Offset<Polyline> CreatePolyline(flatbuffers::FlatBufferBuilder &_fbb, const PolylineT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct StepT : public flatbuffers::NativeTable {
  typedef Step TableType;
  double distance;
  double duration;
  GeometryUnion geometry;
  std::string name;
  uint32_t ref;
  std::string pronunciation;
  std::vector<std::string> destinations;
  std::vector<std::string> exits;
  std::string mode;
  std::unique_ptr<osrm::engine::api::fbresult::StepManeuverT> maneuver;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::IntersectionT>> intersections;
  std::string rotary_name;
  std::string rotary_pronunciation;
  bool driving_side;
  StepT()
      : distance(0.0),
        duration(0.0),
        ref(0),
        driving_side(false) {
  }
};

struct Step FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef StepT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DISTANCE = 4,
    VT_DURATION = 6,
    VT_GEOMETRY_TYPE = 8,
    VT_GEOMETRY = 10,
    VT_NAME = 12,
    VT_REF = 14,
    VT_PRONUNCIATION = 16,
    VT_DESTINATIONS = 18,
    VT_EXITS = 20,
    VT_MODE = 22,
    VT_MANEUVER = 24,
    VT_INTERSECTIONS = 26,
    VT_ROTARY_NAME = 28,
    VT_ROTARY_PRONUNCIATION = 30,
    VT_DRIVING_SIDE = 32
  };
  double distance() const {
    return GetField<double>(VT_DISTANCE, 0.0);
  }
  double duration() const {
    return GetField<double>(VT_DURATION, 0.0);
  }
  osrm::engine::api::fbresult::Geometry geometry_type() const {
    return static_cast<osrm::engine::api::fbresult::Geometry>(GetField<uint8_t>(VT_GEOMETRY_TYPE, 0));
  }
  const void *geometry() const {
    return GetPointer<const void *>(VT_GEOMETRY);
  }
  const flatbuffers::String *geometry_as_polyline() const {
    return geometry_type() == osrm::engine::api::fbresult::Geometry_polyline ? static_cast<const flatbuffers::String *>(geometry()) : nullptr;
  }
  const flatbuffers::String *geometry_as_polyline6() const {
    return geometry_type() == osrm::engine::api::fbresult::Geometry_polyline6 ? static_cast<const flatbuffers::String *>(geometry()) : nullptr;
  }
  const osrm::engine::api::fbresult::Polyline *geometry_as_coordinates() const {
    return geometry_type() == osrm::engine::api::fbresult::Geometry_coordinates ? static_cast<const osrm::engine::api::fbresult::Polyline *>(geometry()) : nullptr;
  }
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  uint32_t ref() const {
    return GetField<uint32_t>(VT_REF, 0);
  }
  const flatbuffers::String *pronunciation() const {
    return GetPointer<const flatbuffers::String *>(VT_PRONUNCIATION);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *destinations() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DESTINATIONS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *exits() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_EXITS);
  }
  const flatbuffers::String *mode() const {
    return GetPointer<const flatbuffers::String *>(VT_MODE);
  }
  const osrm::engine::api::fbresult::StepManeuver *maneuver() const {
    return GetPointer<const osrm::engine::api::fbresult::StepManeuver *>(VT_MANEUVER);
  }
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>> *intersections() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>> *>(VT_INTERSECTIONS);
  }
  const flatbuffers::String *rotary_name() const {
    return GetPointer<const flatbuffers::String *>(VT_ROTARY_NAME);
  }
  const flatbuffers::String *rotary_pronunciation() const {
    return GetPointer<const flatbuffers::String *>(VT_ROTARY_PRONUNCIATION);
  }
  bool driving_side() const {
    return GetField<uint8_t>(VT_DRIVING_SIDE, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<double>(verifier, VT_DISTANCE) &&
           VerifyField<double>(verifier, VT_DURATION) &&
           VerifyField<uint8_t>(verifier, VT_GEOMETRY_TYPE) &&
           VerifyOffset(verifier, VT_GEOMETRY) &&
           VerifyGeometry(verifier, geometry(), geometry_type()) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint32_t>(verifier, VT_REF) &&
           VerifyOffset(verifier, VT_PRONUNCIATION) &&
           verifier.VerifyString(pronunciation()) &&
           VerifyOffset(verifier, VT_DESTINATIONS) &&
           verifier.VerifyVector(destinations()) &&
           verifier.VerifyVectorOfStrings(destinations()) &&
           VerifyOffset(verifier, VT_EXITS) &&
           verifier.VerifyVector(exits()) &&
           verifier.VerifyVectorOfStrings(exits()) &&
           VerifyOffset(verifier, VT_MODE) &&
           verifier.VerifyString(mode()) &&
           VerifyOffset(verifier, VT_MANEUVER) &&
           verifier.VerifyTable(maneuver()) &&
           VerifyOffset(verifier, VT_INTERSECTIONS) &&
           verifier.VerifyVector(intersections()) &&
           verifier.VerifyVectorOfTables(intersections()) &&
           VerifyOffset(verifier, VT_ROTARY_NAME) &&
           verifier.VerifyString(rotary_name()) &&
           VerifyOffset(verifier, VT_ROTARY_PRONUNCIATION) &&
           verifier.VerifyString(rotary_pronunciation()) &&
           VerifyField<uint8_t>(verifier, VT_DRIVING_SIDE) &&
           verifier.EndTable();
  }
  StepT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(StepT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Step> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StepT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct StepBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_distance(double distance) {
    fbb_.AddElement<double>(Step::VT_DISTANCE, distance, 0.0);
  }
  void add_duration(double duration) {
    fbb_.AddElement<double>(Step::VT_DURATION, duration, 0.0);
  }
  void add_geometry_type(osrm::engine::api::fbresult::Geometry geometry_type) {
    fbb_.AddElement<uint8_t>(Step::VT_GEOMETRY_TYPE, static_cast<uint8_t>(geometry_type), 0);
  }
  void add_geometry(flatbuffers::Offset<void> geometry) {
    fbb_.AddOffset(Step::VT_GEOMETRY, geometry);
  }
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(Step::VT_NAME, name);
  }
  void add_ref(uint32_t ref) {
    fbb_.AddElement<uint32_t>(Step::VT_REF, ref, 0);
  }
  void add_pronunciation(flatbuffers::Offset<flatbuffers::String> pronunciation) {
    fbb_.AddOffset(Step::VT_PRONUNCIATION, pronunciation);
  }
  void add_destinations(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> destinations) {
    fbb_.AddOffset(Step::VT_DESTINATIONS, destinations);
  }
  void add_exits(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> exits) {
    fbb_.AddOffset(Step::VT_EXITS, exits);
  }
  void add_mode(flatbuffers::Offset<flatbuffers::String> mode) {
    fbb_.AddOffset(Step::VT_MODE, mode);
  }
  void add_maneuver(flatbuffers::Offset<osrm::engine::api::fbresult::StepManeuver> maneuver) {
    fbb_.AddOffset(Step::VT_MANEUVER, maneuver);
  }
  void add_intersections(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>>> intersections) {
    fbb_.AddOffset(Step::VT_INTERSECTIONS, intersections);
  }
  void add_rotary_name(flatbuffers::Offset<flatbuffers::String> rotary_name) {
    fbb_.AddOffset(Step::VT_ROTARY_NAME, rotary_name);
  }
  void add_rotary_pronunciation(flatbuffers::Offset<flatbuffers::String> rotary_pronunciation) {
    fbb_.AddOffset(Step::VT_ROTARY_PRONUNCIATION, rotary_pronunciation);
  }
  void add_driving_side(bool driving_side) {
    fbb_.AddElement<uint8_t>(Step::VT_DRIVING_SIDE, static_cast<uint8_t>(driving_side), 0);
  }
  explicit StepBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  StepBuilder &operator=(const StepBuilder &);
  flatbuffers::Offset<Step> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Step>(end);
    return o;
  }
};

inline flatbuffers::Offset<Step> CreateStep(
    flatbuffers::FlatBufferBuilder &_fbb,
    double distance = 0.0,
    double duration = 0.0,
    osrm::engine::api::fbresult::Geometry geometry_type = osrm::engine::api::fbresult::Geometry_NONE,
    flatbuffers::Offset<void> geometry = 0,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    uint32_t ref = 0,
    flatbuffers::Offset<flatbuffers::String> pronunciation = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> destinations = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> exits = 0,
    flatbuffers::Offset<flatbuffers::String> mode = 0,
    flatbuffers::Offset<osrm::engine::api::fbresult::StepManeuver> maneuver = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>>> intersections = 0,
    flatbuffers::Offset<flatbuffers::String> rotary_name = 0,
    flatbuffers::Offset<flatbuffers::String> rotary_pronunciation = 0,
    bool driving_side = false) {
  StepBuilder builder_(_fbb);
  builder_.add_duration(duration);
  builder_.add_distance(distance);
  builder_.add_rotary_pronunciation(rotary_pronunciation);
  builder_.add_rotary_name(rotary_name);
  builder_.add_intersections(intersections);
  builder_.add_maneuver(maneuver);
  builder_.add_mode(mode);
  builder_.add_exits(exits);
  builder_.add_destinations(destinations);
  builder_.add_pronunciation(pronunciation);
  builder_.add_ref(ref);
  builder_.add_name(name);
  builder_.add_geometry(geometry);
  builder_.add_driving_side(driving_side);
  builder_.add_geometry_type(geometry_type);
  return builder_.Finish();
}

inline flatbuffers::Offset<Step> CreateStepDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    double distance = 0.0,
    double duration = 0.0,
    osrm::engine::api::fbresult::Geometry geometry_type = osrm::engine::api::fbresult::Geometry_NONE,
    flatbuffers::Offset<void> geometry = 0,
    const char *name = nullptr,
    uint32_t ref = 0,
    const char *pronunciation = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *destinations = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *exits = nullptr,
    const char *mode = nullptr,
    flatbuffers::Offset<osrm::engine::api::fbresult::StepManeuver> maneuver = 0,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>> *intersections = nullptr,
    const char *rotary_name = nullptr,
    const char *rotary_pronunciation = nullptr,
    bool driving_side = false) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto pronunciation__ = pronunciation ? _fbb.CreateString(pronunciation) : 0;
  auto destinations__ = destinations ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*destinations) : 0;
  auto exits__ = exits ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*exits) : 0;
  auto mode__ = mode ? _fbb.CreateString(mode) : 0;
  auto intersections__ = intersections ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>>(*intersections) : 0;
  auto rotary_name__ = rotary_name ? _fbb.CreateString(rotary_name) : 0;
  auto rotary_pronunciation__ = rotary_pronunciation ? _fbb.CreateString(rotary_pronunciation) : 0;
  return osrm::engine::api::fbresult::CreateStep(
      _fbb,
      distance,
      duration,
      geometry_type,
      geometry,
      name__,
      ref,
      pronunciation__,
      destinations__,
      exits__,
      mode__,
      maneuver,
      intersections__,
      rotary_name__,
      rotary_pronunciation__,
      driving_side);
}

flatbuffers::Offset<Step> CreateStep(flatbuffers::FlatBufferBuilder &_fbb, const StepT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct LegT : public flatbuffers::NativeTable {
  typedef Leg TableType;
  double distance;
  double duration;
  double weight;
  std::string summary;
  std::unique_ptr<osrm::engine::api::fbresult::AnnotationT> annotations;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::StepT>> steps;
  LegT()
      : distance(0.0),
        duration(0.0),
        weight(0.0) {
  }
};

struct Leg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LegT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DISTANCE = 4,
    VT_DURATION = 6,
    VT_WEIGHT = 8,
    VT_SUMMARY = 10,
    VT_ANNOTATIONS = 12,
    VT_STEPS = 14
  };
  double distance() const {
    return GetField<double>(VT_DISTANCE, 0.0);
  }
  double duration() const {
    return GetField<double>(VT_DURATION, 0.0);
  }
  double weight() const {
    return GetField<double>(VT_WEIGHT, 0.0);
  }
  const flatbuffers::String *summary() const {
    return GetPointer<const flatbuffers::String *>(VT_SUMMARY);
  }
  const osrm::engine::api::fbresult::Annotation *annotations() const {
    return GetPointer<const osrm::engine::api::fbresult::Annotation *>(VT_ANNOTATIONS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>> *steps() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>> *>(VT_STEPS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<double>(verifier, VT_DISTANCE) &&
           VerifyField<double>(verifier, VT_DURATION) &&
           VerifyField<double>(verifier, VT_WEIGHT) &&
           VerifyOffset(verifier, VT_SUMMARY) &&
           verifier.VerifyString(summary()) &&
           VerifyOffset(verifier, VT_ANNOTATIONS) &&
           verifier.VerifyTable(annotations()) &&
           VerifyOffset(verifier, VT_STEPS) &&
           verifier.VerifyVector(steps()) &&
           verifier.VerifyVectorOfTables(steps()) &&
           verifier.EndTable();
  }
  LegT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(LegT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Leg> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LegT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct LegBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_distance(double distance) {
    fbb_.AddElement<double>(Leg::VT_DISTANCE, distance, 0.0);
  }
  void add_duration(double duration) {
    fbb_.AddElement<double>(Leg::VT_DURATION, duration, 0.0);
  }
  void add_weight(double weight) {
    fbb_.AddElement<double>(Leg::VT_WEIGHT, weight, 0.0);
  }
  void add_summary(flatbuffers::Offset<flatbuffers::String> summary) {
    fbb_.AddOffset(Leg::VT_SUMMARY, summary);
  }
  void add_annotations(flatbuffers::Offset<osrm::engine::api::fbresult::Annotation> annotations) {
    fbb_.AddOffset(Leg::VT_ANNOTATIONS, annotations);
  }
  void add_steps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>>> steps) {
    fbb_.AddOffset(Leg::VT_STEPS, steps);
  }
  explicit LegBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LegBuilder &operator=(const LegBuilder &);
  flatbuffers::Offset<Leg> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Leg>(end);
    return o;
  }
};

inline flatbuffers::Offset<Leg> CreateLeg(
    flatbuffers::FlatBufferBuilder &_fbb,
    double distance = 0.0,
    double duration = 0.0,
    double weight = 0.0,
    flatbuffers::Offset<flatbuffers::String> summary = 0,
    flatbuffers::Offset<osrm::engine::api::fbresult::Annotation> annotations = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>>> steps = 0) {
  LegBuilder builder_(_fbb);
  builder_.add_weight(weight);
  builder_.add_duration(duration);
  builder_.add_distance(distance);
  builder_.add_steps(steps);
  builder_.add_annotations(annotations);
  builder_.add_summary(summary);
  return builder_.Finish();
}

inline flatbuffers::Offset<Leg> CreateLegDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    double distance = 0.0,
    double duration = 0.0,
    double weight = 0.0,
    const char *summary = nullptr,
    flatbuffers::Offset<osrm::engine::api::fbresult::Annotation> annotations = 0,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>> *steps = nullptr) {
  auto summary__ = summary ? _fbb.CreateString(summary) : 0;
  auto steps__ = steps ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>>(*steps) : 0;
  return osrm::engine::api::fbresult::CreateLeg(
      _fbb,
      distance,
      duration,
      weight,
      summary__,
      annotations,
      steps__);
}

flatbuffers::Offset<Leg> CreateLeg(flatbuffers::FlatBufferBuilder &_fbb, const LegT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct RouteObjectT : public flatbuffers::NativeTable {
  typedef RouteObject TableType;
  double distance;
  double duration;
  double weight;
  std::string weight_name;
  double confidence;
  GeometryUnion geometry;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::LegT>> legs;
  RouteObjectT()
      : distance(0.0),
        duration(0.0),
        weight(0.0),
        confidence(0.0) {
  }
};

struct RouteObject FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RouteObjectT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DISTANCE = 4,
    VT_DURATION = 6,
    VT_WEIGHT = 8,
    VT_WEIGHT_NAME = 10,
    VT_CONFIDENCE = 12,
    VT_GEOMETRY_TYPE = 14,
    VT_GEOMETRY = 16,
    VT_LEGS = 18
  };
  double distance() const {
    return GetField<double>(VT_DISTANCE, 0.0);
  }
  double duration() const {
    return GetField<double>(VT_DURATION, 0.0);
  }
  double weight() const {
    return GetField<double>(VT_WEIGHT, 0.0);
  }
  const flatbuffers::String *weight_name() const {
    return GetPointer<const flatbuffers::String *>(VT_WEIGHT_NAME);
  }
  double confidence() const {
    return GetField<double>(VT_CONFIDENCE, 0.0);
  }
  osrm::engine::api::fbresult::Geometry geometry_type() const {
    return static_cast<osrm::engine::api::fbresult::Geometry>(GetField<uint8_t>(VT_GEOMETRY_TYPE, 0));
  }
  const void *geometry() const {
    return GetPointer<const void *>(VT_GEOMETRY);
  }
  const flatbuffers::String *geometry_as_polyline() const {
    return geometry_type() == osrm::engine::api::fbresult::Geometry_polyline ? static_cast<const flatbuffers::String *>(geometry()) : nullptr;
  }
  const flatbuffers::String *geometry_as_polyline6() const {
    return geometry_type() == osrm::engine::api::fbresult::Geometry_polyline6 ? static_cast<const flatbuffers::String *>(geometry()) : nullptr;
  }
  const osrm::engine::api::fbresult::Polyline *geometry_as_coordinates() const {
    return geometry_type() == osrm::engine::api::fbresult::Geometry_coordinates ? static_cast<const osrm::engine::api::fbresult::Polyline *>(geometry()) : nullptr;
  }
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>> *legs() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>> *>(VT_LEGS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<double>(verifier, VT_DISTANCE) &&
           VerifyField<double>(verifier, VT_DURATION) &&
           VerifyField<double>(verifier, VT_WEIGHT) &&
           VerifyOffset(verifier, VT_WEIGHT_NAME) &&
           verifier.VerifyString(weight_name()) &&
           VerifyField<double>(verifier, VT_CONFIDENCE) &&
           VerifyField<uint8_t>(verifier, VT_GEOMETRY_TYPE) &&
           VerifyOffset(verifier, VT_GEOMETRY) &&
           VerifyGeometry(verifier, geometry(), geometry_type()) &&
           VerifyOffset(verifier, VT_LEGS) &&
           verifier.VerifyVector(legs()) &&
           verifier.VerifyVectorOfTables(legs()) &&
           verifier.EndTable();
  }
  RouteObjectT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(RouteObjectT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<RouteObject> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RouteObjectT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct RouteObjectBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_distance(double distance) {
    fbb_.AddElement<double>(RouteObject::VT_DISTANCE, distance, 0.0);
  }
  void add_duration(double duration) {
    fbb_.AddElement<double>(RouteObject::VT_DURATION, duration, 0.0);
  }
  void add_weight(double weight) {
    fbb_.AddElement<double>(RouteObject::VT_WEIGHT, weight, 0.0);
  }
  void add_weight_name(flatbuffers::Offset<flatbuffers::String> weight_name) {
    fbb_.AddOffset(RouteObject::VT_WEIGHT_NAME, weight_name);
  }
  void add_confidence(double confidence) {
    fbb_.AddElement<double>(RouteObject::VT_CONFIDENCE, confidence, 0.0);
  }
  void add_geometry_type(osrm::engine::api::fbresult::Geometry geometry_type) {
    fbb_.AddElement<uint8_t>(RouteObject::VT_GEOMETRY_TYPE, static_cast<uint8_t>(geometry_type), 0);
  }
  void add_geometry(flatbuffers::Offset<void> geometry) {
    fbb_.AddOffset(RouteObject::VT_GEOMETRY, geometry);
  }
  void add_legs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>>> legs) {
    fbb_.AddOffset(RouteObject::VT_LEGS, legs);
  }
  explicit RouteObjectBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  RouteObjectBuilder &operator=(const RouteObjectBuilder &);
  flatbuffers::Offset<RouteObject> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RouteObject>(end);
    return o;
  }
};

inline flatbuffers::Offset<RouteObject> CreateRouteObject(
    flatbuffers::FlatBufferBuilder &_fbb,
    double distance = 0.0,
    double duration = 0.0,
    double weight = 0.0,
    flatbuffers::Offset<flatbuffers::String> weight_name = 0,
    double confidence = 0.0,
    osrm::engine::api::fbresult::Geometry geometry_type = osrm::engine::api::fbresult::Geometry_NONE,
    flatbuffers::Offset<void> geometry = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>>> legs = 0) {
  RouteObjectBuilder builder_(_fbb);
  builder_.add_confidence(confidence);
  builder_.add_weight(weight);
  builder_.add_duration(duration);
  builder_.add_distance(distance);
  builder_.add_legs(legs);
  builder_.add_geometry(geometry);
  builder_.add_weight_name(weight_name);
  builder_.add_geometry_type(geometry_type);
  return builder_.Finish();
}

inline flatbuffers::Offset<RouteObject> CreateRouteObjectDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    double distance = 0.0,
    double duration = 0.0,
    double weight = 0.0,
    const char *weight_name = nullptr,
    double confidence = 0.0,
    osrm::engine::api::fbresult::Geometry geometry_type = osrm::engine::api::fbresult::Geometry_NONE,
    flatbuffers::Offset<void> geometry = 0,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>> *legs = nullptr) {
  auto weight_name__ = weight_name ? _fbb.CreateString(weight_name) : 0;
  auto legs__ = legs ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>>(*legs) : 0;
  return osrm::engine::api::fbresult::CreateRouteObject(
      _fbb,
      distance,
      duration,
      weight,
      weight_name__,
      confidence,
      geometry_type,
      geometry,
      legs__);
}

flatbuffers::Offset<RouteObject> CreateRouteObject(flatbuffers::FlatBufferBuilder &_fbb, const RouteObjectT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct RouteT : public flatbuffers::NativeTable {
  typedef Route TableType;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::RouteObjectT>> routes;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> waypoints;
  RouteT() {
  }
};

struct Route FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RouteT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROUTES = 4,
    VT_WAYPOINTS = 6
  };
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *>(VT_ROUTES);
  }
  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);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ROUTES) &&
           verifier.VerifyVector(routes()) &&
           verifier.VerifyVectorOfTables(routes()) &&
           VerifyOffset(verifier, VT_WAYPOINTS) &&
           verifier.VerifyVector(waypoints()) &&
           verifier.VerifyVectorOfTables(waypoints()) &&
           verifier.EndTable();
  }
  RouteT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(RouteT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Route> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RouteT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct RouteBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_routes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes) {
    fbb_.AddOffset(Route::VT_ROUTES, routes);
  }
  void add_waypoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
    fbb_.AddOffset(Route::VT_WAYPOINTS, waypoints);
  }
  explicit RouteBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  RouteBuilder &operator=(const RouteBuilder &);
  flatbuffers::Offset<Route> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Route>(end);
    return o;
  }
};

inline flatbuffers::Offset<Route> CreateRoute(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0) {
  RouteBuilder builder_(_fbb);
  builder_.add_waypoints(waypoints);
  builder_.add_routes(routes);
  return builder_.Finish();
}

inline flatbuffers::Offset<Route> CreateRouteDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes = nullptr,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr) {
  auto routes__ = routes ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>(*routes) : 0;
  auto waypoints__ = waypoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
  return osrm::engine::api::fbresult::CreateRoute(
      _fbb,
      routes__,
      waypoints__);
}

flatbuffers::Offset<Route> CreateRoute(flatbuffers::FlatBufferBuilder &_fbb, const RouteT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct MatchT : public flatbuffers::NativeTable {
  typedef Match TableType;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> tracepoints;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::RouteT>> matchings;
  MatchT() {
  }
};

struct Match FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef MatchT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TRACEPOINTS = 4,
    VT_MATCHINGS = 6
  };
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *tracepoints() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_TRACEPOINTS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *matchings() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *>(VT_MATCHINGS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_TRACEPOINTS) &&
           verifier.VerifyVector(tracepoints()) &&
           verifier.VerifyVectorOfTables(tracepoints()) &&
           VerifyOffset(verifier, VT_MATCHINGS) &&
           verifier.VerifyVector(matchings()) &&
           verifier.VerifyVectorOfTables(matchings()) &&
           verifier.EndTable();
  }
  MatchT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(MatchT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Match> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatchT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct MatchBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_tracepoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> tracepoints) {
    fbb_.AddOffset(Match::VT_TRACEPOINTS, tracepoints);
  }
  void add_matchings(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>> matchings) {
    fbb_.AddOffset(Match::VT_MATCHINGS, matchings);
  }
  explicit MatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  MatchBuilder &operator=(const MatchBuilder &);
  flatbuffers::Offset<Match> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Match>(end);
    return o;
  }
};

inline flatbuffers::Offset<Match> CreateMatch(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> tracepoints = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>> matchings = 0) {
  MatchBuilder builder_(_fbb);
  builder_.add_matchings(matchings);
  builder_.add_tracepoints(tracepoints);
  return builder_.Finish();
}

inline flatbuffers::Offset<Match> CreateMatchDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *tracepoints = nullptr,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *matchings = nullptr) {
  auto tracepoints__ = tracepoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*tracepoints) : 0;
  auto matchings__ = matchings ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>(*matchings) : 0;
  return osrm::engine::api::fbresult::CreateMatch(
      _fbb,
      tracepoints__,
      matchings__);
}

flatbuffers::Offset<Match> CreateMatch(flatbuffers::FlatBufferBuilder &_fbb, const MatchT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct NearestT : public flatbuffers::NativeTable {
  typedef Nearest TableType;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> waypoints;
  NearestT() {
  }
};

struct Nearest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NearestT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WAYPOINTS = 4
  };
  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);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_WAYPOINTS) &&
           verifier.VerifyVector(waypoints()) &&
           verifier.VerifyVectorOfTables(waypoints()) &&
           verifier.EndTable();
  }
  NearestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NearestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Nearest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NearestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct NearestBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_waypoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
    fbb_.AddOffset(Nearest::VT_WAYPOINTS, waypoints);
  }
  explicit NearestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  NearestBuilder &operator=(const NearestBuilder &);
  flatbuffers::Offset<Nearest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Nearest>(end);
    return o;
  }
};

inline flatbuffers::Offset<Nearest> CreateNearest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0) {
  NearestBuilder builder_(_fbb);
  builder_.add_waypoints(waypoints);
  return builder_.Finish();
}

inline flatbuffers::Offset<Nearest> CreateNearestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr) {
  auto waypoints__ = waypoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
  return osrm::engine::api::fbresult::CreateNearest(
      _fbb,
      waypoints__);
}

flatbuffers::Offset<Nearest> CreateNearest(flatbuffers::FlatBufferBuilder &_fbb, const NearestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct VectorDoubleT : public flatbuffers::NativeTable {
  typedef VectorDouble TableType;
  std::vector<double> column;
  VectorDoubleT() {
  }
};

struct VectorDouble FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef VectorDoubleT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COLUMN = 4
  };
  const flatbuffers::Vector<double> *column() const {
    return GetPointer<const flatbuffers::Vector<double> *>(VT_COLUMN);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_COLUMN) &&
           verifier.VerifyVector(column()) &&
           verifier.EndTable();
  }
  VectorDoubleT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(VectorDoubleT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<VectorDouble> Pack(flatbuffers::FlatBufferBuilder &_fbb, const VectorDoubleT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct VectorDoubleBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_column(flatbuffers::Offset<flatbuffers::Vector<double>> column) {
    fbb_.AddOffset(VectorDouble::VT_COLUMN, column);
  }
  explicit VectorDoubleBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  VectorDoubleBuilder &operator=(const VectorDoubleBuilder &);
  flatbuffers::Offset<VectorDouble> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<VectorDouble>(end);
    return o;
  }
};

inline flatbuffers::Offset<VectorDouble> CreateVectorDouble(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<double>> column = 0) {
  VectorDoubleBuilder builder_(_fbb);
  builder_.add_column(column);
  return builder_.Finish();
}

inline flatbuffers::Offset<VectorDouble> CreateVectorDoubleDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<double> *column = nullptr) {
  auto column__ = column ? _fbb.CreateVector<double>(*column) : 0;
  return osrm::engine::api::fbresult::CreateVectorDouble(
      _fbb,
      column__);
}

flatbuffers::Offset<VectorDouble> CreateVectorDouble(flatbuffers::FlatBufferBuilder &_fbb, const VectorDoubleT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct TableT : public flatbuffers::NativeTable {
  typedef Table TableType;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> waypoints;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::VectorDoubleT>> durations;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::VectorDoubleT>> distances;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> sources;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> destinations;
  std::vector<std::unique_ptr<osrm::engine::api::fbresult::VectorDoubleT>> fallback_speed_cells;
  TableT() {
  }
};

struct Table FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef TableT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WAYPOINTS = 4,
    VT_DURATIONS = 6,
    VT_DISTANCES = 8,
    VT_SOURCES = 10,
    VT_DESTINATIONS = 12,
    VT_FALLBACK_SPEED_CELLS = 14
  };
  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::VectorDouble>> *durations() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> *>(VT_DURATIONS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> *distances() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> *>(VT_DISTANCES);
  }
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *sources() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_SOURCES);
  }
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_DESTINATIONS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> *fallback_speed_cells() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> *>(VT_FALLBACK_SPEED_CELLS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_WAYPOINTS) &&
           verifier.VerifyVector(waypoints()) &&
           verifier.VerifyVectorOfTables(waypoints()) &&
           VerifyOffset(verifier, VT_DURATIONS) &&
           verifier.VerifyVector(durations()) &&
           verifier.VerifyVectorOfTables(durations()) &&
           VerifyOffset(verifier, VT_DISTANCES) &&
           verifier.VerifyVector(distances()) &&
           verifier.VerifyVectorOfTables(distances()) &&
           VerifyOffset(verifier, VT_SOURCES) &&
           verifier.VerifyVector(sources()) &&
           verifier.VerifyVectorOfTables(sources()) &&
           VerifyOffset(verifier, VT_DESTINATIONS) &&
           verifier.VerifyVector(destinations()) &&
           verifier.VerifyVectorOfTables(destinations()) &&
           VerifyOffset(verifier, VT_FALLBACK_SPEED_CELLS) &&
           verifier.VerifyVector(fallback_speed_cells()) &&
           verifier.VerifyVectorOfTables(fallback_speed_cells()) &&
           verifier.EndTable();
  }
  TableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(TableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Table> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct TableBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_waypoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
    fbb_.AddOffset(Table::VT_WAYPOINTS, waypoints);
  }
  void add_durations(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>>> durations) {
    fbb_.AddOffset(Table::VT_DURATIONS, durations);
  }
  void add_distances(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>>> distances) {
    fbb_.AddOffset(Table::VT_DISTANCES, distances);
  }
  void add_sources(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> sources) {
    fbb_.AddOffset(Table::VT_SOURCES, sources);
  }
  void add_destinations(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations) {
    fbb_.AddOffset(Table::VT_DESTINATIONS, destinations);
  }
  void add_fallback_speed_cells(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>>> fallback_speed_cells) {
    fbb_.AddOffset(Table::VT_FALLBACK_SPEED_CELLS, fallback_speed_cells);
  }
  explicit TableBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  TableBuilder &operator=(const TableBuilder &);
  flatbuffers::Offset<Table> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Table>(end);
    return o;
  }
};

inline flatbuffers::Offset<Table> CreateTable(
    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::VectorDouble>>> durations = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>>> distances = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> sources = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>>> fallback_speed_cells = 0) {
  TableBuilder builder_(_fbb);
  builder_.add_fallback_speed_cells(fallback_speed_cells);
  builder_.add_destinations(destinations);
  builder_.add_sources(sources);
  builder_.add_distances(distances);
  builder_.add_durations(durations);
  builder_.add_waypoints(waypoints);
  return builder_.Finish();
}

inline flatbuffers::Offset<Table> CreateTableDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> *durations = nullptr,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> *distances = nullptr,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *sources = nullptr,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations = nullptr,
    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> *fallback_speed_cells = nullptr) {
  auto waypoints__ = waypoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
  auto durations__ = durations ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>>(*durations) : 0;
  auto distances__ = distances ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>>(*distances) : 0;
  auto sources__ = sources ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*sources) : 0;
  auto destinations__ = destinations ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*destinations) : 0;
  auto fallback_speed_cells__ = fallback_speed_cells ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>>(*fallback_speed_cells) : 0;
  return osrm::engine::api::fbresult::CreateTable(
      _fbb,
      waypoints__,
      durations__,
      distances__,
      sources__,
      destinations__,
      fallback_speed_cells__);
}

flatbuffers::Offset<Table> CreateTable(flatbuffers::FlatBufferBuilder &_fbb, const TableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

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;
  TripT() {
  }
};

struct Trip FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef TripT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WAYPOINTS = 4,
    VT_TRIPS = 6
  };
  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 {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *>(VT_TRIPS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_WAYPOINTS) &&
           verifier.VerifyVector(waypoints()) &&
           verifier.VerifyVectorOfTables(waypoints()) &&
           VerifyOffset(verifier, VT_TRIPS) &&
           verifier.VerifyVector(trips()) &&
           verifier.VerifyVectorOfTables(trips()) &&
           verifier.EndTable();
  }
  TripT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(TripT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Trip> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TripT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct TripBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  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) {
    fbb_.AddOffset(Trip::VT_TRIPS, trips);
  }
  explicit TripBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  TripBuilder &operator=(const TripBuilder &);
  flatbuffers::Offset<Trip> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Trip>(end);
    return o;
  }
};

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) {
  TripBuilder builder_(_fbb);
  builder_.add_trips(trips);
  builder_.add_waypoints(waypoints);
  return builder_.Finish();
}

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) {
  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;
  return osrm::engine::api::fbresult::CreateTrip(
      _fbb,
      waypoints__,
      trips__);
}

flatbuffers::Offset<Trip> CreateTrip(flatbuffers::FlatBufferBuilder &_fbb, const TripT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct FBResultT : public flatbuffers::NativeTable {
  typedef FBResult TableType;
  std::string code;
  std::string message;
  ServiceResponseUnion response;
  FBResultT() {
  }
};

struct FBResult FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef FBResultT NativeTableType;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CODE = 4,
    VT_MESSAGE = 6,
    VT_RESPONSE_TYPE = 8,
    VT_RESPONSE = 10
  };
  const flatbuffers::String *code() const {
    return GetPointer<const flatbuffers::String *>(VT_CODE);
  }
  const flatbuffers::String *message() const {
    return GetPointer<const flatbuffers::String *>(VT_MESSAGE);
  }
  osrm::engine::api::fbresult::ServiceResponse response_type() const {
    return static_cast<osrm::engine::api::fbresult::ServiceResponse>(GetField<uint8_t>(VT_RESPONSE_TYPE, 0));
  }
  const void *response() const {
    return GetPointer<const void *>(VT_RESPONSE);
  }
  template<typename T> const T *response_as() const;
  const osrm::engine::api::fbresult::Match *response_as_match() const {
    return response_type() == osrm::engine::api::fbresult::ServiceResponse_match ? static_cast<const osrm::engine::api::fbresult::Match *>(response()) : nullptr;
  }
  const osrm::engine::api::fbresult::Nearest *response_as_nearest() const {
    return response_type() == osrm::engine::api::fbresult::ServiceResponse_nearest ? static_cast<const osrm::engine::api::fbresult::Nearest *>(response()) : nullptr;
  }
  const osrm::engine::api::fbresult::Route *response_as_route() const {
    return response_type() == osrm::engine::api::fbresult::ServiceResponse_route ? static_cast<const osrm::engine::api::fbresult::Route *>(response()) : nullptr;
  }
  const osrm::engine::api::fbresult::Table *response_as_table() const {
    return response_type() == osrm::engine::api::fbresult::ServiceResponse_table ? static_cast<const osrm::engine::api::fbresult::Table *>(response()) : nullptr;
  }
  const osrm::engine::api::fbresult::Trip *response_as_trip() const {
    return response_type() == osrm::engine::api::fbresult::ServiceResponse_trip ? static_cast<const osrm::engine::api::fbresult::Trip *>(response()) : nullptr;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CODE) &&
           verifier.VerifyString(code()) &&
           VerifyOffset(verifier, VT_MESSAGE) &&
           verifier.VerifyString(message()) &&
           VerifyField<uint8_t>(verifier, VT_RESPONSE_TYPE) &&
           VerifyOffset(verifier, VT_RESPONSE) &&
           VerifyServiceResponse(verifier, response(), response_type()) &&
           verifier.EndTable();
  }
  FBResultT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(FBResultT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<FBResult> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FBResultT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

template<> inline const osrm::engine::api::fbresult::Match *FBResult::response_as<osrm::engine::api::fbresult::Match>() const {
  return response_as_match();
}

template<> inline const osrm::engine::api::fbresult::Nearest *FBResult::response_as<osrm::engine::api::fbresult::Nearest>() const {
  return response_as_nearest();
}

template<> inline const osrm::engine::api::fbresult::Route *FBResult::response_as<osrm::engine::api::fbresult::Route>() const {
  return response_as_route();
}

template<> inline const osrm::engine::api::fbresult::Table *FBResult::response_as<osrm::engine::api::fbresult::Table>() const {
  return response_as_table();
}

template<> inline const osrm::engine::api::fbresult::Trip *FBResult::response_as<osrm::engine::api::fbresult::Trip>() const {
  return response_as_trip();
}

struct FBResultBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_code(flatbuffers::Offset<flatbuffers::String> code) {
    fbb_.AddOffset(FBResult::VT_CODE, code);
  }
  void add_message(flatbuffers::Offset<flatbuffers::String> message) {
    fbb_.AddOffset(FBResult::VT_MESSAGE, message);
  }
  void add_response_type(osrm::engine::api::fbresult::ServiceResponse response_type) {
    fbb_.AddElement<uint8_t>(FBResult::VT_RESPONSE_TYPE, static_cast<uint8_t>(response_type), 0);
  }
  void add_response(flatbuffers::Offset<void> response) {
    fbb_.AddOffset(FBResult::VT_RESPONSE, response);
  }
  explicit FBResultBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  FBResultBuilder &operator=(const FBResultBuilder &);
  flatbuffers::Offset<FBResult> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<FBResult>(end);
    return o;
  }
};

inline flatbuffers::Offset<FBResult> CreateFBResult(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> code = 0,
    flatbuffers::Offset<flatbuffers::String> message = 0,
    osrm::engine::api::fbresult::ServiceResponse response_type = osrm::engine::api::fbresult::ServiceResponse_NONE,
    flatbuffers::Offset<void> response = 0) {
  FBResultBuilder builder_(_fbb);
  builder_.add_response(response);
  builder_.add_message(message);
  builder_.add_code(code);
  builder_.add_response_type(response_type);
  return builder_.Finish();
}

inline flatbuffers::Offset<FBResult> CreateFBResultDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *code = nullptr,
    const char *message = nullptr,
    osrm::engine::api::fbresult::ServiceResponse response_type = osrm::engine::api::fbresult::ServiceResponse_NONE,
    flatbuffers::Offset<void> response = 0) {
  auto code__ = code ? _fbb.CreateString(code) : 0;
  auto message__ = message ? _fbb.CreateString(message) : 0;
  return osrm::engine::api::fbresult::CreateFBResult(
      _fbb,
      code__,
      message__,
      response_type,
      response);
}

flatbuffers::Offset<FBResult> CreateFBResult(flatbuffers::FlatBufferBuilder &_fbb, const FBResultT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

inline PositionT *Position::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PositionT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Position::UnPackTo(PositionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = longitute(); _o->longitute = _e; };
  { auto _e = latitude(); _o->latitude = _e; };
}

inline flatbuffers::Offset<Position> Position::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PositionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePosition(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Position> CreatePosition(flatbuffers::FlatBufferBuilder &_fbb, const PositionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PositionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _longitute = _o->longitute;
  auto _latitude = _o->latitude;
  return osrm::engine::api::fbresult::CreatePosition(
      _fbb,
      _longitute,
      _latitude);
}

inline WaypointT *Waypoint::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new WaypointT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Waypoint::UnPackTo(WaypointT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = hint(); if (_e) _o->hint = _e->str(); };
  { auto _e = distance(); _o->distance = _e; };
  { auto _e = name(); if (_e) _o->name = _e->str(); };
  { auto _e = location(); if (_e) _o->location = std::unique_ptr<osrm::engine::api::fbresult::PositionT>(_e->UnPack(_resolver)); };
  { auto _e = nodes(); if (_e) { _o->nodes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->nodes[_i] = _e->Get(_i); } } };
  { auto _e = matchings_index(); _o->matchings_index = _e; };
  { auto _e = waypoint_index(); _o->waypoint_index = _e; };
  { auto _e = alternatives_count(); _o->alternatives_count = _e; };
  { auto _e = trips_index(); _o->trips_index = _e; };
}

inline flatbuffers::Offset<Waypoint> Waypoint::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WaypointT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateWaypoint(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Waypoint> CreateWaypoint(flatbuffers::FlatBufferBuilder &_fbb, const WaypointT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WaypointT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _hint = _o->hint.empty() ? 0 : _fbb.CreateString(_o->hint);
  auto _distance = _o->distance;
  auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
  auto _location = _o->location ? CreatePosition(_fbb, _o->location.get(), _rehasher) : 0;
  auto _nodes = _o->nodes.size() ? _fbb.CreateVector(_o->nodes) : 0;
  auto _matchings_index = _o->matchings_index;
  auto _waypoint_index = _o->waypoint_index;
  auto _alternatives_count = _o->alternatives_count;
  auto _trips_index = _o->trips_index;
  return osrm::engine::api::fbresult::CreateWaypoint(
      _fbb,
      _hint,
      _distance,
      _name,
      _location,
      _nodes,
      _matchings_index,
      _waypoint_index,
      _alternatives_count,
      _trips_index);
}

inline MetadataT *Metadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new MetadataT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Metadata::UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = datasource_names(); if (_e) { _o->datasource_names.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->datasource_names[_i] = _e->Get(_i)->str(); } } };
}

inline flatbuffers::Offset<Metadata> Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateMetadata(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _datasource_names = _o->datasource_names.size() ? _fbb.CreateVectorOfStrings(_o->datasource_names) : 0;
  return osrm::engine::api::fbresult::CreateMetadata(
      _fbb,
      _datasource_names);
}

inline AnnotationT *Annotation::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new AnnotationT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Annotation::UnPackTo(AnnotationT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = distance(); if (_e) { _o->distance.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->distance[_i] = _e->Get(_i); } } };
  { auto _e = duration(); if (_e) { _o->duration.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->duration[_i] = _e->Get(_i); } } };
  { auto _e = datasources(); if (_e) { _o->datasources.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->datasources[_i] = _e->Get(_i); } } };
  { auto _e = nodes(); if (_e) { _o->nodes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->nodes[_i] = _e->Get(_i); } } };
  { auto _e = weight(); if (_e) { _o->weight.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->weight[_i] = _e->Get(_i); } } };
  { auto _e = speed(); if (_e) { _o->speed.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->speed[_i] = _e->Get(_i); } } };
  { auto _e = metadata(); if (_e) _o->metadata = std::unique_ptr<osrm::engine::api::fbresult::MetadataT>(_e->UnPack(_resolver)); };
}

inline flatbuffers::Offset<Annotation> Annotation::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateAnnotation(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Annotation> CreateAnnotation(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AnnotationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _distance = _o->distance.size() ? _fbb.CreateVector(_o->distance) : 0;
  auto _duration = _o->duration.size() ? _fbb.CreateVector(_o->duration) : 0;
  auto _datasources = _o->datasources.size() ? _fbb.CreateVector(_o->datasources) : 0;
  auto _nodes = _o->nodes.size() ? _fbb.CreateVector(_o->nodes) : 0;
  auto _weight = _o->weight.size() ? _fbb.CreateVector(_o->weight) : 0;
  auto _speed = _o->speed.size() ? _fbb.CreateVector(_o->speed) : 0;
  auto _metadata = _o->metadata ? CreateMetadata(_fbb, _o->metadata.get(), _rehasher) : 0;
  return osrm::engine::api::fbresult::CreateAnnotation(
      _fbb,
      _distance,
      _duration,
      _datasources,
      _nodes,
      _weight,
      _speed,
      _metadata);
}

inline StepManeuverT *StepManeuver::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new StepManeuverT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void StepManeuver::UnPackTo(StepManeuverT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = location(); if (_e) _o->location = std::unique_ptr<osrm::engine::api::fbresult::PositionT>(_e->UnPack(_resolver)); };
  { auto _e = bearing_before(); _o->bearing_before = _e; };
  { auto _e = bearing_after(); _o->bearing_after = _e; };
  { auto _e = type(); _o->type = _e; };
  { auto _e = modifier(); _o->modifier = _e; };
  { auto _e = exit(); _o->exit = _e; };
}

inline flatbuffers::Offset<StepManeuver> StepManeuver::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StepManeuverT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateStepManeuver(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<StepManeuver> CreateStepManeuver(flatbuffers::FlatBufferBuilder &_fbb, const StepManeuverT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StepManeuverT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _location = _o->location ? CreatePosition(_fbb, _o->location.get(), _rehasher) : 0;
  auto _bearing_before = _o->bearing_before;
  auto _bearing_after = _o->bearing_after;
  auto _type = _o->type;
  auto _modifier = _o->modifier;
  auto _exit = _o->exit;
  return osrm::engine::api::fbresult::CreateStepManeuver(
      _fbb,
      _location,
      _bearing_before,
      _bearing_after,
      _type,
      _modifier,
      _exit);
}

inline LaneT *Lane::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new LaneT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Lane::UnPackTo(LaneT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = indications(); if (_e) { _o->indications.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->indications[_i] = static_cast<osrm::engine::api::fbresult::Turn>(_e->Get(_i)); } } };
  { auto _e = valid(); _o->valid = _e; };
}

inline flatbuffers::Offset<Lane> Lane::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LaneT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateLane(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Lane> CreateLane(flatbuffers::FlatBufferBuilder &_fbb, const LaneT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LaneT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _indications = _o->indications.size() ? _fbb.CreateVectorScalarCast<int8_t>(flatbuffers::data(_o->indications), _o->indications.size()) : 0;
  auto _valid = _o->valid;
  return osrm::engine::api::fbresult::CreateLane(
      _fbb,
      _indications,
      _valid);
}

inline IntersectionT *Intersection::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new IntersectionT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Intersection::UnPackTo(IntersectionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = location(); if (_e) _o->location = std::unique_ptr<osrm::engine::api::fbresult::PositionT>(_e->UnPack(_resolver)); };
  { auto _e = bearings(); if (_e) { _o->bearings.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->bearings[_i] = _e->Get(_i); } } };
  { auto _e = classes(); if (_e) { _o->classes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->classes[_i] = _e->Get(_i)->str(); } } };
  { auto _e = entry(); if (_e) { _o->entry.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->entry[_i] = _e->Get(_i) != 0; } } };
  { auto _e = in(); _o->in = _e; };
  { auto _e = out(); _o->out = _e; };
  { auto _e = lanes(); if (_e) { _o->lanes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lanes[_i] = std::unique_ptr<osrm::engine::api::fbresult::LaneT>(_e->Get(_i)->UnPack(_resolver)); } } };
}

inline flatbuffers::Offset<Intersection> Intersection::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IntersectionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateIntersection(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Intersection> CreateIntersection(flatbuffers::FlatBufferBuilder &_fbb, const IntersectionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const IntersectionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _location = _o->location ? CreatePosition(_fbb, _o->location.get(), _rehasher) : 0;
  auto _bearings = _o->bearings.size() ? _fbb.CreateVector(_o->bearings) : 0;
  auto _classes = _o->classes.size() ? _fbb.CreateVectorOfStrings(_o->classes) : 0;
  auto _entry = _o->entry.size() ? _fbb.CreateVector(_o->entry) : 0;
  auto _in = _o->in;
  auto _out = _o->out;
  auto _lanes = _o->lanes.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>> (_o->lanes.size(), [](size_t i, _VectorArgs *__va) { return CreateLane(*__va->__fbb, __va->__o->lanes[i].get(), __va->__rehasher); }, &_va ) : 0;
  return osrm::engine::api::fbresult::CreateIntersection(
      _fbb,
      _location,
      _bearings,
      _classes,
      _entry,
      _in,
      _out,
      _lanes);
}

inline PolylineT *Polyline::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PolylineT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Polyline::UnPackTo(PolylineT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = polyline(); if (_e) { _o->polyline.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->polyline[_i] = std::unique_ptr<osrm::engine::api::fbresult::PositionT>(_e->Get(_i)->UnPack(_resolver)); } } };
}

inline flatbuffers::Offset<Polyline> Polyline::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PolylineT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePolyline(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Polyline> CreatePolyline(flatbuffers::FlatBufferBuilder &_fbb, const PolylineT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PolylineT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _polyline = _o->polyline.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>> (_o->polyline.size(), [](size_t i, _VectorArgs *__va) { return CreatePosition(*__va->__fbb, __va->__o->polyline[i].get(), __va->__rehasher); }, &_va ) : 0;
  return osrm::engine::api::fbresult::CreatePolyline(
      _fbb,
      _polyline);
}

inline StepT *Step::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new StepT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Step::UnPackTo(StepT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = distance(); _o->distance = _e; };
  { auto _e = duration(); _o->duration = _e; };
  { auto _e = geometry_type(); _o->geometry.type = _e; };
  { auto _e = geometry(); if (_e) _o->geometry.value = GeometryUnion::UnPack(_e, geometry_type(), _resolver); };
  { auto _e = name(); if (_e) _o->name = _e->str(); };
  { auto _e = ref(); _o->ref = _e; };
  { auto _e = pronunciation(); if (_e) _o->pronunciation = _e->str(); };
  { auto _e = destinations(); if (_e) { _o->destinations.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->destinations[_i] = _e->Get(_i)->str(); } } };
  { auto _e = exits(); if (_e) { _o->exits.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->exits[_i] = _e->Get(_i)->str(); } } };
  { auto _e = mode(); if (_e) _o->mode = _e->str(); };
  { auto _e = maneuver(); if (_e) _o->maneuver = std::unique_ptr<osrm::engine::api::fbresult::StepManeuverT>(_e->UnPack(_resolver)); };
  { auto _e = intersections(); if (_e) { _o->intersections.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->intersections[_i] = std::unique_ptr<osrm::engine::api::fbresult::IntersectionT>(_e->Get(_i)->UnPack(_resolver)); } } };
  { auto _e = rotary_name(); if (_e) _o->rotary_name = _e->str(); };
  { auto _e = rotary_pronunciation(); if (_e) _o->rotary_pronunciation = _e->str(); };
  { auto _e = driving_side(); _o->driving_side = _e; };
}

inline flatbuffers::Offset<Step> Step::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StepT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateStep(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Step> CreateStep(flatbuffers::FlatBufferBuilder &_fbb, const StepT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StepT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _distance = _o->distance;
  auto _duration = _o->duration;
  auto _geometry_type = _o->geometry.type;
  auto _geometry = _o->geometry.Pack(_fbb);
  auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
  auto _ref = _o->ref;
  auto _pronunciation = _o->pronunciation.empty() ? 0 : _fbb.CreateString(_o->pronunciation);
  auto _destinations = _o->destinations.size() ? _fbb.CreateVectorOfStrings(_o->destinations) : 0;
  auto _exits = _o->exits.size() ? _fbb.CreateVectorOfStrings(_o->exits) : 0;
  auto _mode = _o->mode.empty() ? 0 : _fbb.CreateString(_o->mode);
  auto _maneuver = _o->maneuver ? CreateStepManeuver(_fbb, _o->maneuver.get(), _rehasher) : 0;
  auto _intersections = _o->intersections.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>> (_o->intersections.size(), [](size_t i, _VectorArgs *__va) { return CreateIntersection(*__va->__fbb, __va->__o->intersections[i].get(), __va->__rehasher); }, &_va ) : 0;
  auto _rotary_name = _o->rotary_name.empty() ? 0 : _fbb.CreateString(_o->rotary_name);
  auto _rotary_pronunciation = _o->rotary_pronunciation.empty() ? 0 : _fbb.CreateString(_o->rotary_pronunciation);
  auto _driving_side = _o->driving_side;
  return osrm::engine::api::fbresult::CreateStep(
      _fbb,
      _distance,
      _duration,
      _geometry_type,
      _geometry,
      _name,
      _ref,
      _pronunciation,
      _destinations,
      _exits,
      _mode,
      _maneuver,
      _intersections,
      _rotary_name,
      _rotary_pronunciation,
      _driving_side);
}

inline LegT *Leg::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new LegT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Leg::UnPackTo(LegT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = distance(); _o->distance = _e; };
  { auto _e = duration(); _o->duration = _e; };
  { auto _e = weight(); _o->weight = _e; };
  { auto _e = summary(); if (_e) _o->summary = _e->str(); };
  { auto _e = annotations(); if (_e) _o->annotations = std::unique_ptr<osrm::engine::api::fbresult::AnnotationT>(_e->UnPack(_resolver)); };
  { auto _e = steps(); if (_e) { _o->steps.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->steps[_i] = std::unique_ptr<osrm::engine::api::fbresult::StepT>(_e->Get(_i)->UnPack(_resolver)); } } };
}

inline flatbuffers::Offset<Leg> Leg::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LegT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateLeg(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Leg> CreateLeg(flatbuffers::FlatBufferBuilder &_fbb, const LegT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LegT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _distance = _o->distance;
  auto _duration = _o->duration;
  auto _weight = _o->weight;
  auto _summary = _o->summary.empty() ? 0 : _fbb.CreateString(_o->summary);
  auto _annotations = _o->annotations ? CreateAnnotation(_fbb, _o->annotations.get(), _rehasher) : 0;
  auto _steps = _o->steps.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>> (_o->steps.size(), [](size_t i, _VectorArgs *__va) { return CreateStep(*__va->__fbb, __va->__o->steps[i].get(), __va->__rehasher); }, &_va ) : 0;
  return osrm::engine::api::fbresult::CreateLeg(
      _fbb,
      _distance,
      _duration,
      _weight,
      _summary,
      _annotations,
      _steps);
}

inline RouteObjectT *RouteObject::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new RouteObjectT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void RouteObject::UnPackTo(RouteObjectT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = distance(); _o->distance = _e; };
  { auto _e = duration(); _o->duration = _e; };
  { auto _e = weight(); _o->weight = _e; };
  { auto _e = weight_name(); if (_e) _o->weight_name = _e->str(); };
  { auto _e = confidence(); _o->confidence = _e; };
  { auto _e = geometry_type(); _o->geometry.type = _e; };
  { auto _e = geometry(); if (_e) _o->geometry.value = GeometryUnion::UnPack(_e, geometry_type(), _resolver); };
  { auto _e = legs(); if (_e) { _o->legs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->legs[_i] = std::unique_ptr<osrm::engine::api::fbresult::LegT>(_e->Get(_i)->UnPack(_resolver)); } } };
}

inline flatbuffers::Offset<RouteObject> RouteObject::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RouteObjectT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateRouteObject(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<RouteObject> CreateRouteObject(flatbuffers::FlatBufferBuilder &_fbb, const RouteObjectT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RouteObjectT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _distance = _o->distance;
  auto _duration = _o->duration;
  auto _weight = _o->weight;
  auto _weight_name = _o->weight_name.empty() ? 0 : _fbb.CreateString(_o->weight_name);
  auto _confidence = _o->confidence;
  auto _geometry_type = _o->geometry.type;
  auto _geometry = _o->geometry.Pack(_fbb);
  auto _legs = _o->legs.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>> (_o->legs.size(), [](size_t i, _VectorArgs *__va) { return CreateLeg(*__va->__fbb, __va->__o->legs[i].get(), __va->__rehasher); }, &_va ) : 0;
  return osrm::engine::api::fbresult::CreateRouteObject(
      _fbb,
      _distance,
      _duration,
      _weight,
      _weight_name,
      _confidence,
      _geometry_type,
      _geometry,
      _legs);
}

inline RouteT *Route::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new RouteT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Route::UnPackTo(RouteT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = routes(); if (_e) { _o->routes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->routes[_i] = std::unique_ptr<osrm::engine::api::fbresult::RouteObjectT>(_e->Get(_i)->UnPack(_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)); } } };
}

inline flatbuffers::Offset<Route> Route::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RouteT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateRoute(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Route> CreateRoute(flatbuffers::FlatBufferBuilder &_fbb, const RouteT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RouteT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _routes = _o->routes.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> (_o->routes.size(), [](size_t i, _VectorArgs *__va) { return CreateRouteObject(*__va->__fbb, __va->__o->routes[i].get(), __va->__rehasher); }, &_va ) : 0;
  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;
  return osrm::engine::api::fbresult::CreateRoute(
      _fbb,
      _routes,
      _waypoints);
}

inline MatchT *Match::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new MatchT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Match::UnPackTo(MatchT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = tracepoints(); if (_e) { _o->tracepoints.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->tracepoints[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
  { auto _e = matchings(); if (_e) { _o->matchings.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->matchings[_i] = std::unique_ptr<osrm::engine::api::fbresult::RouteT>(_e->Get(_i)->UnPack(_resolver)); } } };
}

inline flatbuffers::Offset<Match> Match::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatchT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateMatch(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Match> CreateMatch(flatbuffers::FlatBufferBuilder &_fbb, const MatchT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatchT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _tracepoints = _o->tracepoints.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->tracepoints.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->tracepoints[i].get(), __va->__rehasher); }, &_va ) : 0;
  auto _matchings = _o->matchings.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> (_o->matchings.size(), [](size_t i, _VectorArgs *__va) { return CreateRoute(*__va->__fbb, __va->__o->matchings[i].get(), __va->__rehasher); }, &_va ) : 0;
  return osrm::engine::api::fbresult::CreateMatch(
      _fbb,
      _tracepoints,
      _matchings);
}

inline NearestT *Nearest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new NearestT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Nearest::UnPackTo(NearestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (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)); } } };
}

inline flatbuffers::Offset<Nearest> Nearest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NearestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateNearest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Nearest> CreateNearest(flatbuffers::FlatBufferBuilder &_fbb, const NearestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NearestT* __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;
  return osrm::engine::api::fbresult::CreateNearest(
      _fbb,
      _waypoints);
}

inline VectorDoubleT *VectorDouble::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new VectorDoubleT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void VectorDouble::UnPackTo(VectorDoubleT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = column(); if (_e) { _o->column.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->column[_i] = _e->Get(_i); } } };
}

inline flatbuffers::Offset<VectorDouble> VectorDouble::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VectorDoubleT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateVectorDouble(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<VectorDouble> CreateVectorDouble(flatbuffers::FlatBufferBuilder &_fbb, const VectorDoubleT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const VectorDoubleT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _column = _o->column.size() ? _fbb.CreateVector(_o->column) : 0;
  return osrm::engine::api::fbresult::CreateVectorDouble(
      _fbb,
      _column);
}

inline TableT *Table::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new TableT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Table::UnPackTo(TableT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (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 = durations(); if (_e) { _o->durations.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->durations[_i] = std::unique_ptr<osrm::engine::api::fbresult::VectorDoubleT>(_e->Get(_i)->UnPack(_resolver)); } } };
  { auto _e = distances(); if (_e) { _o->distances.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->distances[_i] = std::unique_ptr<osrm::engine::api::fbresult::VectorDoubleT>(_e->Get(_i)->UnPack(_resolver)); } } };
  { auto _e = sources(); if (_e) { _o->sources.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->sources[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
  { auto _e = destinations(); if (_e) { _o->destinations.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->destinations[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
  { auto _e = fallback_speed_cells(); if (_e) { _o->fallback_speed_cells.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->fallback_speed_cells[_i] = std::unique_ptr<osrm::engine::api::fbresult::VectorDoubleT>(_e->Get(_i)->UnPack(_resolver)); } } };
}

inline flatbuffers::Offset<Table> Table::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateTable(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Table> CreateTable(flatbuffers::FlatBufferBuilder &_fbb, const TableT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableT* __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 _durations = _o->durations.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> (_o->durations.size(), [](size_t i, _VectorArgs *__va) { return CreateVectorDouble(*__va->__fbb, __va->__o->durations[i].get(), __va->__rehasher); }, &_va ) : 0;
  auto _distances = _o->distances.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> (_o->distances.size(), [](size_t i, _VectorArgs *__va) { return CreateVectorDouble(*__va->__fbb, __va->__o->distances[i].get(), __va->__rehasher); }, &_va ) : 0;
  auto _sources = _o->sources.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->sources.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->sources[i].get(), __va->__rehasher); }, &_va ) : 0;
  auto _destinations = _o->destinations.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->destinations.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->destinations[i].get(), __va->__rehasher); }, &_va ) : 0;
  auto _fallback_speed_cells = _o->fallback_speed_cells.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorDouble>> (_o->fallback_speed_cells.size(), [](size_t i, _VectorArgs *__va) { return CreateVectorDouble(*__va->__fbb, __va->__o->fallback_speed_cells[i].get(), __va->__rehasher); }, &_va ) : 0;
  return osrm::engine::api::fbresult::CreateTable(
      _fbb,
      _waypoints,
      _durations,
      _distances,
      _sources,
      _destinations,
      _fallback_speed_cells);
}

inline TripT *Trip::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new TripT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Trip::UnPackTo(TripT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (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)); } } };
}

inline flatbuffers::Offset<Trip> Trip::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TripT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateTrip(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Trip> CreateTrip(flatbuffers::FlatBufferBuilder &_fbb, const TripT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (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;
  return osrm::engine::api::fbresult::CreateTrip(
      _fbb,
      _waypoints,
      _trips);
}

inline FBResultT *FBResult::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new FBResultT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void FBResult::UnPackTo(FBResultT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = code(); if (_e) _o->code = _e->str(); };
  { auto _e = message(); if (_e) _o->message = _e->str(); };
  { auto _e = response_type(); _o->response.type = _e; };
  { auto _e = response(); if (_e) _o->response.value = ServiceResponseUnion::UnPack(_e, response_type(), _resolver); };
}

inline flatbuffers::Offset<FBResult> FBResult::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FBResultT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateFBResult(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<FBResult> CreateFBResult(flatbuffers::FlatBufferBuilder &_fbb, const FBResultT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FBResultT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _code = _o->code.empty() ? 0 : _fbb.CreateString(_o->code);
  auto _message = _o->message.empty() ? 0 : _fbb.CreateString(_o->message);
  auto _response_type = _o->response.type;
  auto _response = _o->response.Pack(_fbb);
  return osrm::engine::api::fbresult::CreateFBResult(
      _fbb,
      _code,
      _message,
      _response_type,
      _response);
}

inline bool VerifyGeometry(flatbuffers::Verifier &verifier, const void *obj, Geometry type) {
  switch (type) {
    case Geometry_NONE: {
      return true;
    }
    case Geometry_polyline: {
      auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
      return verifier.VerifyString(ptr);
    }
    case Geometry_polyline6: {
      auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
      return verifier.VerifyString(ptr);
    }
    case Geometry_coordinates: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Polyline *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return false;
  }
}

inline bool VerifyGeometryVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyGeometry(
        verifier,  values->Get(i), types->GetEnum<Geometry>(i))) {
      return false;
    }
  }
  return true;
}

inline void *GeometryUnion::UnPack(const void *obj, Geometry type, const flatbuffers::resolver_function_t *resolver) {
  switch (type) {
    case Geometry_polyline: {
      auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
      return new std::string(ptr->c_str(), ptr->size());
    }
    case Geometry_polyline6: {
      auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
      return new std::string(ptr->c_str(), ptr->size());
    }
    case Geometry_coordinates: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Polyline *>(obj);
      return ptr->UnPack(resolver);
    }
    default: return nullptr;
  }
}

inline flatbuffers::Offset<void> GeometryUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
  switch (type) {
    case Geometry_polyline: {
      auto ptr = reinterpret_cast<const std::string *>(value);
      return _fbb.CreateString(*ptr).Union();
    }
    case Geometry_polyline6: {
      auto ptr = reinterpret_cast<const std::string *>(value);
      return _fbb.CreateString(*ptr).Union();
    }
    case Geometry_coordinates: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::PolylineT *>(value);
      return CreatePolyline(_fbb, ptr, _rehasher).Union();
    }
    default: return 0;
  }
}

inline GeometryUnion::GeometryUnion(const GeometryUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
  switch (type) {
    case Geometry_polyline: {
      value = new std::string(*reinterpret_cast<std::string *>(u.value));
      break;
    }
    case Geometry_polyline6: {
      value = new std::string(*reinterpret_cast<std::string *>(u.value));
      break;
    }
    case Geometry_coordinates: {
      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::PolylineT not copyable.
      break;
    }
    default:
      break;
  }
}

inline void GeometryUnion::Reset() {
  switch (type) {
    case Geometry_polyline: {
      auto ptr = reinterpret_cast<std::string *>(value);
      delete ptr;
      break;
    }
    case Geometry_polyline6: {
      auto ptr = reinterpret_cast<std::string *>(value);
      delete ptr;
      break;
    }
    case Geometry_coordinates: {
      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::PolylineT *>(value);
      delete ptr;
      break;
    }
    default: break;
  }
  value = nullptr;
  type = Geometry_NONE;
}

inline bool VerifyServiceResponse(flatbuffers::Verifier &verifier, const void *obj, ServiceResponse type) {
  switch (type) {
    case ServiceResponse_NONE: {
      return true;
    }
    case ServiceResponse_match: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Match *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ServiceResponse_nearest: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Nearest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ServiceResponse_route: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Route *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ServiceResponse_table: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Table *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ServiceResponse_trip: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Trip *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return false;
  }
}

inline bool VerifyServiceResponseVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyServiceResponse(
        verifier,  values->Get(i), types->GetEnum<ServiceResponse>(i))) {
      return false;
    }
  }
  return true;
}

inline void *ServiceResponseUnion::UnPack(const void *obj, ServiceResponse type, const flatbuffers::resolver_function_t *resolver) {
  switch (type) {
    case ServiceResponse_match: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Match *>(obj);
      return ptr->UnPack(resolver);
    }
    case ServiceResponse_nearest: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Nearest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ServiceResponse_route: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Route *>(obj);
      return ptr->UnPack(resolver);
    }
    case ServiceResponse_table: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Table *>(obj);
      return ptr->UnPack(resolver);
    }
    case ServiceResponse_trip: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Trip *>(obj);
      return ptr->UnPack(resolver);
    }
    default: return nullptr;
  }
}

inline flatbuffers::Offset<void> ServiceResponseUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
  switch (type) {
    case ServiceResponse_match: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::MatchT *>(value);
      return CreateMatch(_fbb, ptr, _rehasher).Union();
    }
    case ServiceResponse_nearest: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::NearestT *>(value);
      return CreateNearest(_fbb, ptr, _rehasher).Union();
    }
    case ServiceResponse_route: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::RouteT *>(value);
      return CreateRoute(_fbb, ptr, _rehasher).Union();
    }
    case ServiceResponse_table: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::TableT *>(value);
      return CreateTable(_fbb, ptr, _rehasher).Union();
    }
    case ServiceResponse_trip: {
      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::TripT *>(value);
      return CreateTrip(_fbb, ptr, _rehasher).Union();
    }
    default: return 0;
  }
}

inline ServiceResponseUnion::ServiceResponseUnion(const ServiceResponseUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
  switch (type) {
    case ServiceResponse_match: {
      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::MatchT not copyable.
      break;
    }
    case ServiceResponse_nearest: {
      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::NearestT not copyable.
      break;
    }
    case ServiceResponse_route: {
      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::RouteT not copyable.
      break;
    }
    case ServiceResponse_table: {
      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::TableT not copyable.
      break;
    }
    case ServiceResponse_trip: {
      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::TripT not copyable.
      break;
    }
    default:
      break;
  }
}

inline void ServiceResponseUnion::Reset() {
  switch (type) {
    case ServiceResponse_match: {
      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::MatchT *>(value);
      delete ptr;
      break;
    }
    case ServiceResponse_nearest: {
      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::NearestT *>(value);
      delete ptr;
      break;
    }
    case ServiceResponse_route: {
      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::RouteT *>(value);
      delete ptr;
      break;
    }
    case ServiceResponse_table: {
      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::TableT *>(value);
      delete ptr;
      break;
    }
    case ServiceResponse_trip: {
      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::TripT *>(value);
      delete ptr;
      break;
    }
    default: break;
  }
  value = nullptr;
  type = ServiceResponse_NONE;
}

}  // namespace fbresult
}  // namespace api
}  // namespace engine
}  // namespace osrm

#endif  // FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_