GameSessionQueue.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.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 Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GameLift {
namespace Model {
 
class GameSessionQueue {
 public:
  AWS_GAMELIFT_API GameSessionQueue() = default;
  AWS_GAMELIFT_API GameSessionQueue(Aws::Utils::Json::JsonView jsonValue);
  AWS_GAMELIFT_API GameSessionQueue& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  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>
  GameSessionQueue& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetGameSessionQueueArn() const { return m_gameSessionQueueArn; }
  inline bool GameSessionQueueArnHasBeenSet() const { return m_gameSessionQueueArnHasBeenSet; }
  template <typename GameSessionQueueArnT = Aws::String>
  void SetGameSessionQueueArn(GameSessionQueueArnT&& value) {
    m_gameSessionQueueArnHasBeenSet = true;
    m_gameSessionQueueArn = std::forward<GameSessionQueueArnT>(value);
  }
  template <typename GameSessionQueueArnT = Aws::String>
  GameSessionQueue& WithGameSessionQueueArn(GameSessionQueueArnT&& value) {
    SetGameSessionQueueArn(std::forward<GameSessionQueueArnT>(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 GameSessionQueue& 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>>
  GameSessionQueue& WithPlayerLatencyPolicies(PlayerLatencyPoliciesT&& value) {
    SetPlayerLatencyPolicies(std::forward<PlayerLatencyPoliciesT>(value));
    return *this;
  }
  template <typename PlayerLatencyPoliciesT = PlayerLatencyPolicy>
  GameSessionQueue& 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>>
  GameSessionQueue& WithDestinations(DestinationsT&& value) {
    SetDestinations(std::forward<DestinationsT>(value));
    return *this;
  }
  template <typename DestinationsT = GameSessionQueueDestination>
  GameSessionQueue& 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>
  GameSessionQueue& 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>
  GameSessionQueue& 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>
  GameSessionQueue& 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>
  GameSessionQueue& WithNotificationTarget(NotificationTargetT&& value) {
    SetNotificationTarget(std::forward<NotificationTargetT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  Aws::String m_gameSessionQueueArn;
 
  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_gameSessionQueueArnHasBeenSet = 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