Scan.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/guardduty/GuardDuty_EXPORTS.h>
#include <aws/guardduty/model/ResourceDetails.h>
#include <aws/guardduty/model/ScanResultDetails.h>
#include <aws/guardduty/model/ScanStatus.h>
#include <aws/guardduty/model/ScanType.h>
#include <aws/guardduty/model/TriggerDetails.h>
#include <aws/guardduty/model/VolumeDetail.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GuardDuty {
namespace Model {
 
class Scan {
 public:
  AWS_GUARDDUTY_API Scan() = default;
  AWS_GUARDDUTY_API Scan(Aws::Utils::Json::JsonView jsonValue);
  AWS_GUARDDUTY_API Scan& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GUARDDUTY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetDetectorId() const { return m_detectorId; }
  inline bool DetectorIdHasBeenSet() const { return m_detectorIdHasBeenSet; }
  template <typename DetectorIdT = Aws::String>
  void SetDetectorId(DetectorIdT&& value) {
    m_detectorIdHasBeenSet = true;
    m_detectorId = std::forward<DetectorIdT>(value);
  }
  template <typename DetectorIdT = Aws::String>
  Scan& WithDetectorId(DetectorIdT&& value) {
    SetDetectorId(std::forward<DetectorIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAdminDetectorId() const { return m_adminDetectorId; }
  inline bool AdminDetectorIdHasBeenSet() const { return m_adminDetectorIdHasBeenSet; }
  template <typename AdminDetectorIdT = Aws::String>
  void SetAdminDetectorId(AdminDetectorIdT&& value) {
    m_adminDetectorIdHasBeenSet = true;
    m_adminDetectorId = std::forward<AdminDetectorIdT>(value);
  }
  template <typename AdminDetectorIdT = Aws::String>
  Scan& WithAdminDetectorId(AdminDetectorIdT&& value) {
    SetAdminDetectorId(std::forward<AdminDetectorIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetScanId() const { return m_scanId; }
  inline bool ScanIdHasBeenSet() const { return m_scanIdHasBeenSet; }
  template <typename ScanIdT = Aws::String>
  void SetScanId(ScanIdT&& value) {
    m_scanIdHasBeenSet = true;
    m_scanId = std::forward<ScanIdT>(value);
  }
  template <typename ScanIdT = Aws::String>
  Scan& WithScanId(ScanIdT&& value) {
    SetScanId(std::forward<ScanIdT>(value));
    return *this;
  }
 
 
  inline ScanStatus GetScanStatus() const { return m_scanStatus; }
  inline bool ScanStatusHasBeenSet() const { return m_scanStatusHasBeenSet; }
  inline void SetScanStatus(ScanStatus value) {
    m_scanStatusHasBeenSet = true;
    m_scanStatus = value;
  }
  inline Scan& WithScanStatus(ScanStatus value) {
    SetScanStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetFailureReason() const { return m_failureReason; }
  inline bool FailureReasonHasBeenSet() const { return m_failureReasonHasBeenSet; }
  template <typename FailureReasonT = Aws::String>
  void SetFailureReason(FailureReasonT&& value) {
    m_failureReasonHasBeenSet = true;
    m_failureReason = std::forward<FailureReasonT>(value);
  }
  template <typename FailureReasonT = Aws::String>
  Scan& WithFailureReason(FailureReasonT&& value) {
    SetFailureReason(std::forward<FailureReasonT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetScanStartTime() const { return m_scanStartTime; }
  inline bool ScanStartTimeHasBeenSet() const { return m_scanStartTimeHasBeenSet; }
  template <typename ScanStartTimeT = Aws::Utils::DateTime>
  void SetScanStartTime(ScanStartTimeT&& value) {
    m_scanStartTimeHasBeenSet = true;
    m_scanStartTime = std::forward<ScanStartTimeT>(value);
  }
  template <typename ScanStartTimeT = Aws::Utils::DateTime>
  Scan& WithScanStartTime(ScanStartTimeT&& value) {
    SetScanStartTime(std::forward<ScanStartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetScanEndTime() const { return m_scanEndTime; }
  inline bool ScanEndTimeHasBeenSet() const { return m_scanEndTimeHasBeenSet; }
  template <typename ScanEndTimeT = Aws::Utils::DateTime>
  void SetScanEndTime(ScanEndTimeT&& value) {
    m_scanEndTimeHasBeenSet = true;
    m_scanEndTime = std::forward<ScanEndTimeT>(value);
  }
  template <typename ScanEndTimeT = Aws::Utils::DateTime>
  Scan& WithScanEndTime(ScanEndTimeT&& value) {
    SetScanEndTime(std::forward<ScanEndTimeT>(value));
    return *this;
  }
 
 
  inline const TriggerDetails& GetTriggerDetails() const { return m_triggerDetails; }
  inline bool TriggerDetailsHasBeenSet() const { return m_triggerDetailsHasBeenSet; }
  template <typename TriggerDetailsT = TriggerDetails>
  void SetTriggerDetails(TriggerDetailsT&& value) {
    m_triggerDetailsHasBeenSet = true;
    m_triggerDetails = std::forward<TriggerDetailsT>(value);
  }
  template <typename TriggerDetailsT = TriggerDetails>
  Scan& WithTriggerDetails(TriggerDetailsT&& value) {
    SetTriggerDetails(std::forward<TriggerDetailsT>(value));
    return *this;
  }
 
 
  inline const ResourceDetails& GetResourceDetails() const { return m_resourceDetails; }
  inline bool ResourceDetailsHasBeenSet() const { return m_resourceDetailsHasBeenSet; }
  template <typename ResourceDetailsT = ResourceDetails>
  void SetResourceDetails(ResourceDetailsT&& value) {
    m_resourceDetailsHasBeenSet = true;
    m_resourceDetails = std::forward<ResourceDetailsT>(value);
  }
  template <typename ResourceDetailsT = ResourceDetails>
  Scan& WithResourceDetails(ResourceDetailsT&& value) {
    SetResourceDetails(std::forward<ResourceDetailsT>(value));
    return *this;
  }
 
 
  inline const ScanResultDetails& GetScanResultDetails() const { return m_scanResultDetails; }
  inline bool ScanResultDetailsHasBeenSet() const { return m_scanResultDetailsHasBeenSet; }
  template <typename ScanResultDetailsT = ScanResultDetails>
  void SetScanResultDetails(ScanResultDetailsT&& value) {
    m_scanResultDetailsHasBeenSet = true;
    m_scanResultDetails = std::forward<ScanResultDetailsT>(value);
  }
  template <typename ScanResultDetailsT = ScanResultDetails>
  Scan& WithScanResultDetails(ScanResultDetailsT&& value) {
    SetScanResultDetails(std::forward<ScanResultDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAccountId() const { return m_accountId; }
  inline bool AccountIdHasBeenSet() const { return m_accountIdHasBeenSet; }
  template <typename AccountIdT = Aws::String>
  void SetAccountId(AccountIdT&& value) {
    m_accountIdHasBeenSet = true;
    m_accountId = std::forward<AccountIdT>(value);
  }
  template <typename AccountIdT = Aws::String>
  Scan& WithAccountId(AccountIdT&& value) {
    SetAccountId(std::forward<AccountIdT>(value));
    return *this;
  }
 
 
  inline long long GetTotalBytes() const { return m_totalBytes; }
  inline bool TotalBytesHasBeenSet() const { return m_totalBytesHasBeenSet; }
  inline void SetTotalBytes(long long value) {
    m_totalBytesHasBeenSet = true;
    m_totalBytes = value;
  }
  inline Scan& WithTotalBytes(long long value) {
    SetTotalBytes(value);
    return *this;
  }
 
 
  inline long long GetFileCount() const { return m_fileCount; }
  inline bool FileCountHasBeenSet() const { return m_fileCountHasBeenSet; }
  inline void SetFileCount(long long value) {
    m_fileCountHasBeenSet = true;
    m_fileCount = value;
  }
  inline Scan& WithFileCount(long long value) {
    SetFileCount(value);
    return *this;
  }
 
 
  inline const Aws::Vector<VolumeDetail>& GetAttachedVolumes() const { return m_attachedVolumes; }
  inline bool AttachedVolumesHasBeenSet() const { return m_attachedVolumesHasBeenSet; }
  template <typename AttachedVolumesT = Aws::Vector<VolumeDetail>>
  void SetAttachedVolumes(AttachedVolumesT&& value) {
    m_attachedVolumesHasBeenSet = true;
    m_attachedVolumes = std::forward<AttachedVolumesT>(value);
  }
  template <typename AttachedVolumesT = Aws::Vector<VolumeDetail>>
  Scan& WithAttachedVolumes(AttachedVolumesT&& value) {
    SetAttachedVolumes(std::forward<AttachedVolumesT>(value));
    return *this;
  }
  template <typename AttachedVolumesT = VolumeDetail>
  Scan& AddAttachedVolumes(AttachedVolumesT&& value) {
    m_attachedVolumesHasBeenSet = true;
    m_attachedVolumes.emplace_back(std::forward<AttachedVolumesT>(value));
    return *this;
  }
 
 
  inline ScanType GetScanType() const { return m_scanType; }
  inline bool ScanTypeHasBeenSet() const { return m_scanTypeHasBeenSet; }
  inline void SetScanType(ScanType value) {
    m_scanTypeHasBeenSet = true;
    m_scanType = value;
  }
  inline Scan& WithScanType(ScanType value) {
    SetScanType(value);
    return *this;
  }
 private:
  Aws::String m_detectorId;
 
  Aws::String m_adminDetectorId;
 
  Aws::String m_scanId;
 
  ScanStatus m_scanStatus{ScanStatus::NOT_SET};
 
  Aws::String m_failureReason;
 
  Aws::Utils::DateTime m_scanStartTime{};
 
  Aws::Utils::DateTime m_scanEndTime{};
 
  TriggerDetails m_triggerDetails;
 
  ResourceDetails m_resourceDetails;
 
  ScanResultDetails m_scanResultDetails;
 
  Aws::String m_accountId;
 
  long long m_totalBytes{0};
 
  long long m_fileCount{0};
 
  Aws::Vector<VolumeDetail> m_attachedVolumes;
 
  ScanType m_scanType{ScanType::NOT_SET};
  bool m_detectorIdHasBeenSet = false;
  bool m_adminDetectorIdHasBeenSet = false;
  bool m_scanIdHasBeenSet = false;
  bool m_scanStatusHasBeenSet = false;
  bool m_failureReasonHasBeenSet = false;
  bool m_scanStartTimeHasBeenSet = false;
  bool m_scanEndTimeHasBeenSet = false;
  bool m_triggerDetailsHasBeenSet = false;
  bool m_resourceDetailsHasBeenSet = false;
  bool m_scanResultDetailsHasBeenSet = false;
  bool m_accountIdHasBeenSet = false;
  bool m_totalBytesHasBeenSet = false;
  bool m_fileCountHasBeenSet = false;
  bool m_attachedVolumesHasBeenSet = false;
  bool m_scanTypeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GuardDuty
}  // namespace Aws