UpdateGameSessionQueueRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/gamelift/GameLiftRequest.h>
#include <aws/gamelift/GameLift_EXPORTS.h>
#include <aws/gamelift/model/FilterConfiguration.h>
#include <aws/gamelift/model/GameSessionQueueDestination.h>
#include <aws/gamelift/model/PlayerLatencyPolicy.h>
#include <aws/gamelift/model/PriorityConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace GameLift {
namespace Model {
 
class UpdateGameSessionQueueRequest : public GameLiftRequest {
 public:
  AWS_GAMELIFT_API UpdateGameSessionQueueRequest() = 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 "UpdateGameSessionQueue"; }
 
  AWS_GAMELIFT_API Aws::String SerializePayload() const override;
 
  AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  UpdateGameSessionQueueRequest& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline int GetTimeoutInSeconds() const { return m_timeoutInSeconds; }
  inline bool TimeoutInSecondsHasBeenSet() const { return m_timeoutInSecondsHasBeenSet; }
  inline void SetTimeoutInSeconds(int value) {
    m_timeoutInSecondsHasBeenSet = true;
    m_timeoutInSeconds = value;
  }
  inline UpdateGameSessionQueueRequest& WithTimeoutInSeconds(int value) {
    SetTimeoutInSeconds(value);
    return *this;
  }
 
 
  inline const Aws::Vector<PlayerLatencyPolicy>& GetPlayerLatencyPolicies() const { return m_playerLatencyPolicies; }
  inline bool PlayerLatencyPoliciesHasBeenSet() const { return m_playerLatencyPoliciesHasBeenSet; }
  template <typename PlayerLatencyPoliciesT = Aws::Vector<PlayerLatencyPolicy>>
  void SetPlayerLatencyPolicies(PlayerLatencyPoliciesT&& value) {
    m_playerLatencyPoliciesHasBeenSet = true;
    m_playerLatencyPolicies = std::forward<PlayerLatencyPoliciesT>(value);
  }
  template <typename PlayerLatencyPoliciesT = Aws::Vector<PlayerLatencyPolicy>>
  UpdateGameSessionQueueRequest& WithPlayerLatencyPolicies(PlayerLatencyPoliciesT&& value) {
    SetPlayerLatencyPolicies(std::forward<PlayerLatencyPoliciesT>(value));
    return *this;
  }
  template <typename PlayerLatencyPoliciesT = PlayerLatencyPolicy>
  UpdateGameSessionQueueRequest& AddPlayerLatencyPolicies(PlayerLatencyPoliciesT&& value) {
    m_playerLatencyPoliciesHasBeenSet = true;
    m_playerLatencyPolicies.emplace_back(std::forward<PlayerLatencyPoliciesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<GameSessionQueueDestination>& GetDestinations() const { return m_destinations; }
  inline bool DestinationsHasBeenSet() const { return m_destinationsHasBeenSet; }
  template <typename DestinationsT = Aws::Vector<GameSessionQueueDestination>>
  void SetDestinations(DestinationsT&& value) {
    m_destinationsHasBeenSet = true;
    m_destinations = std::forward<DestinationsT>(value);
  }
  template <typename DestinationsT = Aws::Vector<GameSessionQueueDestination>>
  UpdateGameSessionQueueRequest& WithDestinations(DestinationsT&& value) {
    SetDestinations(std::forward<DestinationsT>(value));
    return *this;
  }
  template <typename DestinationsT = GameSessionQueueDestination>
  UpdateGameSessionQueueRequest& AddDestinations(DestinationsT&& value) {
    m_destinationsHasBeenSet = true;
    m_destinations.emplace_back(std::forward<DestinationsT>(value));
    return *this;
  }
 
 
  inline const FilterConfiguration& GetFilterConfiguration() const { return m_filterConfiguration; }
  inline bool FilterConfigurationHasBeenSet() const { return m_filterConfigurationHasBeenSet; }
  template <typename FilterConfigurationT = FilterConfiguration>
  void SetFilterConfiguration(FilterConfigurationT&& value) {
    m_filterConfigurationHasBeenSet = true;
    m_filterConfiguration = std::forward<FilterConfigurationT>(value);
  }
  template <typename FilterConfigurationT = FilterConfiguration>
  UpdateGameSessionQueueRequest& WithFilterConfiguration(FilterConfigurationT&& value) {
    SetFilterConfiguration(std::forward<FilterConfigurationT>(value));
    return *this;
  }
 
 
  inline const PriorityConfiguration& GetPriorityConfiguration() const { return m_priorityConfiguration; }
  inline bool PriorityConfigurationHasBeenSet() const { return m_priorityConfigurationHasBeenSet; }
  template <typename PriorityConfigurationT = PriorityConfiguration>
  void SetPriorityConfiguration(PriorityConfigurationT&& value) {
    m_priorityConfigurationHasBeenSet = true;
    m_priorityConfiguration = std::forward<PriorityConfigurationT>(value);
  }
  template <typename PriorityConfigurationT = PriorityConfiguration>
  UpdateGameSessionQueueRequest& WithPriorityConfiguration(PriorityConfigurationT&& value) {
    SetPriorityConfiguration(std::forward<PriorityConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCustomEventData() const { return m_customEventData; }
  inline bool CustomEventDataHasBeenSet() const { return m_customEventDataHasBeenSet; }
  template <typename CustomEventDataT = Aws::String>
  void SetCustomEventData(CustomEventDataT&& value) {
    m_customEventDataHasBeenSet = true;
    m_customEventData = std::forward<CustomEventDataT>(value);
  }
  template <typename CustomEventDataT = Aws::String>
  UpdateGameSessionQueueRequest& WithCustomEventData(CustomEventDataT&& value) {
    SetCustomEventData(std::forward<CustomEventDataT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNotificationTarget() const { return m_notificationTarget; }
  inline bool NotificationTargetHasBeenSet() const { return m_notificationTargetHasBeenSet; }
  template <typename NotificationTargetT = Aws::String>
  void SetNotificationTarget(NotificationTargetT&& value) {
    m_notificationTargetHasBeenSet = true;
    m_notificationTarget = std::forward<NotificationTargetT>(value);
  }
  template <typename NotificationTargetT = Aws::String>
  UpdateGameSessionQueueRequest& WithNotificationTarget(NotificationTargetT&& value) {
    SetNotificationTarget(std::forward<NotificationTargetT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  int m_timeoutInSeconds{0};
 
  Aws::Vector<PlayerLatencyPolicy> m_playerLatencyPolicies;
 
  Aws::Vector<GameSessionQueueDestination> m_destinations;
 
  FilterConfiguration m_filterConfiguration;
 
  PriorityConfiguration m_priorityConfiguration;
 
  Aws::String m_customEventData;
 
  Aws::String m_notificationTarget;
  bool m_nameHasBeenSet = false;
  bool m_timeoutInSecondsHasBeenSet = false;
  bool m_playerLatencyPoliciesHasBeenSet = false;
  bool m_destinationsHasBeenSet = false;
  bool m_filterConfigurationHasBeenSet = false;
  bool m_priorityConfigurationHasBeenSet = false;
  bool m_customEventDataHasBeenSet = false;
  bool m_notificationTargetHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GameLift
}  // namespace Aws