ImageFinding.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ec2/EC2_EXPORTS.h>
#include <aws/ec2/model/SeverityLabel.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace EC2 {
namespace Model {
 
class ImageFinding {
 public:
  AWS_EC2_API ImageFinding() = default;
  AWS_EC2_API ImageFinding(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_EC2_API ImageFinding& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_EC2_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_EC2_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline bool GetFixAvailable() const { return m_fixAvailable; }
  inline bool FixAvailableHasBeenSet() const { return m_fixAvailableHasBeenSet; }
  inline void SetFixAvailable(bool value) {
    m_fixAvailableHasBeenSet = true;
    m_fixAvailable = value;
  }
  inline ImageFinding& WithFixAvailable(bool value) {
    SetFixAvailable(value);
    return *this;
  }
 
 
  inline double GetScore() const { return m_score; }
  inline bool ScoreHasBeenSet() const { return m_scoreHasBeenSet; }
  inline void SetScore(double value) {
    m_scoreHasBeenSet = true;
    m_score = value;
  }
  inline ImageFinding& WithScore(double value) {
    SetScore(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetFirstObservedAt() const { return m_firstObservedAt; }
  inline bool FirstObservedAtHasBeenSet() const { return m_firstObservedAtHasBeenSet; }
  template <typename FirstObservedAtT = Aws::Utils::DateTime>
  void SetFirstObservedAt(FirstObservedAtT&& value) {
    m_firstObservedAtHasBeenSet = true;
    m_firstObservedAt = std::forward<FirstObservedAtT>(value);
  }
  template <typename FirstObservedAtT = Aws::Utils::DateTime>
  ImageFinding& WithFirstObservedAt(FirstObservedAtT&& value) {
    SetFirstObservedAt(std::forward<FirstObservedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetUpdatedAt() const { return m_updatedAt; }
  inline bool UpdatedAtHasBeenSet() const { return m_updatedAtHasBeenSet; }
  template <typename UpdatedAtT = Aws::Utils::DateTime>
  void SetUpdatedAt(UpdatedAtT&& value) {
    m_updatedAtHasBeenSet = true;
    m_updatedAt = std::forward<UpdatedAtT>(value);
  }
  template <typename UpdatedAtT = Aws::Utils::DateTime>
  ImageFinding& WithUpdatedAt(UpdatedAtT&& value) {
    SetUpdatedAt(std::forward<UpdatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTitle() const { return m_title; }
  inline bool TitleHasBeenSet() const { return m_titleHasBeenSet; }
  template <typename TitleT = Aws::String>
  void SetTitle(TitleT&& value) {
    m_titleHasBeenSet = true;
    m_title = std::forward<TitleT>(value);
  }
  template <typename TitleT = Aws::String>
  ImageFinding& WithTitle(TitleT&& value) {
    SetTitle(std::forward<TitleT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetPaths() const { return m_paths; }
  inline bool PathsHasBeenSet() const { return m_pathsHasBeenSet; }
  template <typename PathsT = Aws::Vector<Aws::String>>
  void SetPaths(PathsT&& value) {
    m_pathsHasBeenSet = true;
    m_paths = std::forward<PathsT>(value);
  }
  template <typename PathsT = Aws::Vector<Aws::String>>
  ImageFinding& WithPaths(PathsT&& value) {
    SetPaths(std::forward<PathsT>(value));
    return *this;
  }
  template <typename PathsT = Aws::String>
  ImageFinding& AddPaths(PathsT&& value) {
    m_pathsHasBeenSet = true;
    m_paths.emplace_back(std::forward<PathsT>(value));
    return *this;
  }
 
 
  inline SeverityLabel GetSeverityLabel() const { return m_severityLabel; }
  inline bool SeverityLabelHasBeenSet() const { return m_severityLabelHasBeenSet; }
  inline void SetSeverityLabel(SeverityLabel value) {
    m_severityLabelHasBeenSet = true;
    m_severityLabel = value;
  }
  inline ImageFinding& WithSeverityLabel(SeverityLabel value) {
    SetSeverityLabel(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSnapshotId() const { return m_snapshotId; }
  inline bool SnapshotIdHasBeenSet() const { return m_snapshotIdHasBeenSet; }
  template <typename SnapshotIdT = Aws::String>
  void SetSnapshotId(SnapshotIdT&& value) {
    m_snapshotIdHasBeenSet = true;
    m_snapshotId = std::forward<SnapshotIdT>(value);
  }
  template <typename SnapshotIdT = Aws::String>
  ImageFinding& WithSnapshotId(SnapshotIdT&& value) {
    SetSnapshotId(std::forward<SnapshotIdT>(value));
    return *this;
  }
 private:
  bool m_fixAvailable{false};
 
  double m_score{0.0};
 
  Aws::Utils::DateTime m_firstObservedAt{};
 
  Aws::Utils::DateTime m_updatedAt{};
 
  Aws::String m_title;
 
  Aws::Vector<Aws::String> m_paths;
 
  SeverityLabel m_severityLabel{SeverityLabel::NOT_SET};
 
  Aws::String m_snapshotId;
  bool m_fixAvailableHasBeenSet = false;
  bool m_scoreHasBeenSet = false;
  bool m_firstObservedAtHasBeenSet = false;
  bool m_updatedAtHasBeenSet = false;
  bool m_titleHasBeenSet = false;
  bool m_pathsHasBeenSet = false;
  bool m_severityLabelHasBeenSet = false;
  bool m_snapshotIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EC2
}  // namespace Aws