FunctionCodeLocation.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/lambda/Lambda_EXPORTS.h>
#include <aws/lambda/model/FunctionCodeLocationError.h>
#include <aws/lambda/model/ResolvedS3Object.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Lambda {
namespace Model {
 
class FunctionCodeLocation {
 public:
  AWS_LAMBDA_API FunctionCodeLocation() = default;
  AWS_LAMBDA_API FunctionCodeLocation(Aws::Utils::Json::JsonView jsonValue);
  AWS_LAMBDA_API FunctionCodeLocation& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_LAMBDA_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetRepositoryType() const { return m_repositoryType; }
  inline bool RepositoryTypeHasBeenSet() const { return m_repositoryTypeHasBeenSet; }
  template <typename RepositoryTypeT = Aws::String>
  void SetRepositoryType(RepositoryTypeT&& value) {
    m_repositoryTypeHasBeenSet = true;
    m_repositoryType = std::forward<RepositoryTypeT>(value);
  }
  template <typename RepositoryTypeT = Aws::String>
  FunctionCodeLocation& WithRepositoryType(RepositoryTypeT&& value) {
    SetRepositoryType(std::forward<RepositoryTypeT>(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>
  FunctionCodeLocation& WithLocation(LocationT&& value) {
    SetLocation(std::forward<LocationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetImageUri() const { return m_imageUri; }
  inline bool ImageUriHasBeenSet() const { return m_imageUriHasBeenSet; }
  template <typename ImageUriT = Aws::String>
  void SetImageUri(ImageUriT&& value) {
    m_imageUriHasBeenSet = true;
    m_imageUri = std::forward<ImageUriT>(value);
  }
  template <typename ImageUriT = Aws::String>
  FunctionCodeLocation& WithImageUri(ImageUriT&& value) {
    SetImageUri(std::forward<ImageUriT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResolvedImageUri() const { return m_resolvedImageUri; }
  inline bool ResolvedImageUriHasBeenSet() const { return m_resolvedImageUriHasBeenSet; }
  template <typename ResolvedImageUriT = Aws::String>
  void SetResolvedImageUri(ResolvedImageUriT&& value) {
    m_resolvedImageUriHasBeenSet = true;
    m_resolvedImageUri = std::forward<ResolvedImageUriT>(value);
  }
  template <typename ResolvedImageUriT = Aws::String>
  FunctionCodeLocation& WithResolvedImageUri(ResolvedImageUriT&& value) {
    SetResolvedImageUri(std::forward<ResolvedImageUriT>(value));
    return *this;
  }
 
 
  inline const ResolvedS3Object& GetResolvedS3Object() const { return m_resolvedS3Object; }
  inline bool ResolvedS3ObjectHasBeenSet() const { return m_resolvedS3ObjectHasBeenSet; }
  template <typename ResolvedS3ObjectT = ResolvedS3Object>
  void SetResolvedS3Object(ResolvedS3ObjectT&& value) {
    m_resolvedS3ObjectHasBeenSet = true;
    m_resolvedS3Object = std::forward<ResolvedS3ObjectT>(value);
  }
  template <typename ResolvedS3ObjectT = ResolvedS3Object>
  FunctionCodeLocation& WithResolvedS3Object(ResolvedS3ObjectT&& value) {
    SetResolvedS3Object(std::forward<ResolvedS3ObjectT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSourceKMSKeyArn() const { return m_sourceKMSKeyArn; }
  inline bool SourceKMSKeyArnHasBeenSet() const { return m_sourceKMSKeyArnHasBeenSet; }
  template <typename SourceKMSKeyArnT = Aws::String>
  void SetSourceKMSKeyArn(SourceKMSKeyArnT&& value) {
    m_sourceKMSKeyArnHasBeenSet = true;
    m_sourceKMSKeyArn = std::forward<SourceKMSKeyArnT>(value);
  }
  template <typename SourceKMSKeyArnT = Aws::String>
  FunctionCodeLocation& WithSourceKMSKeyArn(SourceKMSKeyArnT&& value) {
    SetSourceKMSKeyArn(std::forward<SourceKMSKeyArnT>(value));
    return *this;
  }
 
 
  inline const FunctionCodeLocationError& GetError() const { return m_error; }
  inline bool ErrorHasBeenSet() const { return m_errorHasBeenSet; }
  template <typename ErrorT = FunctionCodeLocationError>
  void SetError(ErrorT&& value) {
    m_errorHasBeenSet = true;
    m_error = std::forward<ErrorT>(value);
  }
  template <typename ErrorT = FunctionCodeLocationError>
  FunctionCodeLocation& WithError(ErrorT&& value) {
    SetError(std::forward<ErrorT>(value));
    return *this;
  }
 private:
  Aws::String m_repositoryType;
 
  Aws::String m_location;
 
  Aws::String m_imageUri;
 
  Aws::String m_resolvedImageUri;
 
  ResolvedS3Object m_resolvedS3Object;
 
  Aws::String m_sourceKMSKeyArn;
 
  FunctionCodeLocationError m_error;
  bool m_repositoryTypeHasBeenSet = false;
  bool m_locationHasBeenSet = false;
  bool m_imageUriHasBeenSet = false;
  bool m_resolvedImageUriHasBeenSet = false;
  bool m_resolvedS3ObjectHasBeenSet = false;
  bool m_sourceKMSKeyArnHasBeenSet = false;
  bool m_errorHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Lambda
}  // namespace Aws