CalculateRouteRequest.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/location/LocationServiceRequest.h>
#include <aws/location/LocationService_EXPORTS.h>
#include <aws/location/model/CalculateRouteCarModeOptions.h>
#include <aws/location/model/CalculateRouteTruckModeOptions.h>
#include <aws/location/model/DistanceUnit.h>
#include <aws/location/model/OptimizationMode.h>
#include <aws/location/model/TravelMode.h>
 
#include <utility>
 
namespace Aws {
namespace Http {
class URI;
}  // namespace Http
namespace LocationService {
namespace Model {
 
class CalculateRouteRequest : public LocationServiceRequest {
 public:
  AWS_LOCATIONSERVICE_API CalculateRouteRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "CalculateRoute"; }
 
  AWS_LOCATIONSERVICE_API Aws::String SerializePayload() const override;
 
  AWS_LOCATIONSERVICE_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
 
 
  inline const Aws::String& GetCalculatorName() const { return m_calculatorName; }
  inline bool CalculatorNameHasBeenSet() const { return m_calculatorNameHasBeenSet; }
  template <typename CalculatorNameT = Aws::String>
  void SetCalculatorName(CalculatorNameT&& value) {
    m_calculatorNameHasBeenSet = true;
    m_calculatorName = std::forward<CalculatorNameT>(value);
  }
  template <typename CalculatorNameT = Aws::String>
  CalculateRouteRequest& WithCalculatorName(CalculatorNameT&& value) {
    SetCalculatorName(std::forward<CalculatorNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<double>& GetDeparturePosition() const { return m_departurePosition; }
  inline bool DeparturePositionHasBeenSet() const { return m_departurePositionHasBeenSet; }
  template <typename DeparturePositionT = Aws::Vector<double>>
  void SetDeparturePosition(DeparturePositionT&& value) {
    m_departurePositionHasBeenSet = true;
    m_departurePosition = std::forward<DeparturePositionT>(value);
  }
  template <typename DeparturePositionT = Aws::Vector<double>>
  CalculateRouteRequest& WithDeparturePosition(DeparturePositionT&& value) {
    SetDeparturePosition(std::forward<DeparturePositionT>(value));
    return *this;
  }
  inline CalculateRouteRequest& AddDeparturePosition(double value) {
    m_departurePositionHasBeenSet = true;
    m_departurePosition.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<double>& GetDestinationPosition() const { return m_destinationPosition; }
  inline bool DestinationPositionHasBeenSet() const { return m_destinationPositionHasBeenSet; }
  template <typename DestinationPositionT = Aws::Vector<double>>
  void SetDestinationPosition(DestinationPositionT&& value) {
    m_destinationPositionHasBeenSet = true;
    m_destinationPosition = std::forward<DestinationPositionT>(value);
  }
  template <typename DestinationPositionT = Aws::Vector<double>>
  CalculateRouteRequest& WithDestinationPosition(DestinationPositionT&& value) {
    SetDestinationPosition(std::forward<DestinationPositionT>(value));
    return *this;
  }
  inline CalculateRouteRequest& AddDestinationPosition(double value) {
    m_destinationPositionHasBeenSet = true;
    m_destinationPosition.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::Vector<double>>& GetWaypointPositions() const { return m_waypointPositions; }
  inline bool WaypointPositionsHasBeenSet() const { return m_waypointPositionsHasBeenSet; }
  template <typename WaypointPositionsT = Aws::Vector<Aws::Vector<double>>>
  void SetWaypointPositions(WaypointPositionsT&& value) {
    m_waypointPositionsHasBeenSet = true;
    m_waypointPositions = std::forward<WaypointPositionsT>(value);
  }
  template <typename WaypointPositionsT = Aws::Vector<Aws::Vector<double>>>
  CalculateRouteRequest& WithWaypointPositions(WaypointPositionsT&& value) {
    SetWaypointPositions(std::forward<WaypointPositionsT>(value));
    return *this;
  }
  template <typename WaypointPositionsT = Aws::Vector<double>>
  CalculateRouteRequest& AddWaypointPositions(WaypointPositionsT&& value) {
    m_waypointPositionsHasBeenSet = true;
    m_waypointPositions.emplace_back(std::forward<WaypointPositionsT>(value));
    return *this;
  }
 
 
  inline TravelMode GetTravelMode() const { return m_travelMode; }
  inline bool TravelModeHasBeenSet() const { return m_travelModeHasBeenSet; }
  inline void SetTravelMode(TravelMode value) {
    m_travelModeHasBeenSet = true;
    m_travelMode = value;
  }
  inline CalculateRouteRequest& WithTravelMode(TravelMode value) {
    SetTravelMode(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetDepartureTime() const { return m_departureTime; }
  inline bool DepartureTimeHasBeenSet() const { return m_departureTimeHasBeenSet; }
  template <typename DepartureTimeT = Aws::Utils::DateTime>
  void SetDepartureTime(DepartureTimeT&& value) {
    m_departureTimeHasBeenSet = true;
    m_departureTime = std::forward<DepartureTimeT>(value);
  }
  template <typename DepartureTimeT = Aws::Utils::DateTime>
  CalculateRouteRequest& WithDepartureTime(DepartureTimeT&& value) {
    SetDepartureTime(std::forward<DepartureTimeT>(value));
    return *this;
  }
 
 
  inline bool GetDepartNow() const { return m_departNow; }
  inline bool DepartNowHasBeenSet() const { return m_departNowHasBeenSet; }
  inline void SetDepartNow(bool value) {
    m_departNowHasBeenSet = true;
    m_departNow = value;
  }
  inline CalculateRouteRequest& WithDepartNow(bool value) {
    SetDepartNow(value);
    return *this;
  }
 
 
  inline DistanceUnit GetDistanceUnit() const { return m_distanceUnit; }
  inline bool DistanceUnitHasBeenSet() const { return m_distanceUnitHasBeenSet; }
  inline void SetDistanceUnit(DistanceUnit value) {
    m_distanceUnitHasBeenSet = true;
    m_distanceUnit = value;
  }
  inline CalculateRouteRequest& WithDistanceUnit(DistanceUnit value) {
    SetDistanceUnit(value);
    return *this;
  }
 
 
  inline bool GetIncludeLegGeometry() const { return m_includeLegGeometry; }
  inline bool IncludeLegGeometryHasBeenSet() const { return m_includeLegGeometryHasBeenSet; }
  inline void SetIncludeLegGeometry(bool value) {
    m_includeLegGeometryHasBeenSet = true;
    m_includeLegGeometry = value;
  }
  inline CalculateRouteRequest& WithIncludeLegGeometry(bool value) {
    SetIncludeLegGeometry(value);
    return *this;
  }
 
 
  inline const CalculateRouteCarModeOptions& GetCarModeOptions() const { return m_carModeOptions; }
  inline bool CarModeOptionsHasBeenSet() const { return m_carModeOptionsHasBeenSet; }
  template <typename CarModeOptionsT = CalculateRouteCarModeOptions>
  void SetCarModeOptions(CarModeOptionsT&& value) {
    m_carModeOptionsHasBeenSet = true;
    m_carModeOptions = std::forward<CarModeOptionsT>(value);
  }
  template <typename CarModeOptionsT = CalculateRouteCarModeOptions>
  CalculateRouteRequest& WithCarModeOptions(CarModeOptionsT&& value) {
    SetCarModeOptions(std::forward<CarModeOptionsT>(value));
    return *this;
  }
 
 
  inline const CalculateRouteTruckModeOptions& GetTruckModeOptions() const { return m_truckModeOptions; }
  inline bool TruckModeOptionsHasBeenSet() const { return m_truckModeOptionsHasBeenSet; }
  template <typename TruckModeOptionsT = CalculateRouteTruckModeOptions>
  void SetTruckModeOptions(TruckModeOptionsT&& value) {
    m_truckModeOptionsHasBeenSet = true;
    m_truckModeOptions = std::forward<TruckModeOptionsT>(value);
  }
  template <typename TruckModeOptionsT = CalculateRouteTruckModeOptions>
  CalculateRouteRequest& WithTruckModeOptions(TruckModeOptionsT&& value) {
    SetTruckModeOptions(std::forward<TruckModeOptionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetArrivalTime() const { return m_arrivalTime; }
  inline bool ArrivalTimeHasBeenSet() const { return m_arrivalTimeHasBeenSet; }
  template <typename ArrivalTimeT = Aws::Utils::DateTime>
  void SetArrivalTime(ArrivalTimeT&& value) {
    m_arrivalTimeHasBeenSet = true;
    m_arrivalTime = std::forward<ArrivalTimeT>(value);
  }
  template <typename ArrivalTimeT = Aws::Utils::DateTime>
  CalculateRouteRequest& WithArrivalTime(ArrivalTimeT&& value) {
    SetArrivalTime(std::forward<ArrivalTimeT>(value));
    return *this;
  }
 
 
  inline OptimizationMode GetOptimizeFor() const { return m_optimizeFor; }
  inline bool OptimizeForHasBeenSet() const { return m_optimizeForHasBeenSet; }
  inline void SetOptimizeFor(OptimizationMode value) {
    m_optimizeForHasBeenSet = true;
    m_optimizeFor = value;
  }
  inline CalculateRouteRequest& WithOptimizeFor(OptimizationMode value) {
    SetOptimizeFor(value);
    return *this;
  }
 
 
  inline const Aws::String& GetKey() const { return m_key; }
  inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
  template <typename KeyT = Aws::String>
  void SetKey(KeyT&& value) {
    m_keyHasBeenSet = true;
    m_key = std::forward<KeyT>(value);
  }
  template <typename KeyT = Aws::String>
  CalculateRouteRequest& WithKey(KeyT&& value) {
    SetKey(std::forward<KeyT>(value));
    return *this;
  }
 private:
  Aws::String m_calculatorName;
 
  Aws::Vector<double> m_departurePosition;
 
  Aws::Vector<double> m_destinationPosition;
 
  Aws::Vector<Aws::Vector<double>> m_waypointPositions;
 
  TravelMode m_travelMode{TravelMode::NOT_SET};
 
  Aws::Utils::DateTime m_departureTime{};
 
  bool m_departNow{false};
 
  DistanceUnit m_distanceUnit{DistanceUnit::NOT_SET};
 
  bool m_includeLegGeometry{false};
 
  CalculateRouteCarModeOptions m_carModeOptions;
 
  CalculateRouteTruckModeOptions m_truckModeOptions;
 
  Aws::Utils::DateTime m_arrivalTime{};
 
  OptimizationMode m_optimizeFor{OptimizationMode::NOT_SET};
 
  Aws::String m_key;
  bool m_calculatorNameHasBeenSet = false;
  bool m_departurePositionHasBeenSet = false;
  bool m_destinationPositionHasBeenSet = false;
  bool m_waypointPositionsHasBeenSet = false;
  bool m_travelModeHasBeenSet = false;
  bool m_departureTimeHasBeenSet = false;
  bool m_departNowHasBeenSet = false;
  bool m_distanceUnitHasBeenSet = false;
  bool m_includeLegGeometryHasBeenSet = false;
  bool m_carModeOptionsHasBeenSet = false;
  bool m_truckModeOptionsHasBeenSet = false;
  bool m_arrivalTimeHasBeenSet = false;
  bool m_optimizeForHasBeenSet = false;
  bool m_keyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace LocationService
}  // namespace Aws