CustomCodeSigning.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/iot/IoT_EXPORTS.h>
#include <aws/iot/model/CodeSigningCertificateChain.h>
#include <aws/iot/model/CodeSigningSignature.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace IoT {
namespace Model {
 
class CustomCodeSigning {
 public:
  AWS_IOT_API CustomCodeSigning() = default;
  AWS_IOT_API CustomCodeSigning(Aws::Utils::Json::JsonView jsonValue);
  AWS_IOT_API CustomCodeSigning& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_IOT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const CodeSigningSignature& GetSignature() const { return m_signature; }
  inline bool SignatureHasBeenSet() const { return m_signatureHasBeenSet; }
  template <typename SignatureT = CodeSigningSignature>
  void SetSignature(SignatureT&& value) {
    m_signatureHasBeenSet = true;
    m_signature = std::forward<SignatureT>(value);
  }
  template <typename SignatureT = CodeSigningSignature>
  CustomCodeSigning& WithSignature(SignatureT&& value) {
    SetSignature(std::forward<SignatureT>(value));
    return *this;
  }
 
 
  inline const CodeSigningCertificateChain& GetCertificateChain() const { return m_certificateChain; }
  inline bool CertificateChainHasBeenSet() const { return m_certificateChainHasBeenSet; }
  template <typename CertificateChainT = CodeSigningCertificateChain>
  void SetCertificateChain(CertificateChainT&& value) {
    m_certificateChainHasBeenSet = true;
    m_certificateChain = std::forward<CertificateChainT>(value);
  }
  template <typename CertificateChainT = CodeSigningCertificateChain>
  CustomCodeSigning& WithCertificateChain(CertificateChainT&& value) {
    SetCertificateChain(std::forward<CertificateChainT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetHashAlgorithm() const { return m_hashAlgorithm; }
  inline bool HashAlgorithmHasBeenSet() const { return m_hashAlgorithmHasBeenSet; }
  template <typename HashAlgorithmT = Aws::String>
  void SetHashAlgorithm(HashAlgorithmT&& value) {
    m_hashAlgorithmHasBeenSet = true;
    m_hashAlgorithm = std::forward<HashAlgorithmT>(value);
  }
  template <typename HashAlgorithmT = Aws::String>
  CustomCodeSigning& WithHashAlgorithm(HashAlgorithmT&& value) {
    SetHashAlgorithm(std::forward<HashAlgorithmT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSignatureAlgorithm() const { return m_signatureAlgorithm; }
  inline bool SignatureAlgorithmHasBeenSet() const { return m_signatureAlgorithmHasBeenSet; }
  template <typename SignatureAlgorithmT = Aws::String>
  void SetSignatureAlgorithm(SignatureAlgorithmT&& value) {
    m_signatureAlgorithmHasBeenSet = true;
    m_signatureAlgorithm = std::forward<SignatureAlgorithmT>(value);
  }
  template <typename SignatureAlgorithmT = Aws::String>
  CustomCodeSigning& WithSignatureAlgorithm(SignatureAlgorithmT&& value) {
    SetSignatureAlgorithm(std::forward<SignatureAlgorithmT>(value));
    return *this;
  }
 private:
  CodeSigningSignature m_signature;
 
  CodeSigningCertificateChain m_certificateChain;
 
  Aws::String m_hashAlgorithm;
 
  Aws::String m_signatureAlgorithm;
  bool m_signatureHasBeenSet = false;
  bool m_certificateChainHasBeenSet = false;
  bool m_hashAlgorithmHasBeenSet = false;
  bool m_signatureAlgorithmHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace IoT
}  // namespace Aws