LinuxParameters.h

 
#pragma once
#include <aws/batch/Batch_EXPORTS.h>
#include <aws/batch/model/Device.h>
#include <aws/batch/model/Tmpfs.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Batch {
namespace Model {
 
class LinuxParameters {
 public:
  AWS_BATCH_API LinuxParameters() = default;
  AWS_BATCH_API LinuxParameters(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API LinuxParameters& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<Device>& GetDevices() const { return m_devices; }
  inline bool DevicesHasBeenSet() const { return m_devicesHasBeenSet; }
  template <typename DevicesT = Aws::Vector<Device>>
  void SetDevices(DevicesT&& value) {
    m_devicesHasBeenSet = true;
    m_devices = std::forward<DevicesT>(value);
  }
  template <typename DevicesT = Aws::Vector<Device>>
  LinuxParameters& WithDevices(DevicesT&& value) {
    SetDevices(std::forward<DevicesT>(value));
    return *this;
  }
  template <typename DevicesT = Device>
  LinuxParameters& AddDevices(DevicesT&& value) {
    m_devicesHasBeenSet = true;
    m_devices.emplace_back(std::forward<DevicesT>(value));
    return *this;
  }
 
 
  inline bool GetInitProcessEnabled() const { return m_initProcessEnabled; }
  inline bool InitProcessEnabledHasBeenSet() const { return m_initProcessEnabledHasBeenSet; }
  inline void SetInitProcessEnabled(bool value) {
    m_initProcessEnabledHasBeenSet = true;
    m_initProcessEnabled = value;
  }
  inline LinuxParameters& WithInitProcessEnabled(bool value) {
    SetInitProcessEnabled(value);
    return *this;
  }
 
 
  inline int GetSharedMemorySize() const { return m_sharedMemorySize; }
  inline bool SharedMemorySizeHasBeenSet() const { return m_sharedMemorySizeHasBeenSet; }
  inline void SetSharedMemorySize(int value) {
    m_sharedMemorySizeHasBeenSet = true;
    m_sharedMemorySize = value;
  }
  inline LinuxParameters& WithSharedMemorySize(int value) {
    SetSharedMemorySize(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Tmpfs>& GetTmpfs() const { return m_tmpfs; }
  inline bool TmpfsHasBeenSet() const { return m_tmpfsHasBeenSet; }
  template <typename TmpfsT = Aws::Vector<Tmpfs>>
  void SetTmpfs(TmpfsT&& value) {
    m_tmpfsHasBeenSet = true;
    m_tmpfs = std::forward<TmpfsT>(value);
  }
  template <typename TmpfsT = Aws::Vector<Tmpfs>>
  LinuxParameters& WithTmpfs(TmpfsT&& value) {
    SetTmpfs(std::forward<TmpfsT>(value));
    return *this;
  }
  template <typename TmpfsT = Tmpfs>
  LinuxParameters& AddTmpfs(TmpfsT&& value) {
    m_tmpfsHasBeenSet = true;
    m_tmpfs.emplace_back(std::forward<TmpfsT>(value));
    return *this;
  }
 
 
  inline int GetMaxSwap() const { return m_maxSwap; }
  inline bool MaxSwapHasBeenSet() const { return m_maxSwapHasBeenSet; }
  inline void SetMaxSwap(int value) {
    m_maxSwapHasBeenSet = true;
    m_maxSwap = value;
  }
  inline LinuxParameters& WithMaxSwap(int value) {
    SetMaxSwap(value);
    return *this;
  }
 
 
  inline int GetSwappiness() const { return m_swappiness; }
  inline bool SwappinessHasBeenSet() const { return m_swappinessHasBeenSet; }
  inline void SetSwappiness(int value) {
    m_swappinessHasBeenSet = true;
    m_swappiness = value;
  }
  inline LinuxParameters& WithSwappiness(int value) {
    SetSwappiness(value);
    return *this;
  }
 private:
  Aws::Vector<Device> m_devices;
 
  bool m_initProcessEnabled{false};
 
  int m_sharedMemorySize{0};
 
  Aws::Vector<Tmpfs> m_tmpfs;
 
  int m_maxSwap{0};
 
  int m_swappiness{0};
  bool m_devicesHasBeenSet = false;
  bool m_initProcessEnabledHasBeenSet = false;
  bool m_sharedMemorySizeHasBeenSet = false;
  bool m_tmpfsHasBeenSet = false;
  bool m_maxSwapHasBeenSet = false;
  bool m_swappinessHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Batch
}  // namespace Aws