RouteVehicleLegDetails.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/geo-routes/GeoRoutes_EXPORTS.h>
#include <aws/geo-routes/model/RoutePassThroughWaypoint.h>
#include <aws/geo-routes/model/RouteToll.h>
#include <aws/geo-routes/model/RouteTollSystem.h>
#include <aws/geo-routes/model/RouteVehicleAfterTravelStep.h>
#include <aws/geo-routes/model/RouteVehicleArrival.h>
#include <aws/geo-routes/model/RouteVehicleDeparture.h>
#include <aws/geo-routes/model/RouteVehicleIncident.h>
#include <aws/geo-routes/model/RouteVehicleNotice.h>
#include <aws/geo-routes/model/RouteVehicleSpan.h>
#include <aws/geo-routes/model/RouteVehicleSummary.h>
#include <aws/geo-routes/model/RouteVehicleTravelStep.h>
#include <aws/geo-routes/model/RouteZone.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GeoRoutes {
namespace Model {
 
class RouteVehicleLegDetails {
 public:
  AWS_GEOROUTES_API RouteVehicleLegDetails() = default;
  AWS_GEOROUTES_API RouteVehicleLegDetails(Aws::Utils::Json::JsonView jsonValue);
  AWS_GEOROUTES_API RouteVehicleLegDetails& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GEOROUTES_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<RouteVehicleAfterTravelStep>& GetAfterTravelSteps() const { return m_afterTravelSteps; }
  inline bool AfterTravelStepsHasBeenSet() const { return m_afterTravelStepsHasBeenSet; }
  template <typename AfterTravelStepsT = Aws::Vector<RouteVehicleAfterTravelStep>>
  void SetAfterTravelSteps(AfterTravelStepsT&& value) {
    m_afterTravelStepsHasBeenSet = true;
    m_afterTravelSteps = std::forward<AfterTravelStepsT>(value);
  }
  template <typename AfterTravelStepsT = Aws::Vector<RouteVehicleAfterTravelStep>>
  RouteVehicleLegDetails& WithAfterTravelSteps(AfterTravelStepsT&& value) {
    SetAfterTravelSteps(std::forward<AfterTravelStepsT>(value));
    return *this;
  }
  template <typename AfterTravelStepsT = RouteVehicleAfterTravelStep>
  RouteVehicleLegDetails& AddAfterTravelSteps(AfterTravelStepsT&& value) {
    m_afterTravelStepsHasBeenSet = true;
    m_afterTravelSteps.emplace_back(std::forward<AfterTravelStepsT>(value));
    return *this;
  }
 
 
  inline const RouteVehicleArrival& GetArrival() const { return m_arrival; }
  inline bool ArrivalHasBeenSet() const { return m_arrivalHasBeenSet; }
  template <typename ArrivalT = RouteVehicleArrival>
  void SetArrival(ArrivalT&& value) {
    m_arrivalHasBeenSet = true;
    m_arrival = std::forward<ArrivalT>(value);
  }
  template <typename ArrivalT = RouteVehicleArrival>
  RouteVehicleLegDetails& WithArrival(ArrivalT&& value) {
    SetArrival(std::forward<ArrivalT>(value));
    return *this;
  }
 
 
  inline const RouteVehicleDeparture& GetDeparture() const { return m_departure; }
  inline bool DepartureHasBeenSet() const { return m_departureHasBeenSet; }
  template <typename DepartureT = RouteVehicleDeparture>
  void SetDeparture(DepartureT&& value) {
    m_departureHasBeenSet = true;
    m_departure = std::forward<DepartureT>(value);
  }
  template <typename DepartureT = RouteVehicleDeparture>
  RouteVehicleLegDetails& WithDeparture(DepartureT&& value) {
    SetDeparture(std::forward<DepartureT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RouteVehicleIncident>& GetIncidents() const { return m_incidents; }
  inline bool IncidentsHasBeenSet() const { return m_incidentsHasBeenSet; }
  template <typename IncidentsT = Aws::Vector<RouteVehicleIncident>>
  void SetIncidents(IncidentsT&& value) {
    m_incidentsHasBeenSet = true;
    m_incidents = std::forward<IncidentsT>(value);
  }
  template <typename IncidentsT = Aws::Vector<RouteVehicleIncident>>
  RouteVehicleLegDetails& WithIncidents(IncidentsT&& value) {
    SetIncidents(std::forward<IncidentsT>(value));
    return *this;
  }
  template <typename IncidentsT = RouteVehicleIncident>
  RouteVehicleLegDetails& AddIncidents(IncidentsT&& value) {
    m_incidentsHasBeenSet = true;
    m_incidents.emplace_back(std::forward<IncidentsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RouteVehicleNotice>& GetNotices() const { return m_notices; }
  inline bool NoticesHasBeenSet() const { return m_noticesHasBeenSet; }
  template <typename NoticesT = Aws::Vector<RouteVehicleNotice>>
  void SetNotices(NoticesT&& value) {
    m_noticesHasBeenSet = true;
    m_notices = std::forward<NoticesT>(value);
  }
  template <typename NoticesT = Aws::Vector<RouteVehicleNotice>>
  RouteVehicleLegDetails& WithNotices(NoticesT&& value) {
    SetNotices(std::forward<NoticesT>(value));
    return *this;
  }
  template <typename NoticesT = RouteVehicleNotice>
  RouteVehicleLegDetails& AddNotices(NoticesT&& value) {
    m_noticesHasBeenSet = true;
    m_notices.emplace_back(std::forward<NoticesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RoutePassThroughWaypoint>& GetPassThroughWaypoints() const { return m_passThroughWaypoints; }
  inline bool PassThroughWaypointsHasBeenSet() const { return m_passThroughWaypointsHasBeenSet; }
  template <typename PassThroughWaypointsT = Aws::Vector<RoutePassThroughWaypoint>>
  void SetPassThroughWaypoints(PassThroughWaypointsT&& value) {
    m_passThroughWaypointsHasBeenSet = true;
    m_passThroughWaypoints = std::forward<PassThroughWaypointsT>(value);
  }
  template <typename PassThroughWaypointsT = Aws::Vector<RoutePassThroughWaypoint>>
  RouteVehicleLegDetails& WithPassThroughWaypoints(PassThroughWaypointsT&& value) {
    SetPassThroughWaypoints(std::forward<PassThroughWaypointsT>(value));
    return *this;
  }
  template <typename PassThroughWaypointsT = RoutePassThroughWaypoint>
  RouteVehicleLegDetails& AddPassThroughWaypoints(PassThroughWaypointsT&& value) {
    m_passThroughWaypointsHasBeenSet = true;
    m_passThroughWaypoints.emplace_back(std::forward<PassThroughWaypointsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RouteVehicleSpan>& GetSpans() const { return m_spans; }
  inline bool SpansHasBeenSet() const { return m_spansHasBeenSet; }
  template <typename SpansT = Aws::Vector<RouteVehicleSpan>>
  void SetSpans(SpansT&& value) {
    m_spansHasBeenSet = true;
    m_spans = std::forward<SpansT>(value);
  }
  template <typename SpansT = Aws::Vector<RouteVehicleSpan>>
  RouteVehicleLegDetails& WithSpans(SpansT&& value) {
    SetSpans(std::forward<SpansT>(value));
    return *this;
  }
  template <typename SpansT = RouteVehicleSpan>
  RouteVehicleLegDetails& AddSpans(SpansT&& value) {
    m_spansHasBeenSet = true;
    m_spans.emplace_back(std::forward<SpansT>(value));
    return *this;
  }
 
 
  inline const RouteVehicleSummary& GetSummary() const { return m_summary; }
  inline bool SummaryHasBeenSet() const { return m_summaryHasBeenSet; }
  template <typename SummaryT = RouteVehicleSummary>
  void SetSummary(SummaryT&& value) {
    m_summaryHasBeenSet = true;
    m_summary = std::forward<SummaryT>(value);
  }
  template <typename SummaryT = RouteVehicleSummary>
  RouteVehicleLegDetails& WithSummary(SummaryT&& value) {
    SetSummary(std::forward<SummaryT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RouteToll>& GetTolls() const { return m_tolls; }
  inline bool TollsHasBeenSet() const { return m_tollsHasBeenSet; }
  template <typename TollsT = Aws::Vector<RouteToll>>
  void SetTolls(TollsT&& value) {
    m_tollsHasBeenSet = true;
    m_tolls = std::forward<TollsT>(value);
  }
  template <typename TollsT = Aws::Vector<RouteToll>>
  RouteVehicleLegDetails& WithTolls(TollsT&& value) {
    SetTolls(std::forward<TollsT>(value));
    return *this;
  }
  template <typename TollsT = RouteToll>
  RouteVehicleLegDetails& AddTolls(TollsT&& value) {
    m_tollsHasBeenSet = true;
    m_tolls.emplace_back(std::forward<TollsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RouteTollSystem>& GetTollSystems() const { return m_tollSystems; }
  inline bool TollSystemsHasBeenSet() const { return m_tollSystemsHasBeenSet; }
  template <typename TollSystemsT = Aws::Vector<RouteTollSystem>>
  void SetTollSystems(TollSystemsT&& value) {
    m_tollSystemsHasBeenSet = true;
    m_tollSystems = std::forward<TollSystemsT>(value);
  }
  template <typename TollSystemsT = Aws::Vector<RouteTollSystem>>
  RouteVehicleLegDetails& WithTollSystems(TollSystemsT&& value) {
    SetTollSystems(std::forward<TollSystemsT>(value));
    return *this;
  }
  template <typename TollSystemsT = RouteTollSystem>
  RouteVehicleLegDetails& AddTollSystems(TollSystemsT&& value) {
    m_tollSystemsHasBeenSet = true;
    m_tollSystems.emplace_back(std::forward<TollSystemsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RouteVehicleTravelStep>& GetTravelSteps() const { return m_travelSteps; }
  inline bool TravelStepsHasBeenSet() const { return m_travelStepsHasBeenSet; }
  template <typename TravelStepsT = Aws::Vector<RouteVehicleTravelStep>>
  void SetTravelSteps(TravelStepsT&& value) {
    m_travelStepsHasBeenSet = true;
    m_travelSteps = std::forward<TravelStepsT>(value);
  }
  template <typename TravelStepsT = Aws::Vector<RouteVehicleTravelStep>>
  RouteVehicleLegDetails& WithTravelSteps(TravelStepsT&& value) {
    SetTravelSteps(std::forward<TravelStepsT>(value));
    return *this;
  }
  template <typename TravelStepsT = RouteVehicleTravelStep>
  RouteVehicleLegDetails& AddTravelSteps(TravelStepsT&& value) {
    m_travelStepsHasBeenSet = true;
    m_travelSteps.emplace_back(std::forward<TravelStepsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetTruckRoadTypes() const { return m_truckRoadTypes; }
  inline bool TruckRoadTypesHasBeenSet() const { return m_truckRoadTypesHasBeenSet; }
  template <typename TruckRoadTypesT = Aws::Vector<Aws::String>>
  void SetTruckRoadTypes(TruckRoadTypesT&& value) {
    m_truckRoadTypesHasBeenSet = true;
    m_truckRoadTypes = std::forward<TruckRoadTypesT>(value);
  }
  template <typename TruckRoadTypesT = Aws::Vector<Aws::String>>
  RouteVehicleLegDetails& WithTruckRoadTypes(TruckRoadTypesT&& value) {
    SetTruckRoadTypes(std::forward<TruckRoadTypesT>(value));
    return *this;
  }
  template <typename TruckRoadTypesT = Aws::String>
  RouteVehicleLegDetails& AddTruckRoadTypes(TruckRoadTypesT&& value) {
    m_truckRoadTypesHasBeenSet = true;
    m_truckRoadTypes.emplace_back(std::forward<TruckRoadTypesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RouteZone>& GetZones() const { return m_zones; }
  inline bool ZonesHasBeenSet() const { return m_zonesHasBeenSet; }
  template <typename ZonesT = Aws::Vector<RouteZone>>
  void SetZones(ZonesT&& value) {
    m_zonesHasBeenSet = true;
    m_zones = std::forward<ZonesT>(value);
  }
  template <typename ZonesT = Aws::Vector<RouteZone>>
  RouteVehicleLegDetails& WithZones(ZonesT&& value) {
    SetZones(std::forward<ZonesT>(value));
    return *this;
  }
  template <typename ZonesT = RouteZone>
  RouteVehicleLegDetails& AddZones(ZonesT&& value) {
    m_zonesHasBeenSet = true;
    m_zones.emplace_back(std::forward<ZonesT>(value));
    return *this;
  }
 private:
  Aws::Vector<RouteVehicleAfterTravelStep> m_afterTravelSteps;
 
  RouteVehicleArrival m_arrival;
 
  RouteVehicleDeparture m_departure;
 
  Aws::Vector<RouteVehicleIncident> m_incidents;
 
  Aws::Vector<RouteVehicleNotice> m_notices;
 
  Aws::Vector<RoutePassThroughWaypoint> m_passThroughWaypoints;
 
  Aws::Vector<RouteVehicleSpan> m_spans;
 
  RouteVehicleSummary m_summary;
 
  Aws::Vector<RouteToll> m_tolls;
 
  Aws::Vector<RouteTollSystem> m_tollSystems;
 
  Aws::Vector<RouteVehicleTravelStep> m_travelSteps;
 
  Aws::Vector<Aws::String> m_truckRoadTypes;
 
  Aws::Vector<RouteZone> m_zones;
  bool m_afterTravelStepsHasBeenSet = false;
  bool m_arrivalHasBeenSet = false;
  bool m_departureHasBeenSet = false;
  bool m_incidentsHasBeenSet = false;
  bool m_noticesHasBeenSet = false;
  bool m_passThroughWaypointsHasBeenSet = false;
  bool m_spansHasBeenSet = false;
  bool m_summaryHasBeenSet = false;
  bool m_tollsHasBeenSet = false;
  bool m_tollSystemsHasBeenSet = false;
  bool m_travelStepsHasBeenSet = false;
  bool m_truckRoadTypesHasBeenSet = false;
  bool m_zonesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GeoRoutes
}  // namespace Aws