KeyAttributes.h

 
#pragma once
#include <aws/payment-cryptography/PaymentCryptography_EXPORTS.h>
#include <aws/payment-cryptography/model/KeyAlgorithm.h>
#include <aws/payment-cryptography/model/KeyClass.h>
#include <aws/payment-cryptography/model/KeyModesOfUse.h>
#include <aws/payment-cryptography/model/KeyUsage.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace PaymentCryptography {
namespace Model {
 
class KeyAttributes {
 public:
  AWS_PAYMENTCRYPTOGRAPHY_API KeyAttributes() = default;
  AWS_PAYMENTCRYPTOGRAPHY_API KeyAttributes(Aws::Utils::Json::JsonView jsonValue);
  AWS_PAYMENTCRYPTOGRAPHY_API KeyAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_PAYMENTCRYPTOGRAPHY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline KeyUsage GetKeyUsage() const { return m_keyUsage; }
  inline bool KeyUsageHasBeenSet() const { return m_keyUsageHasBeenSet; }
  inline void SetKeyUsage(KeyUsage value) {
    m_keyUsageHasBeenSet = true;
    m_keyUsage = value;
  }
  inline KeyAttributes& WithKeyUsage(KeyUsage value) {
    SetKeyUsage(value);
    return *this;
  }
 
 
  inline KeyClass GetKeyClass() const { return m_keyClass; }
  inline bool KeyClassHasBeenSet() const { return m_keyClassHasBeenSet; }
  inline void SetKeyClass(KeyClass value) {
    m_keyClassHasBeenSet = true;
    m_keyClass = value;
  }
  inline KeyAttributes& WithKeyClass(KeyClass value) {
    SetKeyClass(value);
    return *this;
  }
 
 
  inline KeyAlgorithm GetKeyAlgorithm() const { return m_keyAlgorithm; }
  inline bool KeyAlgorithmHasBeenSet() const { return m_keyAlgorithmHasBeenSet; }
  inline void SetKeyAlgorithm(KeyAlgorithm value) {
    m_keyAlgorithmHasBeenSet = true;
    m_keyAlgorithm = value;
  }
  inline KeyAttributes& WithKeyAlgorithm(KeyAlgorithm value) {
    SetKeyAlgorithm(value);
    return *this;
  }
 
 
  inline const KeyModesOfUse& GetKeyModesOfUse() const { return m_keyModesOfUse; }
  inline bool KeyModesOfUseHasBeenSet() const { return m_keyModesOfUseHasBeenSet; }
  template <typename KeyModesOfUseT = KeyModesOfUse>
  void SetKeyModesOfUse(KeyModesOfUseT&& value) {
    m_keyModesOfUseHasBeenSet = true;
    m_keyModesOfUse = std::forward<KeyModesOfUseT>(value);
  }
  template <typename KeyModesOfUseT = KeyModesOfUse>
  KeyAttributes& WithKeyModesOfUse(KeyModesOfUseT&& value) {
    SetKeyModesOfUse(std::forward<KeyModesOfUseT>(value));
    return *this;
  }
 private:
  KeyUsage m_keyUsage{KeyUsage::NOT_SET};
 
  KeyClass m_keyClass{KeyClass::NOT_SET};
 
  KeyAlgorithm m_keyAlgorithm{KeyAlgorithm::NOT_SET};
 
  KeyModesOfUse m_keyModesOfUse;
  bool m_keyUsageHasBeenSet = false;
  bool m_keyClassHasBeenSet = false;
  bool m_keyAlgorithmHasBeenSet = false;
  bool m_keyModesOfUseHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace PaymentCryptography
}  // namespace Aws