ReportGenerator.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/license-manager/LicenseManager_EXPORTS.h>
#include <aws/license-manager/model/ReportContext.h>
#include <aws/license-manager/model/ReportFrequency.h>
#include <aws/license-manager/model/ReportType.h>
#include <aws/license-manager/model/S3Location.h>
#include <aws/license-manager/model/Tag.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace LicenseManager {
namespace Model {
 
class ReportGenerator {
 public:
  AWS_LICENSEMANAGER_API ReportGenerator() = default;
  AWS_LICENSEMANAGER_API ReportGenerator(Aws::Utils::Json::JsonView jsonValue);
  AWS_LICENSEMANAGER_API ReportGenerator& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_LICENSEMANAGER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetReportGeneratorName() const { return m_reportGeneratorName; }
  inline bool ReportGeneratorNameHasBeenSet() const { return m_reportGeneratorNameHasBeenSet; }
  template <typename ReportGeneratorNameT = Aws::String>
  void SetReportGeneratorName(ReportGeneratorNameT&& value) {
    m_reportGeneratorNameHasBeenSet = true;
    m_reportGeneratorName = std::forward<ReportGeneratorNameT>(value);
  }
  template <typename ReportGeneratorNameT = Aws::String>
  ReportGenerator& WithReportGeneratorName(ReportGeneratorNameT&& value) {
    SetReportGeneratorName(std::forward<ReportGeneratorNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ReportType>& GetReportType() const { return m_reportType; }
  inline bool ReportTypeHasBeenSet() const { return m_reportTypeHasBeenSet; }
  template <typename ReportTypeT = Aws::Vector<ReportType>>
  void SetReportType(ReportTypeT&& value) {
    m_reportTypeHasBeenSet = true;
    m_reportType = std::forward<ReportTypeT>(value);
  }
  template <typename ReportTypeT = Aws::Vector<ReportType>>
  ReportGenerator& WithReportType(ReportTypeT&& value) {
    SetReportType(std::forward<ReportTypeT>(value));
    return *this;
  }
  inline ReportGenerator& AddReportType(ReportType value) {
    m_reportTypeHasBeenSet = true;
    m_reportType.push_back(value);
    return *this;
  }
 
 
  inline const ReportContext& GetReportContext() const { return m_reportContext; }
  inline bool ReportContextHasBeenSet() const { return m_reportContextHasBeenSet; }
  template <typename ReportContextT = ReportContext>
  void SetReportContext(ReportContextT&& value) {
    m_reportContextHasBeenSet = true;
    m_reportContext = std::forward<ReportContextT>(value);
  }
  template <typename ReportContextT = ReportContext>
  ReportGenerator& WithReportContext(ReportContextT&& value) {
    SetReportContext(std::forward<ReportContextT>(value));
    return *this;
  }
 
 
  inline const ReportFrequency& GetReportFrequency() const { return m_reportFrequency; }
  inline bool ReportFrequencyHasBeenSet() const { return m_reportFrequencyHasBeenSet; }
  template <typename ReportFrequencyT = ReportFrequency>
  void SetReportFrequency(ReportFrequencyT&& value) {
    m_reportFrequencyHasBeenSet = true;
    m_reportFrequency = std::forward<ReportFrequencyT>(value);
  }
  template <typename ReportFrequencyT = ReportFrequency>
  ReportGenerator& WithReportFrequency(ReportFrequencyT&& value) {
    SetReportFrequency(std::forward<ReportFrequencyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLicenseManagerReportGeneratorArn() const { return m_licenseManagerReportGeneratorArn; }
  inline bool LicenseManagerReportGeneratorArnHasBeenSet() const { return m_licenseManagerReportGeneratorArnHasBeenSet; }
  template <typename LicenseManagerReportGeneratorArnT = Aws::String>
  void SetLicenseManagerReportGeneratorArn(LicenseManagerReportGeneratorArnT&& value) {
    m_licenseManagerReportGeneratorArnHasBeenSet = true;
    m_licenseManagerReportGeneratorArn = std::forward<LicenseManagerReportGeneratorArnT>(value);
  }
  template <typename LicenseManagerReportGeneratorArnT = Aws::String>
  ReportGenerator& WithLicenseManagerReportGeneratorArn(LicenseManagerReportGeneratorArnT&& value) {
    SetLicenseManagerReportGeneratorArn(std::forward<LicenseManagerReportGeneratorArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLastRunStatus() const { return m_lastRunStatus; }
  inline bool LastRunStatusHasBeenSet() const { return m_lastRunStatusHasBeenSet; }
  template <typename LastRunStatusT = Aws::String>
  void SetLastRunStatus(LastRunStatusT&& value) {
    m_lastRunStatusHasBeenSet = true;
    m_lastRunStatus = std::forward<LastRunStatusT>(value);
  }
  template <typename LastRunStatusT = Aws::String>
  ReportGenerator& WithLastRunStatus(LastRunStatusT&& value) {
    SetLastRunStatus(std::forward<LastRunStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLastRunFailureReason() const { return m_lastRunFailureReason; }
  inline bool LastRunFailureReasonHasBeenSet() const { return m_lastRunFailureReasonHasBeenSet; }
  template <typename LastRunFailureReasonT = Aws::String>
  void SetLastRunFailureReason(LastRunFailureReasonT&& value) {
    m_lastRunFailureReasonHasBeenSet = true;
    m_lastRunFailureReason = std::forward<LastRunFailureReasonT>(value);
  }
  template <typename LastRunFailureReasonT = Aws::String>
  ReportGenerator& WithLastRunFailureReason(LastRunFailureReasonT&& value) {
    SetLastRunFailureReason(std::forward<LastRunFailureReasonT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLastReportGenerationTime() const { return m_lastReportGenerationTime; }
  inline bool LastReportGenerationTimeHasBeenSet() const { return m_lastReportGenerationTimeHasBeenSet; }
  template <typename LastReportGenerationTimeT = Aws::String>
  void SetLastReportGenerationTime(LastReportGenerationTimeT&& value) {
    m_lastReportGenerationTimeHasBeenSet = true;
    m_lastReportGenerationTime = std::forward<LastReportGenerationTimeT>(value);
  }
  template <typename LastReportGenerationTimeT = Aws::String>
  ReportGenerator& WithLastReportGenerationTime(LastReportGenerationTimeT&& value) {
    SetLastReportGenerationTime(std::forward<LastReportGenerationTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReportCreatorAccount() const { return m_reportCreatorAccount; }
  inline bool ReportCreatorAccountHasBeenSet() const { return m_reportCreatorAccountHasBeenSet; }
  template <typename ReportCreatorAccountT = Aws::String>
  void SetReportCreatorAccount(ReportCreatorAccountT&& value) {
    m_reportCreatorAccountHasBeenSet = true;
    m_reportCreatorAccount = std::forward<ReportCreatorAccountT>(value);
  }
  template <typename ReportCreatorAccountT = Aws::String>
  ReportGenerator& WithReportCreatorAccount(ReportCreatorAccountT&& value) {
    SetReportCreatorAccount(std::forward<ReportCreatorAccountT>(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>
  ReportGenerator& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const S3Location& GetS3Location() const { return m_s3Location; }
  inline bool S3LocationHasBeenSet() const { return m_s3LocationHasBeenSet; }
  template <typename S3LocationT = S3Location>
  void SetS3Location(S3LocationT&& value) {
    m_s3LocationHasBeenSet = true;
    m_s3Location = std::forward<S3LocationT>(value);
  }
  template <typename S3LocationT = S3Location>
  ReportGenerator& WithS3Location(S3LocationT&& value) {
    SetS3Location(std::forward<S3LocationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCreateTime() const { return m_createTime; }
  inline bool CreateTimeHasBeenSet() const { return m_createTimeHasBeenSet; }
  template <typename CreateTimeT = Aws::String>
  void SetCreateTime(CreateTimeT&& value) {
    m_createTimeHasBeenSet = true;
    m_createTime = std::forward<CreateTimeT>(value);
  }
  template <typename CreateTimeT = Aws::String>
  ReportGenerator& WithCreateTime(CreateTimeT&& value) {
    SetCreateTime(std::forward<CreateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  ReportGenerator& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  ReportGenerator& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 private:
  Aws::String m_reportGeneratorName;
 
  Aws::Vector<ReportType> m_reportType;
 
  ReportContext m_reportContext;
 
  ReportFrequency m_reportFrequency;
 
  Aws::String m_licenseManagerReportGeneratorArn;
 
  Aws::String m_lastRunStatus;
 
  Aws::String m_lastRunFailureReason;
 
  Aws::String m_lastReportGenerationTime;
 
  Aws::String m_reportCreatorAccount;
 
  Aws::String m_description;
 
  S3Location m_s3Location;
 
  Aws::String m_createTime;
 
  Aws::Vector<Tag> m_tags;
  bool m_reportGeneratorNameHasBeenSet = false;
  bool m_reportTypeHasBeenSet = false;
  bool m_reportContextHasBeenSet = false;
  bool m_reportFrequencyHasBeenSet = false;
  bool m_licenseManagerReportGeneratorArnHasBeenSet = false;
  bool m_lastRunStatusHasBeenSet = false;
  bool m_lastRunFailureReasonHasBeenSet = false;
  bool m_lastReportGenerationTimeHasBeenSet = false;
  bool m_reportCreatorAccountHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_s3LocationHasBeenSet = false;
  bool m_createTimeHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace LicenseManager
}  // namespace Aws