CalculateRouteMatrixRequest.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/TravelMode.h>
 
#include <utility>
 
namespace Aws {
namespace Http {
class URI;
}  // namespace Http
namespace LocationService {
namespace Model {
 
class CalculateRouteMatrixRequest : public LocationServiceRequest {
 public:
  AWS_LOCATIONSERVICE_API CalculateRouteMatrixRequest() = 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 "CalculateRouteMatrix"; }
 
  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>
  CalculateRouteMatrixRequest& WithCalculatorName(CalculatorNameT&& value) {
    SetCalculatorName(std::forward<CalculatorNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::Vector<double>>& GetDeparturePositions() const { return m_departurePositions; }
  inline bool DeparturePositionsHasBeenSet() const { return m_departurePositionsHasBeenSet; }
  template <typename DeparturePositionsT = Aws::Vector<Aws::Vector<double>>>
  void SetDeparturePositions(DeparturePositionsT&& value) {
    m_departurePositionsHasBeenSet = true;
    m_departurePositions = std::forward<DeparturePositionsT>(value);
  }
  template <typename DeparturePositionsT = Aws::Vector<Aws::Vector<double>>>
  CalculateRouteMatrixRequest& WithDeparturePositions(DeparturePositionsT&& value) {
    SetDeparturePositions(std::forward<DeparturePositionsT>(value));
    return *this;
  }
  template <typename DeparturePositionsT = Aws::Vector<double>>
  CalculateRouteMatrixRequest& AddDeparturePositions(DeparturePositionsT&& value) {
    m_departurePositionsHasBeenSet = true;
    m_departurePositions.emplace_back(std::forward<DeparturePositionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::Vector<double>>& GetDestinationPositions() const { return m_destinationPositions; }
  inline bool DestinationPositionsHasBeenSet() const { return m_destinationPositionsHasBeenSet; }
  template <typename DestinationPositionsT = Aws::Vector<Aws::Vector<double>>>
  void SetDestinationPositions(DestinationPositionsT&& value) {
    m_destinationPositionsHasBeenSet = true;
    m_destinationPositions = std::forward<DestinationPositionsT>(value);
  }
  template <typename DestinationPositionsT = Aws::Vector<Aws::Vector<double>>>
  CalculateRouteMatrixRequest& WithDestinationPositions(DestinationPositionsT&& value) {
    SetDestinationPositions(std::forward<DestinationPositionsT>(value));
    return *this;
  }
  template <typename DestinationPositionsT = Aws::Vector<double>>
  CalculateRouteMatrixRequest& AddDestinationPositions(DestinationPositionsT&& value) {
    m_destinationPositionsHasBeenSet = true;
    m_destinationPositions.emplace_back(std::forward<DestinationPositionsT>(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 CalculateRouteMatrixRequest& 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>
  CalculateRouteMatrixRequest& 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 CalculateRouteMatrixRequest& 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 CalculateRouteMatrixRequest& WithDistanceUnit(DistanceUnit value) {
    SetDistanceUnit(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>
  CalculateRouteMatrixRequest& 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>
  CalculateRouteMatrixRequest& WithTruckModeOptions(TruckModeOptionsT&& value) {
    SetTruckModeOptions(std::forward<TruckModeOptionsT>(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>
  CalculateRouteMatrixRequest& WithKey(KeyT&& value) {
    SetKey(std::forward<KeyT>(value));
    return *this;
  }
 private:
  Aws::String m_calculatorName;
 
  Aws::Vector<Aws::Vector<double>> m_departurePositions;
 
  Aws::Vector<Aws::Vector<double>> m_destinationPositions;
 
  TravelMode m_travelMode{TravelMode::NOT_SET};
 
  Aws::Utils::DateTime m_departureTime{};
 
  bool m_departNow{false};
 
  DistanceUnit m_distanceUnit{DistanceUnit::NOT_SET};
 
  CalculateRouteCarModeOptions m_carModeOptions;
 
  CalculateRouteTruckModeOptions m_truckModeOptions;
 
  Aws::String m_key;
  bool m_calculatorNameHasBeenSet = false;
  bool m_departurePositionsHasBeenSet = false;
  bool m_destinationPositionsHasBeenSet = false;
  bool m_travelModeHasBeenSet = false;
  bool m_departureTimeHasBeenSet = false;
  bool m_departNowHasBeenSet = false;
  bool m_distanceUnitHasBeenSet = false;
  bool m_carModeOptionsHasBeenSet = false;
  bool m_truckModeOptionsHasBeenSet = false;
  bool m_keyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace LocationService
}  // namespace Aws