FleetCapacity.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/gamelift/GameLift_EXPORTS.h>
#include <aws/gamelift/model/EC2InstanceCounts.h>
#include <aws/gamelift/model/EC2InstanceType.h>
#include <aws/gamelift/model/GameServerContainerGroupCounts.h>
#include <aws/gamelift/model/ManagedCapacityConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GameLift {
namespace Model {
 
class FleetCapacity {
 public:
  AWS_GAMELIFT_API FleetCapacity() = default;
  AWS_GAMELIFT_API FleetCapacity(Aws::Utils::Json::JsonView jsonValue);
  AWS_GAMELIFT_API FleetCapacity& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetFleetId() const { return m_fleetId; }
  inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
  template <typename FleetIdT = Aws::String>
  void SetFleetId(FleetIdT&& value) {
    m_fleetIdHasBeenSet = true;
    m_fleetId = std::forward<FleetIdT>(value);
  }
  template <typename FleetIdT = Aws::String>
  FleetCapacity& WithFleetId(FleetIdT&& value) {
    SetFleetId(std::forward<FleetIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFleetArn() const { return m_fleetArn; }
  inline bool FleetArnHasBeenSet() const { return m_fleetArnHasBeenSet; }
  template <typename FleetArnT = Aws::String>
  void SetFleetArn(FleetArnT&& value) {
    m_fleetArnHasBeenSet = true;
    m_fleetArn = std::forward<FleetArnT>(value);
  }
  template <typename FleetArnT = Aws::String>
  FleetCapacity& WithFleetArn(FleetArnT&& value) {
    SetFleetArn(std::forward<FleetArnT>(value));
    return *this;
  }
 
 
  inline EC2InstanceType GetInstanceType() const { return m_instanceType; }
  inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
  inline void SetInstanceType(EC2InstanceType value) {
    m_instanceTypeHasBeenSet = true;
    m_instanceType = value;
  }
  inline FleetCapacity& WithInstanceType(EC2InstanceType value) {
    SetInstanceType(value);
    return *this;
  }
 
 
  inline const EC2InstanceCounts& GetInstanceCounts() const { return m_instanceCounts; }
  inline bool InstanceCountsHasBeenSet() const { return m_instanceCountsHasBeenSet; }
  template <typename InstanceCountsT = EC2InstanceCounts>
  void SetInstanceCounts(InstanceCountsT&& value) {
    m_instanceCountsHasBeenSet = true;
    m_instanceCounts = std::forward<InstanceCountsT>(value);
  }
  template <typename InstanceCountsT = EC2InstanceCounts>
  FleetCapacity& WithInstanceCounts(InstanceCountsT&& value) {
    SetInstanceCounts(std::forward<InstanceCountsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLocation() const { return m_location; }
  inline bool LocationHasBeenSet() const { return m_locationHasBeenSet; }
  template <typename LocationT = Aws::String>
  void SetLocation(LocationT&& value) {
    m_locationHasBeenSet = true;
    m_location = std::forward<LocationT>(value);
  }
  template <typename LocationT = Aws::String>
  FleetCapacity& WithLocation(LocationT&& value) {
    SetLocation(std::forward<LocationT>(value));
    return *this;
  }
 
 
  inline const GameServerContainerGroupCounts& GetGameServerContainerGroupCounts() const { return m_gameServerContainerGroupCounts; }
  inline bool GameServerContainerGroupCountsHasBeenSet() const { return m_gameServerContainerGroupCountsHasBeenSet; }
  template <typename GameServerContainerGroupCountsT = GameServerContainerGroupCounts>
  void SetGameServerContainerGroupCounts(GameServerContainerGroupCountsT&& value) {
    m_gameServerContainerGroupCountsHasBeenSet = true;
    m_gameServerContainerGroupCounts = std::forward<GameServerContainerGroupCountsT>(value);
  }
  template <typename GameServerContainerGroupCountsT = GameServerContainerGroupCounts>
  FleetCapacity& WithGameServerContainerGroupCounts(GameServerContainerGroupCountsT&& value) {
    SetGameServerContainerGroupCounts(std::forward<GameServerContainerGroupCountsT>(value));
    return *this;
  }
 
 
  inline const ManagedCapacityConfiguration& GetManagedCapacityConfiguration() const { return m_managedCapacityConfiguration; }
  inline bool ManagedCapacityConfigurationHasBeenSet() const { return m_managedCapacityConfigurationHasBeenSet; }
  template <typename ManagedCapacityConfigurationT = ManagedCapacityConfiguration>
  void SetManagedCapacityConfiguration(ManagedCapacityConfigurationT&& value) {
    m_managedCapacityConfigurationHasBeenSet = true;
    m_managedCapacityConfiguration = std::forward<ManagedCapacityConfigurationT>(value);
  }
  template <typename ManagedCapacityConfigurationT = ManagedCapacityConfiguration>
  FleetCapacity& WithManagedCapacityConfiguration(ManagedCapacityConfigurationT&& value) {
    SetManagedCapacityConfiguration(std::forward<ManagedCapacityConfigurationT>(value));
    return *this;
  }
 private:
  Aws::String m_fleetId;
 
  Aws::String m_fleetArn;
 
  EC2InstanceType m_instanceType{EC2InstanceType::NOT_SET};
 
  EC2InstanceCounts m_instanceCounts;
 
  Aws::String m_location;
 
  GameServerContainerGroupCounts m_gameServerContainerGroupCounts;
 
  ManagedCapacityConfiguration m_managedCapacityConfiguration;
  bool m_fleetIdHasBeenSet = false;
  bool m_fleetArnHasBeenSet = false;
  bool m_instanceTypeHasBeenSet = false;
  bool m_instanceCountsHasBeenSet = false;
  bool m_locationHasBeenSet = false;
  bool m_gameServerContainerGroupCountsHasBeenSet = false;
  bool m_managedCapacityConfigurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GameLift
}  // namespace Aws