RouteViolatedConstraints.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/RouteHazardousCargoType.h>
#include <aws/geo-routes/model/RouteNoticeDetailRange.h>
#include <aws/geo-routes/model/RouteTruckType.h>
#include <aws/geo-routes/model/RouteWeightConstraint.h>
#include <aws/geo-routes/model/WeightPerAxleGroup.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GeoRoutes {
namespace Model {
 
class RouteViolatedConstraints {
 public:
  AWS_GEOROUTES_API RouteViolatedConstraints() = default;
  AWS_GEOROUTES_API RouteViolatedConstraints(Aws::Utils::Json::JsonView jsonValue);
  AWS_GEOROUTES_API RouteViolatedConstraints& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GEOROUTES_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline bool GetAllHazardsRestricted() const { return m_allHazardsRestricted; }
  inline bool AllHazardsRestrictedHasBeenSet() const { return m_allHazardsRestrictedHasBeenSet; }
  inline void SetAllHazardsRestricted(bool value) {
    m_allHazardsRestrictedHasBeenSet = true;
    m_allHazardsRestricted = value;
  }
  inline RouteViolatedConstraints& WithAllHazardsRestricted(bool value) {
    SetAllHazardsRestricted(value);
    return *this;
  }
 
 
  inline const RouteNoticeDetailRange& GetAxleCount() const { return m_axleCount; }
  inline bool AxleCountHasBeenSet() const { return m_axleCountHasBeenSet; }
  template <typename AxleCountT = RouteNoticeDetailRange>
  void SetAxleCount(AxleCountT&& value) {
    m_axleCountHasBeenSet = true;
    m_axleCount = std::forward<AxleCountT>(value);
  }
  template <typename AxleCountT = RouteNoticeDetailRange>
  RouteViolatedConstraints& WithAxleCount(AxleCountT&& value) {
    SetAxleCount(std::forward<AxleCountT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RouteHazardousCargoType>& GetHazardousCargos() const { return m_hazardousCargos; }
  inline bool HazardousCargosHasBeenSet() const { return m_hazardousCargosHasBeenSet; }
  template <typename HazardousCargosT = Aws::Vector<RouteHazardousCargoType>>
  void SetHazardousCargos(HazardousCargosT&& value) {
    m_hazardousCargosHasBeenSet = true;
    m_hazardousCargos = std::forward<HazardousCargosT>(value);
  }
  template <typename HazardousCargosT = Aws::Vector<RouteHazardousCargoType>>
  RouteViolatedConstraints& WithHazardousCargos(HazardousCargosT&& value) {
    SetHazardousCargos(std::forward<HazardousCargosT>(value));
    return *this;
  }
  inline RouteViolatedConstraints& AddHazardousCargos(RouteHazardousCargoType value) {
    m_hazardousCargosHasBeenSet = true;
    m_hazardousCargos.push_back(value);
    return *this;
  }
 
 
  inline long long GetMaxHeight() const { return m_maxHeight; }
  inline bool MaxHeightHasBeenSet() const { return m_maxHeightHasBeenSet; }
  inline void SetMaxHeight(long long value) {
    m_maxHeightHasBeenSet = true;
    m_maxHeight = value;
  }
  inline RouteViolatedConstraints& WithMaxHeight(long long value) {
    SetMaxHeight(value);
    return *this;
  }
 
 
  inline long long GetMaxKpraLength() const { return m_maxKpraLength; }
  inline bool MaxKpraLengthHasBeenSet() const { return m_maxKpraLengthHasBeenSet; }
  inline void SetMaxKpraLength(long long value) {
    m_maxKpraLengthHasBeenSet = true;
    m_maxKpraLength = value;
  }
  inline RouteViolatedConstraints& WithMaxKpraLength(long long value) {
    SetMaxKpraLength(value);
    return *this;
  }
 
 
  inline long long GetMaxLength() const { return m_maxLength; }
  inline bool MaxLengthHasBeenSet() const { return m_maxLengthHasBeenSet; }
  inline void SetMaxLength(long long value) {
    m_maxLengthHasBeenSet = true;
    m_maxLength = value;
  }
  inline RouteViolatedConstraints& WithMaxLength(long long value) {
    SetMaxLength(value);
    return *this;
  }
 
 
  inline long long GetMaxPayloadCapacity() const { return m_maxPayloadCapacity; }
  inline bool MaxPayloadCapacityHasBeenSet() const { return m_maxPayloadCapacityHasBeenSet; }
  inline void SetMaxPayloadCapacity(long long value) {
    m_maxPayloadCapacityHasBeenSet = true;
    m_maxPayloadCapacity = value;
  }
  inline RouteViolatedConstraints& WithMaxPayloadCapacity(long long value) {
    SetMaxPayloadCapacity(value);
    return *this;
  }
 
 
  inline const RouteWeightConstraint& GetMaxWeight() const { return m_maxWeight; }
  inline bool MaxWeightHasBeenSet() const { return m_maxWeightHasBeenSet; }
  template <typename MaxWeightT = RouteWeightConstraint>
  void SetMaxWeight(MaxWeightT&& value) {
    m_maxWeightHasBeenSet = true;
    m_maxWeight = std::forward<MaxWeightT>(value);
  }
  template <typename MaxWeightT = RouteWeightConstraint>
  RouteViolatedConstraints& WithMaxWeight(MaxWeightT&& value) {
    SetMaxWeight(std::forward<MaxWeightT>(value));
    return *this;
  }
 
 
  inline long long GetMaxWeightPerAxle() const { return m_maxWeightPerAxle; }
  inline bool MaxWeightPerAxleHasBeenSet() const { return m_maxWeightPerAxleHasBeenSet; }
  inline void SetMaxWeightPerAxle(long long value) {
    m_maxWeightPerAxleHasBeenSet = true;
    m_maxWeightPerAxle = value;
  }
  inline RouteViolatedConstraints& WithMaxWeightPerAxle(long long value) {
    SetMaxWeightPerAxle(value);
    return *this;
  }
 
 
  inline const WeightPerAxleGroup& GetMaxWeightPerAxleGroup() const { return m_maxWeightPerAxleGroup; }
  inline bool MaxWeightPerAxleGroupHasBeenSet() const { return m_maxWeightPerAxleGroupHasBeenSet; }
  template <typename MaxWeightPerAxleGroupT = WeightPerAxleGroup>
  void SetMaxWeightPerAxleGroup(MaxWeightPerAxleGroupT&& value) {
    m_maxWeightPerAxleGroupHasBeenSet = true;
    m_maxWeightPerAxleGroup = std::forward<MaxWeightPerAxleGroupT>(value);
  }
  template <typename MaxWeightPerAxleGroupT = WeightPerAxleGroup>
  RouteViolatedConstraints& WithMaxWeightPerAxleGroup(MaxWeightPerAxleGroupT&& value) {
    SetMaxWeightPerAxleGroup(std::forward<MaxWeightPerAxleGroupT>(value));
    return *this;
  }
 
 
  inline long long GetMaxWidth() const { return m_maxWidth; }
  inline bool MaxWidthHasBeenSet() const { return m_maxWidthHasBeenSet; }
  inline void SetMaxWidth(long long value) {
    m_maxWidthHasBeenSet = true;
    m_maxWidth = value;
  }
  inline RouteViolatedConstraints& WithMaxWidth(long long value) {
    SetMaxWidth(value);
    return *this;
  }
 
 
  inline const RouteNoticeDetailRange& GetOccupancy() const { return m_occupancy; }
  inline bool OccupancyHasBeenSet() const { return m_occupancyHasBeenSet; }
  template <typename OccupancyT = RouteNoticeDetailRange>
  void SetOccupancy(OccupancyT&& value) {
    m_occupancyHasBeenSet = true;
    m_occupancy = std::forward<OccupancyT>(value);
  }
  template <typename OccupancyT = RouteNoticeDetailRange>
  RouteViolatedConstraints& WithOccupancy(OccupancyT&& value) {
    SetOccupancy(std::forward<OccupancyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRestrictedTimes() const { return m_restrictedTimes; }
  inline bool RestrictedTimesHasBeenSet() const { return m_restrictedTimesHasBeenSet; }
  template <typename RestrictedTimesT = Aws::String>
  void SetRestrictedTimes(RestrictedTimesT&& value) {
    m_restrictedTimesHasBeenSet = true;
    m_restrictedTimes = std::forward<RestrictedTimesT>(value);
  }
  template <typename RestrictedTimesT = Aws::String>
  RouteViolatedConstraints& WithRestrictedTimes(RestrictedTimesT&& value) {
    SetRestrictedTimes(std::forward<RestrictedTimesT>(value));
    return *this;
  }
 
 
  inline bool GetTimeDependent() const { return m_timeDependent; }
  inline bool TimeDependentHasBeenSet() const { return m_timeDependentHasBeenSet; }
  inline void SetTimeDependent(bool value) {
    m_timeDependentHasBeenSet = true;
    m_timeDependent = value;
  }
  inline RouteViolatedConstraints& WithTimeDependent(bool value) {
    SetTimeDependent(value);
    return *this;
  }
 
 
  inline const RouteNoticeDetailRange& GetTrailerCount() const { return m_trailerCount; }
  inline bool TrailerCountHasBeenSet() const { return m_trailerCountHasBeenSet; }
  template <typename TrailerCountT = RouteNoticeDetailRange>
  void SetTrailerCount(TrailerCountT&& value) {
    m_trailerCountHasBeenSet = true;
    m_trailerCount = std::forward<TrailerCountT>(value);
  }
  template <typename TrailerCountT = RouteNoticeDetailRange>
  RouteViolatedConstraints& WithTrailerCount(TrailerCountT&& value) {
    SetTrailerCount(std::forward<TrailerCountT>(value));
    return *this;
  }
 
 
  inline bool GetTravelMode() const { return m_travelMode; }
  inline bool TravelModeHasBeenSet() const { return m_travelModeHasBeenSet; }
  inline void SetTravelMode(bool value) {
    m_travelModeHasBeenSet = true;
    m_travelMode = value;
  }
  inline RouteViolatedConstraints& WithTravelMode(bool value) {
    SetTravelMode(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTruckRoadType() const { return m_truckRoadType; }
  inline bool TruckRoadTypeHasBeenSet() const { return m_truckRoadTypeHasBeenSet; }
  template <typename TruckRoadTypeT = Aws::String>
  void SetTruckRoadType(TruckRoadTypeT&& value) {
    m_truckRoadTypeHasBeenSet = true;
    m_truckRoadType = std::forward<TruckRoadTypeT>(value);
  }
  template <typename TruckRoadTypeT = Aws::String>
  RouteViolatedConstraints& WithTruckRoadType(TruckRoadTypeT&& value) {
    SetTruckRoadType(std::forward<TruckRoadTypeT>(value));
    return *this;
  }
 
 
  inline RouteTruckType GetTruckType() const { return m_truckType; }
  inline bool TruckTypeHasBeenSet() const { return m_truckTypeHasBeenSet; }
  inline void SetTruckType(RouteTruckType value) {
    m_truckTypeHasBeenSet = true;
    m_truckType = value;
  }
  inline RouteViolatedConstraints& WithTruckType(RouteTruckType value) {
    SetTruckType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTunnelRestrictionCode() const { return m_tunnelRestrictionCode; }
  inline bool TunnelRestrictionCodeHasBeenSet() const { return m_tunnelRestrictionCodeHasBeenSet; }
  template <typename TunnelRestrictionCodeT = Aws::String>
  void SetTunnelRestrictionCode(TunnelRestrictionCodeT&& value) {
    m_tunnelRestrictionCodeHasBeenSet = true;
    m_tunnelRestrictionCode = std::forward<TunnelRestrictionCodeT>(value);
  }
  template <typename TunnelRestrictionCodeT = Aws::String>
  RouteViolatedConstraints& WithTunnelRestrictionCode(TunnelRestrictionCodeT&& value) {
    SetTunnelRestrictionCode(std::forward<TunnelRestrictionCodeT>(value));
    return *this;
  }
 private:
  bool m_allHazardsRestricted{false};
 
  RouteNoticeDetailRange m_axleCount;
 
  Aws::Vector<RouteHazardousCargoType> m_hazardousCargos;
 
  long long m_maxHeight{0};
 
  long long m_maxKpraLength{0};
 
  long long m_maxLength{0};
 
  long long m_maxPayloadCapacity{0};
 
  RouteWeightConstraint m_maxWeight;
 
  long long m_maxWeightPerAxle{0};
 
  WeightPerAxleGroup m_maxWeightPerAxleGroup;
 
  long long m_maxWidth{0};
 
  RouteNoticeDetailRange m_occupancy;
 
  Aws::String m_restrictedTimes;
 
  bool m_timeDependent{false};
 
  RouteNoticeDetailRange m_trailerCount;
 
  bool m_travelMode{false};
 
  Aws::String m_truckRoadType;
 
  RouteTruckType m_truckType{RouteTruckType::NOT_SET};
 
  Aws::String m_tunnelRestrictionCode;
  bool m_allHazardsRestrictedHasBeenSet = false;
  bool m_axleCountHasBeenSet = false;
  bool m_hazardousCargosHasBeenSet = false;
  bool m_maxHeightHasBeenSet = false;
  bool m_maxKpraLengthHasBeenSet = false;
  bool m_maxLengthHasBeenSet = false;
  bool m_maxPayloadCapacityHasBeenSet = false;
  bool m_maxWeightHasBeenSet = false;
  bool m_maxWeightPerAxleHasBeenSet = false;
  bool m_maxWeightPerAxleGroupHasBeenSet = false;
  bool m_maxWidthHasBeenSet = false;
  bool m_occupancyHasBeenSet = false;
  bool m_restrictedTimesHasBeenSet = false;
  bool m_timeDependentHasBeenSet = false;
  bool m_trailerCountHasBeenSet = false;
  bool m_travelModeHasBeenSet = false;
  bool m_truckRoadTypeHasBeenSet = false;
  bool m_truckTypeHasBeenSet = false;
  bool m_tunnelRestrictionCodeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GeoRoutes
}  // namespace Aws