RouteIntermodalTransitOptions.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/geo-routes/GeoRoutes_EXPORTS.h>
#include <aws/geo-routes/model/RouteIntermodalEnabledLegs.h>
#include <aws/geo-routes/model/RouteTransitMode.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GeoRoutes {
namespace Model {
 
class RouteIntermodalTransitOptions {
 public:
  AWS_GEOROUTES_API RouteIntermodalTransitOptions() = default;
  AWS_GEOROUTES_API RouteIntermodalTransitOptions(Aws::Utils::Json::JsonView jsonValue);
  AWS_GEOROUTES_API RouteIntermodalTransitOptions& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GEOROUTES_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<RouteTransitMode>& GetAllowedModes() const { return m_allowedModes; }
  inline bool AllowedModesHasBeenSet() const { return m_allowedModesHasBeenSet; }
  template <typename AllowedModesT = Aws::Vector<RouteTransitMode>>
  void SetAllowedModes(AllowedModesT&& value) {
    m_allowedModesHasBeenSet = true;
    m_allowedModes = std::forward<AllowedModesT>(value);
  }
  template <typename AllowedModesT = Aws::Vector<RouteTransitMode>>
  RouteIntermodalTransitOptions& WithAllowedModes(AllowedModesT&& value) {
    SetAllowedModes(std::forward<AllowedModesT>(value));
    return *this;
  }
  inline RouteIntermodalTransitOptions& AddAllowedModes(RouteTransitMode value) {
    m_allowedModesHasBeenSet = true;
    m_allowedModes.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<RouteIntermodalEnabledLegs>& GetEnabledFor() const { return m_enabledFor; }
  inline bool EnabledForHasBeenSet() const { return m_enabledForHasBeenSet; }
  template <typename EnabledForT = Aws::Vector<RouteIntermodalEnabledLegs>>
  void SetEnabledFor(EnabledForT&& value) {
    m_enabledForHasBeenSet = true;
    m_enabledFor = std::forward<EnabledForT>(value);
  }
  template <typename EnabledForT = Aws::Vector<RouteIntermodalEnabledLegs>>
  RouteIntermodalTransitOptions& WithEnabledFor(EnabledForT&& value) {
    SetEnabledFor(std::forward<EnabledForT>(value));
    return *this;
  }
  inline RouteIntermodalTransitOptions& AddEnabledFor(RouteIntermodalEnabledLegs value) {
    m_enabledForHasBeenSet = true;
    m_enabledFor.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<RouteTransitMode>& GetExcludedModes() const { return m_excludedModes; }
  inline bool ExcludedModesHasBeenSet() const { return m_excludedModesHasBeenSet; }
  template <typename ExcludedModesT = Aws::Vector<RouteTransitMode>>
  void SetExcludedModes(ExcludedModesT&& value) {
    m_excludedModesHasBeenSet = true;
    m_excludedModes = std::forward<ExcludedModesT>(value);
  }
  template <typename ExcludedModesT = Aws::Vector<RouteTransitMode>>
  RouteIntermodalTransitOptions& WithExcludedModes(ExcludedModesT&& value) {
    SetExcludedModes(std::forward<ExcludedModesT>(value));
    return *this;
  }
  inline RouteIntermodalTransitOptions& AddExcludedModes(RouteTransitMode value) {
    m_excludedModesHasBeenSet = true;
    m_excludedModes.push_back(value);
    return *this;
  }
 private:
  Aws::Vector<RouteTransitMode> m_allowedModes;
 
  Aws::Vector<RouteIntermodalEnabledLegs> m_enabledFor;
 
  Aws::Vector<RouteTransitMode> m_excludedModes;
  bool m_allowedModesHasBeenSet = false;
  bool m_enabledForHasBeenSet = false;
  bool m_excludedModesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GeoRoutes
}  // namespace Aws