EFSVolumeConfiguration.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/ecs/model/EFSAuthorizationConfig.h>
#include <aws/ecs/model/EFSTransitEncryption.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ECS {
namespace Model {
 
class EFSVolumeConfiguration {
 public:
  AWS_ECS_API EFSVolumeConfiguration() = default;
  AWS_ECS_API EFSVolumeConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API EFSVolumeConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetFileSystemId() const { return m_fileSystemId; }
  inline bool FileSystemIdHasBeenSet() const { return m_fileSystemIdHasBeenSet; }
  template <typename FileSystemIdT = Aws::String>
  void SetFileSystemId(FileSystemIdT&& value) {
    m_fileSystemIdHasBeenSet = true;
    m_fileSystemId = std::forward<FileSystemIdT>(value);
  }
  template <typename FileSystemIdT = Aws::String>
  EFSVolumeConfiguration& WithFileSystemId(FileSystemIdT&& value) {
    SetFileSystemId(std::forward<FileSystemIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRootDirectory() const { return m_rootDirectory; }
  inline bool RootDirectoryHasBeenSet() const { return m_rootDirectoryHasBeenSet; }
  template <typename RootDirectoryT = Aws::String>
  void SetRootDirectory(RootDirectoryT&& value) {
    m_rootDirectoryHasBeenSet = true;
    m_rootDirectory = std::forward<RootDirectoryT>(value);
  }
  template <typename RootDirectoryT = Aws::String>
  EFSVolumeConfiguration& WithRootDirectory(RootDirectoryT&& value) {
    SetRootDirectory(std::forward<RootDirectoryT>(value));
    return *this;
  }
 
 
  inline EFSTransitEncryption GetTransitEncryption() const { return m_transitEncryption; }
  inline bool TransitEncryptionHasBeenSet() const { return m_transitEncryptionHasBeenSet; }
  inline void SetTransitEncryption(EFSTransitEncryption value) {
    m_transitEncryptionHasBeenSet = true;
    m_transitEncryption = value;
  }
  inline EFSVolumeConfiguration& WithTransitEncryption(EFSTransitEncryption value) {
    SetTransitEncryption(value);
    return *this;
  }
 
 
  inline int GetTransitEncryptionPort() const { return m_transitEncryptionPort; }
  inline bool TransitEncryptionPortHasBeenSet() const { return m_transitEncryptionPortHasBeenSet; }
  inline void SetTransitEncryptionPort(int value) {
    m_transitEncryptionPortHasBeenSet = true;
    m_transitEncryptionPort = value;
  }
  inline EFSVolumeConfiguration& WithTransitEncryptionPort(int value) {
    SetTransitEncryptionPort(value);
    return *this;
  }
 
 
  inline const EFSAuthorizationConfig& GetAuthorizationConfig() const { return m_authorizationConfig; }
  inline bool AuthorizationConfigHasBeenSet() const { return m_authorizationConfigHasBeenSet; }
  template <typename AuthorizationConfigT = EFSAuthorizationConfig>
  void SetAuthorizationConfig(AuthorizationConfigT&& value) {
    m_authorizationConfigHasBeenSet = true;
    m_authorizationConfig = std::forward<AuthorizationConfigT>(value);
  }
  template <typename AuthorizationConfigT = EFSAuthorizationConfig>
  EFSVolumeConfiguration& WithAuthorizationConfig(AuthorizationConfigT&& value) {
    SetAuthorizationConfig(std::forward<AuthorizationConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_fileSystemId;
 
  Aws::String m_rootDirectory;
 
  EFSTransitEncryption m_transitEncryption{EFSTransitEncryption::NOT_SET};
 
  int m_transitEncryptionPort{0};
 
  EFSAuthorizationConfig m_authorizationConfig;
  bool m_fileSystemIdHasBeenSet = false;
  bool m_rootDirectoryHasBeenSet = false;
  bool m_transitEncryptionHasBeenSet = false;
  bool m_transitEncryptionPortHasBeenSet = false;
  bool m_authorizationConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ECS
}  // namespace Aws