Insight.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/xray/XRay_EXPORTS.h>
#include <aws/xray/model/AnomalousService.h>
#include <aws/xray/model/InsightCategory.h>
#include <aws/xray/model/InsightState.h>
#include <aws/xray/model/RequestImpactStatistics.h>
#include <aws/xray/model/ServiceId.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace XRay {
namespace Model {
 
class Insight {
 public:
  AWS_XRAY_API Insight() = default;
  AWS_XRAY_API Insight(Aws::Utils::Json::JsonView jsonValue);
  AWS_XRAY_API Insight& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_XRAY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetInsightId() const { return m_insightId; }
  inline bool InsightIdHasBeenSet() const { return m_insightIdHasBeenSet; }
  template <typename InsightIdT = Aws::String>
  void SetInsightId(InsightIdT&& value) {
    m_insightIdHasBeenSet = true;
    m_insightId = std::forward<InsightIdT>(value);
  }
  template <typename InsightIdT = Aws::String>
  Insight& WithInsightId(InsightIdT&& value) {
    SetInsightId(std::forward<InsightIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetGroupARN() const { return m_groupARN; }
  inline bool GroupARNHasBeenSet() const { return m_groupARNHasBeenSet; }
  template <typename GroupARNT = Aws::String>
  void SetGroupARN(GroupARNT&& value) {
    m_groupARNHasBeenSet = true;
    m_groupARN = std::forward<GroupARNT>(value);
  }
  template <typename GroupARNT = Aws::String>
  Insight& WithGroupARN(GroupARNT&& value) {
    SetGroupARN(std::forward<GroupARNT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetGroupName() const { return m_groupName; }
  inline bool GroupNameHasBeenSet() const { return m_groupNameHasBeenSet; }
  template <typename GroupNameT = Aws::String>
  void SetGroupName(GroupNameT&& value) {
    m_groupNameHasBeenSet = true;
    m_groupName = std::forward<GroupNameT>(value);
  }
  template <typename GroupNameT = Aws::String>
  Insight& WithGroupName(GroupNameT&& value) {
    SetGroupName(std::forward<GroupNameT>(value));
    return *this;
  }
 
 
  inline const ServiceId& GetRootCauseServiceId() const { return m_rootCauseServiceId; }
  inline bool RootCauseServiceIdHasBeenSet() const { return m_rootCauseServiceIdHasBeenSet; }
  template <typename RootCauseServiceIdT = ServiceId>
  void SetRootCauseServiceId(RootCauseServiceIdT&& value) {
    m_rootCauseServiceIdHasBeenSet = true;
    m_rootCauseServiceId = std::forward<RootCauseServiceIdT>(value);
  }
  template <typename RootCauseServiceIdT = ServiceId>
  Insight& WithRootCauseServiceId(RootCauseServiceIdT&& value) {
    SetRootCauseServiceId(std::forward<RootCauseServiceIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<InsightCategory>& GetCategories() const { return m_categories; }
  inline bool CategoriesHasBeenSet() const { return m_categoriesHasBeenSet; }
  template <typename CategoriesT = Aws::Vector<InsightCategory>>
  void SetCategories(CategoriesT&& value) {
    m_categoriesHasBeenSet = true;
    m_categories = std::forward<CategoriesT>(value);
  }
  template <typename CategoriesT = Aws::Vector<InsightCategory>>
  Insight& WithCategories(CategoriesT&& value) {
    SetCategories(std::forward<CategoriesT>(value));
    return *this;
  }
  inline Insight& AddCategories(InsightCategory value) {
    m_categoriesHasBeenSet = true;
    m_categories.push_back(value);
    return *this;
  }
 
 
  inline InsightState GetState() const { return m_state; }
  inline bool StateHasBeenSet() const { return m_stateHasBeenSet; }
  inline void SetState(InsightState value) {
    m_stateHasBeenSet = true;
    m_state = value;
  }
  inline Insight& WithState(InsightState value) {
    SetState(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStartTime() const { return m_startTime; }
  inline bool StartTimeHasBeenSet() const { return m_startTimeHasBeenSet; }
  template <typename StartTimeT = Aws::Utils::DateTime>
  void SetStartTime(StartTimeT&& value) {
    m_startTimeHasBeenSet = true;
    m_startTime = std::forward<StartTimeT>(value);
  }
  template <typename StartTimeT = Aws::Utils::DateTime>
  Insight& WithStartTime(StartTimeT&& value) {
    SetStartTime(std::forward<StartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetEndTime() const { return m_endTime; }
  inline bool EndTimeHasBeenSet() const { return m_endTimeHasBeenSet; }
  template <typename EndTimeT = Aws::Utils::DateTime>
  void SetEndTime(EndTimeT&& value) {
    m_endTimeHasBeenSet = true;
    m_endTime = std::forward<EndTimeT>(value);
  }
  template <typename EndTimeT = Aws::Utils::DateTime>
  Insight& WithEndTime(EndTimeT&& value) {
    SetEndTime(std::forward<EndTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSummary() const { return m_summary; }
  inline bool SummaryHasBeenSet() const { return m_summaryHasBeenSet; }
  template <typename SummaryT = Aws::String>
  void SetSummary(SummaryT&& value) {
    m_summaryHasBeenSet = true;
    m_summary = std::forward<SummaryT>(value);
  }
  template <typename SummaryT = Aws::String>
  Insight& WithSummary(SummaryT&& value) {
    SetSummary(std::forward<SummaryT>(value));
    return *this;
  }
 
 
  inline const RequestImpactStatistics& GetClientRequestImpactStatistics() const { return m_clientRequestImpactStatistics; }
  inline bool ClientRequestImpactStatisticsHasBeenSet() const { return m_clientRequestImpactStatisticsHasBeenSet; }
  template <typename ClientRequestImpactStatisticsT = RequestImpactStatistics>
  void SetClientRequestImpactStatistics(ClientRequestImpactStatisticsT&& value) {
    m_clientRequestImpactStatisticsHasBeenSet = true;
    m_clientRequestImpactStatistics = std::forward<ClientRequestImpactStatisticsT>(value);
  }
  template <typename ClientRequestImpactStatisticsT = RequestImpactStatistics>
  Insight& WithClientRequestImpactStatistics(ClientRequestImpactStatisticsT&& value) {
    SetClientRequestImpactStatistics(std::forward<ClientRequestImpactStatisticsT>(value));
    return *this;
  }
 
 
  inline const RequestImpactStatistics& GetRootCauseServiceRequestImpactStatistics() const {
    return m_rootCauseServiceRequestImpactStatistics;
  }
  inline bool RootCauseServiceRequestImpactStatisticsHasBeenSet() const { return m_rootCauseServiceRequestImpactStatisticsHasBeenSet; }
  template <typename RootCauseServiceRequestImpactStatisticsT = RequestImpactStatistics>
  void SetRootCauseServiceRequestImpactStatistics(RootCauseServiceRequestImpactStatisticsT&& value) {
    m_rootCauseServiceRequestImpactStatisticsHasBeenSet = true;
    m_rootCauseServiceRequestImpactStatistics = std::forward<RootCauseServiceRequestImpactStatisticsT>(value);
  }
  template <typename RootCauseServiceRequestImpactStatisticsT = RequestImpactStatistics>
  Insight& WithRootCauseServiceRequestImpactStatistics(RootCauseServiceRequestImpactStatisticsT&& value) {
    SetRootCauseServiceRequestImpactStatistics(std::forward<RootCauseServiceRequestImpactStatisticsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AnomalousService>& GetTopAnomalousServices() const { return m_topAnomalousServices; }
  inline bool TopAnomalousServicesHasBeenSet() const { return m_topAnomalousServicesHasBeenSet; }
  template <typename TopAnomalousServicesT = Aws::Vector<AnomalousService>>
  void SetTopAnomalousServices(TopAnomalousServicesT&& value) {
    m_topAnomalousServicesHasBeenSet = true;
    m_topAnomalousServices = std::forward<TopAnomalousServicesT>(value);
  }
  template <typename TopAnomalousServicesT = Aws::Vector<AnomalousService>>
  Insight& WithTopAnomalousServices(TopAnomalousServicesT&& value) {
    SetTopAnomalousServices(std::forward<TopAnomalousServicesT>(value));
    return *this;
  }
  template <typename TopAnomalousServicesT = AnomalousService>
  Insight& AddTopAnomalousServices(TopAnomalousServicesT&& value) {
    m_topAnomalousServicesHasBeenSet = true;
    m_topAnomalousServices.emplace_back(std::forward<TopAnomalousServicesT>(value));
    return *this;
  }
 private:
  Aws::String m_insightId;
 
  Aws::String m_groupARN;
 
  Aws::String m_groupName;
 
  ServiceId m_rootCauseServiceId;
 
  Aws::Vector<InsightCategory> m_categories;
 
  InsightState m_state{InsightState::NOT_SET};
 
  Aws::Utils::DateTime m_startTime{};
 
  Aws::Utils::DateTime m_endTime{};
 
  Aws::String m_summary;
 
  RequestImpactStatistics m_clientRequestImpactStatistics;
 
  RequestImpactStatistics m_rootCauseServiceRequestImpactStatistics;
 
  Aws::Vector<AnomalousService> m_topAnomalousServices;
  bool m_insightIdHasBeenSet = false;
  bool m_groupARNHasBeenSet = false;
  bool m_groupNameHasBeenSet = false;
  bool m_rootCauseServiceIdHasBeenSet = false;
  bool m_categoriesHasBeenSet = false;
  bool m_stateHasBeenSet = false;
  bool m_startTimeHasBeenSet = false;
  bool m_endTimeHasBeenSet = false;
  bool m_summaryHasBeenSet = false;
  bool m_clientRequestImpactStatisticsHasBeenSet = false;
  bool m_rootCauseServiceRequestImpactStatisticsHasBeenSet = false;
  bool m_topAnomalousServicesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace XRay
}  // namespace Aws