Insight.h

 
#pragma once
#include <aws/xray/XRay_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/xray/model/ServiceId.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/xray/model/InsightState.h>
#include <aws/core/utils/DateTime.h>
#include <aws/xray/model/RequestImpactStatistics.h>
#include <aws/xray/model/InsightCategory.h>
#include <aws/xray/model/AnomalousService.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;
    bool m_insightIdHasBeenSet = false;
 
    Aws::String m_groupARN;
    bool m_groupARNHasBeenSet = false;
 
    Aws::String m_groupName;
    bool m_groupNameHasBeenSet = false;
 
    ServiceId m_rootCauseServiceId;
    bool m_rootCauseServiceIdHasBeenSet = false;
 
    Aws::Vector<InsightCategory> m_categories;
    bool m_categoriesHasBeenSet = false;
 
    InsightState m_state{InsightState::NOT_SET};
    bool m_stateHasBeenSet = false;
 
    Aws::Utils::DateTime m_startTime{};
    bool m_startTimeHasBeenSet = false;
 
    Aws::Utils::DateTime m_endTime{};
    bool m_endTimeHasBeenSet = false;
 
    Aws::String m_summary;
    bool m_summaryHasBeenSet = false;
 
    RequestImpactStatistics m_clientRequestImpactStatistics;
    bool m_clientRequestImpactStatisticsHasBeenSet = false;
 
    RequestImpactStatistics m_rootCauseServiceRequestImpactStatistics;
    bool m_rootCauseServiceRequestImpactStatisticsHasBeenSet = false;
 
    Aws::Vector<AnomalousService> m_topAnomalousServices;
    bool m_topAnomalousServicesHasBeenSet = false;
  };
 
} // namespace Model
} // namespace XRay
} // namespace Aws