FindingVulnerability.h

 
#pragma once
#include <aws/continuum/Continuum_EXPORTS.h>
#include <aws/continuum/model/AffectedPackage.h>
#include <aws/continuum/model/FindingLocation.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Continuum {
namespace Model {
 
class FindingVulnerability {
 public:
  AWS_CONTINUUM_API FindingVulnerability() = default;
  AWS_CONTINUUM_API FindingVulnerability(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONTINUUM_API FindingVulnerability& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONTINUUM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  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>
  FindingVulnerability& WithTitle(TitleT&& value) {
    SetTitle(std::forward<TitleT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  FindingVulnerability& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCweId() const { return m_cweId; }
  inline bool CweIdHasBeenSet() const { return m_cweIdHasBeenSet; }
  template <typename CweIdT = Aws::String>
  void SetCweId(CweIdT&& value) {
    m_cweIdHasBeenSet = true;
    m_cweId = std::forward<CweIdT>(value);
  }
  template <typename CweIdT = Aws::String>
  FindingVulnerability& WithCweId(CweIdT&& value) {
    SetCweId(std::forward<CweIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCweCaption() const { return m_cweCaption; }
  inline bool CweCaptionHasBeenSet() const { return m_cweCaptionHasBeenSet; }
  template <typename CweCaptionT = Aws::String>
  void SetCweCaption(CweCaptionT&& value) {
    m_cweCaptionHasBeenSet = true;
    m_cweCaption = std::forward<CweCaptionT>(value);
  }
  template <typename CweCaptionT = Aws::String>
  FindingVulnerability& WithCweCaption(CweCaptionT&& value) {
    SetCweCaption(std::forward<CweCaptionT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAdditionalCweIds() const { return m_additionalCweIds; }
  inline bool AdditionalCweIdsHasBeenSet() const { return m_additionalCweIdsHasBeenSet; }
  template <typename AdditionalCweIdsT = Aws::Vector<Aws::String>>
  void SetAdditionalCweIds(AdditionalCweIdsT&& value) {
    m_additionalCweIdsHasBeenSet = true;
    m_additionalCweIds = std::forward<AdditionalCweIdsT>(value);
  }
  template <typename AdditionalCweIdsT = Aws::Vector<Aws::String>>
  FindingVulnerability& WithAdditionalCweIds(AdditionalCweIdsT&& value) {
    SetAdditionalCweIds(std::forward<AdditionalCweIdsT>(value));
    return *this;
  }
  template <typename AdditionalCweIdsT = Aws::String>
  FindingVulnerability& AddAdditionalCweIds(AdditionalCweIdsT&& value) {
    m_additionalCweIdsHasBeenSet = true;
    m_additionalCweIds.emplace_back(std::forward<AdditionalCweIdsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCveId() const { return m_cveId; }
  inline bool CveIdHasBeenSet() const { return m_cveIdHasBeenSet; }
  template <typename CveIdT = Aws::String>
  void SetCveId(CveIdT&& value) {
    m_cveIdHasBeenSet = true;
    m_cveId = std::forward<CveIdT>(value);
  }
  template <typename CveIdT = Aws::String>
  FindingVulnerability& WithCveId(CveIdT&& value) {
    SetCveId(std::forward<CveIdT>(value));
    return *this;
  }
 
 
  inline double GetCvssBaseScore() const { return m_cvssBaseScore; }
  inline bool CvssBaseScoreHasBeenSet() const { return m_cvssBaseScoreHasBeenSet; }
  inline void SetCvssBaseScore(double value) {
    m_cvssBaseScoreHasBeenSet = true;
    m_cvssBaseScore = value;
  }
  inline FindingVulnerability& WithCvssBaseScore(double value) {
    SetCvssBaseScore(value);
    return *this;
  }
 
 
  inline const Aws::String& GetFixCoverage() const { return m_fixCoverage; }
  inline bool FixCoverageHasBeenSet() const { return m_fixCoverageHasBeenSet; }
  template <typename FixCoverageT = Aws::String>
  void SetFixCoverage(FixCoverageT&& value) {
    m_fixCoverageHasBeenSet = true;
    m_fixCoverage = std::forward<FixCoverageT>(value);
  }
  template <typename FixCoverageT = Aws::String>
  FindingVulnerability& WithFixCoverage(FixCoverageT&& value) {
    SetFixCoverage(std::forward<FixCoverageT>(value));
    return *this;
  }
 
 
  inline int GetFixCoverageId() const { return m_fixCoverageId; }
  inline bool FixCoverageIdHasBeenSet() const { return m_fixCoverageIdHasBeenSet; }
  inline void SetFixCoverageId(int value) {
    m_fixCoverageIdHasBeenSet = true;
    m_fixCoverageId = value;
  }
  inline FindingVulnerability& WithFixCoverageId(int value) {
    SetFixCoverageId(value);
    return *this;
  }
 
 
  inline const Aws::Vector<FindingLocation>& GetLocations() const { return m_locations; }
  inline bool LocationsHasBeenSet() const { return m_locationsHasBeenSet; }
  template <typename LocationsT = Aws::Vector<FindingLocation>>
  void SetLocations(LocationsT&& value) {
    m_locationsHasBeenSet = true;
    m_locations = std::forward<LocationsT>(value);
  }
  template <typename LocationsT = Aws::Vector<FindingLocation>>
  FindingVulnerability& WithLocations(LocationsT&& value) {
    SetLocations(std::forward<LocationsT>(value));
    return *this;
  }
  template <typename LocationsT = FindingLocation>
  FindingVulnerability& AddLocations(LocationsT&& value) {
    m_locationsHasBeenSet = true;
    m_locations.emplace_back(std::forward<LocationsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRemediation() const { return m_remediation; }
  inline bool RemediationHasBeenSet() const { return m_remediationHasBeenSet; }
  template <typename RemediationT = Aws::String>
  void SetRemediation(RemediationT&& value) {
    m_remediationHasBeenSet = true;
    m_remediation = std::forward<RemediationT>(value);
  }
  template <typename RemediationT = Aws::String>
  FindingVulnerability& WithRemediation(RemediationT&& value) {
    SetRemediation(std::forward<RemediationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetRemediationReferences() const { return m_remediationReferences; }
  inline bool RemediationReferencesHasBeenSet() const { return m_remediationReferencesHasBeenSet; }
  template <typename RemediationReferencesT = Aws::Vector<Aws::String>>
  void SetRemediationReferences(RemediationReferencesT&& value) {
    m_remediationReferencesHasBeenSet = true;
    m_remediationReferences = std::forward<RemediationReferencesT>(value);
  }
  template <typename RemediationReferencesT = Aws::Vector<Aws::String>>
  FindingVulnerability& WithRemediationReferences(RemediationReferencesT&& value) {
    SetRemediationReferences(std::forward<RemediationReferencesT>(value));
    return *this;
  }
  template <typename RemediationReferencesT = Aws::String>
  FindingVulnerability& AddRemediationReferences(RemediationReferencesT&& value) {
    m_remediationReferencesHasBeenSet = true;
    m_remediationReferences.emplace_back(std::forward<RemediationReferencesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCode() const { return m_code; }
  inline bool CodeHasBeenSet() const { return m_codeHasBeenSet; }
  template <typename CodeT = Aws::String>
  void SetCode(CodeT&& value) {
    m_codeHasBeenSet = true;
    m_code = std::forward<CodeT>(value);
  }
  template <typename CodeT = Aws::String>
  FindingVulnerability& WithCode(CodeT&& value) {
    SetCode(std::forward<CodeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDetails() const { return m_details; }
  inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
  template <typename DetailsT = Aws::String>
  void SetDetails(DetailsT&& value) {
    m_detailsHasBeenSet = true;
    m_details = std::forward<DetailsT>(value);
  }
  template <typename DetailsT = Aws::String>
  FindingVulnerability& WithDetails(DetailsT&& value) {
    SetDetails(std::forward<DetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AffectedPackage>& GetAffectedPackages() const { return m_affectedPackages; }
  inline bool AffectedPackagesHasBeenSet() const { return m_affectedPackagesHasBeenSet; }
  template <typename AffectedPackagesT = Aws::Vector<AffectedPackage>>
  void SetAffectedPackages(AffectedPackagesT&& value) {
    m_affectedPackagesHasBeenSet = true;
    m_affectedPackages = std::forward<AffectedPackagesT>(value);
  }
  template <typename AffectedPackagesT = Aws::Vector<AffectedPackage>>
  FindingVulnerability& WithAffectedPackages(AffectedPackagesT&& value) {
    SetAffectedPackages(std::forward<AffectedPackagesT>(value));
    return *this;
  }
  template <typename AffectedPackagesT = AffectedPackage>
  FindingVulnerability& AddAffectedPackages(AffectedPackagesT&& value) {
    m_affectedPackagesHasBeenSet = true;
    m_affectedPackages.emplace_back(std::forward<AffectedPackagesT>(value));
    return *this;
  }
 private:
  Aws::String m_title;
 
  Aws::String m_description;
 
  Aws::String m_cweId;
 
  Aws::String m_cweCaption;
 
  Aws::Vector<Aws::String> m_additionalCweIds;
 
  Aws::String m_cveId;
 
  double m_cvssBaseScore{0.0};
 
  Aws::String m_fixCoverage;
 
  int m_fixCoverageId{0};
 
  Aws::Vector<FindingLocation> m_locations;
 
  Aws::String m_remediation;
 
  Aws::Vector<Aws::String> m_remediationReferences;
 
  Aws::String m_code;
 
  Aws::String m_details;
 
  Aws::Vector<AffectedPackage> m_affectedPackages;
  bool m_titleHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_cweIdHasBeenSet = false;
  bool m_cweCaptionHasBeenSet = false;
  bool m_additionalCweIdsHasBeenSet = false;
  bool m_cveIdHasBeenSet = false;
  bool m_cvssBaseScoreHasBeenSet = false;
  bool m_fixCoverageHasBeenSet = false;
  bool m_fixCoverageIdHasBeenSet = false;
  bool m_locationsHasBeenSet = false;
  bool m_remediationHasBeenSet = false;
  bool m_remediationReferencesHasBeenSet = false;
  bool m_codeHasBeenSet = false;
  bool m_detailsHasBeenSet = false;
  bool m_affectedPackagesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Continuum
}  // namespace Aws