Visual.h

 
#pragma once
#include <aws/quicksight/QuickSight_EXPORTS.h>
#include <aws/quicksight/model/BarChartVisual.h>
#include <aws/quicksight/model/BoxPlotVisual.h>
#include <aws/quicksight/model/ComboChartVisual.h>
#include <aws/quicksight/model/CustomContentVisual.h>
#include <aws/quicksight/model/EmptyVisual.h>
#include <aws/quicksight/model/FilledMapVisual.h>
#include <aws/quicksight/model/FunnelChartVisual.h>
#include <aws/quicksight/model/GaugeChartVisual.h>
#include <aws/quicksight/model/GeospatialMapVisual.h>
#include <aws/quicksight/model/HeatMapVisual.h>
#include <aws/quicksight/model/HistogramVisual.h>
#include <aws/quicksight/model/InsightVisual.h>
#include <aws/quicksight/model/KPIVisual.h>
#include <aws/quicksight/model/LayerMapVisual.h>
#include <aws/quicksight/model/LineChartVisual.h>
#include <aws/quicksight/model/PieChartVisual.h>
#include <aws/quicksight/model/PivotTableVisual.h>
#include <aws/quicksight/model/PluginVisual.h>
#include <aws/quicksight/model/RadarChartVisual.h>
#include <aws/quicksight/model/SankeyDiagramVisual.h>
#include <aws/quicksight/model/ScatterPlotVisual.h>
#include <aws/quicksight/model/TableVisual.h>
#include <aws/quicksight/model/TreeMapVisual.h>
#include <aws/quicksight/model/WaterfallVisual.h>
#include <aws/quicksight/model/WordCloudVisual.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace QuickSight {
namespace Model {
 
class Visual {
 public:
  AWS_QUICKSIGHT_API Visual() = default;
  AWS_QUICKSIGHT_API Visual(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API Visual& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const TableVisual& GetTableVisual() const { return m_tableVisual; }
  inline bool TableVisualHasBeenSet() const { return m_tableVisualHasBeenSet; }
  template <typename TableVisualT = TableVisual>
  void SetTableVisual(TableVisualT&& value) {
    m_tableVisualHasBeenSet = true;
    m_tableVisual = std::forward<TableVisualT>(value);
  }
  template <typename TableVisualT = TableVisual>
  Visual& WithTableVisual(TableVisualT&& value) {
    SetTableVisual(std::forward<TableVisualT>(value));
    return *this;
  }
 
 
  inline const PivotTableVisual& GetPivotTableVisual() const { return m_pivotTableVisual; }
  inline bool PivotTableVisualHasBeenSet() const { return m_pivotTableVisualHasBeenSet; }
  template <typename PivotTableVisualT = PivotTableVisual>
  void SetPivotTableVisual(PivotTableVisualT&& value) {
    m_pivotTableVisualHasBeenSet = true;
    m_pivotTableVisual = std::forward<PivotTableVisualT>(value);
  }
  template <typename PivotTableVisualT = PivotTableVisual>
  Visual& WithPivotTableVisual(PivotTableVisualT&& value) {
    SetPivotTableVisual(std::forward<PivotTableVisualT>(value));
    return *this;
  }
 
 
  inline const BarChartVisual& GetBarChartVisual() const { return m_barChartVisual; }
  inline bool BarChartVisualHasBeenSet() const { return m_barChartVisualHasBeenSet; }
  template <typename BarChartVisualT = BarChartVisual>
  void SetBarChartVisual(BarChartVisualT&& value) {
    m_barChartVisualHasBeenSet = true;
    m_barChartVisual = std::forward<BarChartVisualT>(value);
  }
  template <typename BarChartVisualT = BarChartVisual>
  Visual& WithBarChartVisual(BarChartVisualT&& value) {
    SetBarChartVisual(std::forward<BarChartVisualT>(value));
    return *this;
  }
 
 
  inline const KPIVisual& GetKPIVisual() const { return m_kPIVisual; }
  inline bool KPIVisualHasBeenSet() const { return m_kPIVisualHasBeenSet; }
  template <typename KPIVisualT = KPIVisual>
  void SetKPIVisual(KPIVisualT&& value) {
    m_kPIVisualHasBeenSet = true;
    m_kPIVisual = std::forward<KPIVisualT>(value);
  }
  template <typename KPIVisualT = KPIVisual>
  Visual& WithKPIVisual(KPIVisualT&& value) {
    SetKPIVisual(std::forward<KPIVisualT>(value));
    return *this;
  }
 
 
  inline const PieChartVisual& GetPieChartVisual() const { return m_pieChartVisual; }
  inline bool PieChartVisualHasBeenSet() const { return m_pieChartVisualHasBeenSet; }
  template <typename PieChartVisualT = PieChartVisual>
  void SetPieChartVisual(PieChartVisualT&& value) {
    m_pieChartVisualHasBeenSet = true;
    m_pieChartVisual = std::forward<PieChartVisualT>(value);
  }
  template <typename PieChartVisualT = PieChartVisual>
  Visual& WithPieChartVisual(PieChartVisualT&& value) {
    SetPieChartVisual(std::forward<PieChartVisualT>(value));
    return *this;
  }
 
 
  inline const GaugeChartVisual& GetGaugeChartVisual() const { return m_gaugeChartVisual; }
  inline bool GaugeChartVisualHasBeenSet() const { return m_gaugeChartVisualHasBeenSet; }
  template <typename GaugeChartVisualT = GaugeChartVisual>
  void SetGaugeChartVisual(GaugeChartVisualT&& value) {
    m_gaugeChartVisualHasBeenSet = true;
    m_gaugeChartVisual = std::forward<GaugeChartVisualT>(value);
  }
  template <typename GaugeChartVisualT = GaugeChartVisual>
  Visual& WithGaugeChartVisual(GaugeChartVisualT&& value) {
    SetGaugeChartVisual(std::forward<GaugeChartVisualT>(value));
    return *this;
  }
 
 
  inline const LineChartVisual& GetLineChartVisual() const { return m_lineChartVisual; }
  inline bool LineChartVisualHasBeenSet() const { return m_lineChartVisualHasBeenSet; }
  template <typename LineChartVisualT = LineChartVisual>
  void SetLineChartVisual(LineChartVisualT&& value) {
    m_lineChartVisualHasBeenSet = true;
    m_lineChartVisual = std::forward<LineChartVisualT>(value);
  }
  template <typename LineChartVisualT = LineChartVisual>
  Visual& WithLineChartVisual(LineChartVisualT&& value) {
    SetLineChartVisual(std::forward<LineChartVisualT>(value));
    return *this;
  }
 
 
  inline const HeatMapVisual& GetHeatMapVisual() const { return m_heatMapVisual; }
  inline bool HeatMapVisualHasBeenSet() const { return m_heatMapVisualHasBeenSet; }
  template <typename HeatMapVisualT = HeatMapVisual>
  void SetHeatMapVisual(HeatMapVisualT&& value) {
    m_heatMapVisualHasBeenSet = true;
    m_heatMapVisual = std::forward<HeatMapVisualT>(value);
  }
  template <typename HeatMapVisualT = HeatMapVisual>
  Visual& WithHeatMapVisual(HeatMapVisualT&& value) {
    SetHeatMapVisual(std::forward<HeatMapVisualT>(value));
    return *this;
  }
 
 
  inline const TreeMapVisual& GetTreeMapVisual() const { return m_treeMapVisual; }
  inline bool TreeMapVisualHasBeenSet() const { return m_treeMapVisualHasBeenSet; }
  template <typename TreeMapVisualT = TreeMapVisual>
  void SetTreeMapVisual(TreeMapVisualT&& value) {
    m_treeMapVisualHasBeenSet = true;
    m_treeMapVisual = std::forward<TreeMapVisualT>(value);
  }
  template <typename TreeMapVisualT = TreeMapVisual>
  Visual& WithTreeMapVisual(TreeMapVisualT&& value) {
    SetTreeMapVisual(std::forward<TreeMapVisualT>(value));
    return *this;
  }
 
 
  inline const GeospatialMapVisual& GetGeospatialMapVisual() const { return m_geospatialMapVisual; }
  inline bool GeospatialMapVisualHasBeenSet() const { return m_geospatialMapVisualHasBeenSet; }
  template <typename GeospatialMapVisualT = GeospatialMapVisual>
  void SetGeospatialMapVisual(GeospatialMapVisualT&& value) {
    m_geospatialMapVisualHasBeenSet = true;
    m_geospatialMapVisual = std::forward<GeospatialMapVisualT>(value);
  }
  template <typename GeospatialMapVisualT = GeospatialMapVisual>
  Visual& WithGeospatialMapVisual(GeospatialMapVisualT&& value) {
    SetGeospatialMapVisual(std::forward<GeospatialMapVisualT>(value));
    return *this;
  }
 
 
  inline const FilledMapVisual& GetFilledMapVisual() const { return m_filledMapVisual; }
  inline bool FilledMapVisualHasBeenSet() const { return m_filledMapVisualHasBeenSet; }
  template <typename FilledMapVisualT = FilledMapVisual>
  void SetFilledMapVisual(FilledMapVisualT&& value) {
    m_filledMapVisualHasBeenSet = true;
    m_filledMapVisual = std::forward<FilledMapVisualT>(value);
  }
  template <typename FilledMapVisualT = FilledMapVisual>
  Visual& WithFilledMapVisual(FilledMapVisualT&& value) {
    SetFilledMapVisual(std::forward<FilledMapVisualT>(value));
    return *this;
  }
 
 
  inline const LayerMapVisual& GetLayerMapVisual() const { return m_layerMapVisual; }
  inline bool LayerMapVisualHasBeenSet() const { return m_layerMapVisualHasBeenSet; }
  template <typename LayerMapVisualT = LayerMapVisual>
  void SetLayerMapVisual(LayerMapVisualT&& value) {
    m_layerMapVisualHasBeenSet = true;
    m_layerMapVisual = std::forward<LayerMapVisualT>(value);
  }
  template <typename LayerMapVisualT = LayerMapVisual>
  Visual& WithLayerMapVisual(LayerMapVisualT&& value) {
    SetLayerMapVisual(std::forward<LayerMapVisualT>(value));
    return *this;
  }
 
 
  inline const FunnelChartVisual& GetFunnelChartVisual() const { return m_funnelChartVisual; }
  inline bool FunnelChartVisualHasBeenSet() const { return m_funnelChartVisualHasBeenSet; }
  template <typename FunnelChartVisualT = FunnelChartVisual>
  void SetFunnelChartVisual(FunnelChartVisualT&& value) {
    m_funnelChartVisualHasBeenSet = true;
    m_funnelChartVisual = std::forward<FunnelChartVisualT>(value);
  }
  template <typename FunnelChartVisualT = FunnelChartVisual>
  Visual& WithFunnelChartVisual(FunnelChartVisualT&& value) {
    SetFunnelChartVisual(std::forward<FunnelChartVisualT>(value));
    return *this;
  }
 
 
  inline const ScatterPlotVisual& GetScatterPlotVisual() const { return m_scatterPlotVisual; }
  inline bool ScatterPlotVisualHasBeenSet() const { return m_scatterPlotVisualHasBeenSet; }
  template <typename ScatterPlotVisualT = ScatterPlotVisual>
  void SetScatterPlotVisual(ScatterPlotVisualT&& value) {
    m_scatterPlotVisualHasBeenSet = true;
    m_scatterPlotVisual = std::forward<ScatterPlotVisualT>(value);
  }
  template <typename ScatterPlotVisualT = ScatterPlotVisual>
  Visual& WithScatterPlotVisual(ScatterPlotVisualT&& value) {
    SetScatterPlotVisual(std::forward<ScatterPlotVisualT>(value));
    return *this;
  }
 
 
  inline const ComboChartVisual& GetComboChartVisual() const { return m_comboChartVisual; }
  inline bool ComboChartVisualHasBeenSet() const { return m_comboChartVisualHasBeenSet; }
  template <typename ComboChartVisualT = ComboChartVisual>
  void SetComboChartVisual(ComboChartVisualT&& value) {
    m_comboChartVisualHasBeenSet = true;
    m_comboChartVisual = std::forward<ComboChartVisualT>(value);
  }
  template <typename ComboChartVisualT = ComboChartVisual>
  Visual& WithComboChartVisual(ComboChartVisualT&& value) {
    SetComboChartVisual(std::forward<ComboChartVisualT>(value));
    return *this;
  }
 
 
  inline const BoxPlotVisual& GetBoxPlotVisual() const { return m_boxPlotVisual; }
  inline bool BoxPlotVisualHasBeenSet() const { return m_boxPlotVisualHasBeenSet; }
  template <typename BoxPlotVisualT = BoxPlotVisual>
  void SetBoxPlotVisual(BoxPlotVisualT&& value) {
    m_boxPlotVisualHasBeenSet = true;
    m_boxPlotVisual = std::forward<BoxPlotVisualT>(value);
  }
  template <typename BoxPlotVisualT = BoxPlotVisual>
  Visual& WithBoxPlotVisual(BoxPlotVisualT&& value) {
    SetBoxPlotVisual(std::forward<BoxPlotVisualT>(value));
    return *this;
  }
 
 
  inline const WaterfallVisual& GetWaterfallVisual() const { return m_waterfallVisual; }
  inline bool WaterfallVisualHasBeenSet() const { return m_waterfallVisualHasBeenSet; }
  template <typename WaterfallVisualT = WaterfallVisual>
  void SetWaterfallVisual(WaterfallVisualT&& value) {
    m_waterfallVisualHasBeenSet = true;
    m_waterfallVisual = std::forward<WaterfallVisualT>(value);
  }
  template <typename WaterfallVisualT = WaterfallVisual>
  Visual& WithWaterfallVisual(WaterfallVisualT&& value) {
    SetWaterfallVisual(std::forward<WaterfallVisualT>(value));
    return *this;
  }
 
 
  inline const HistogramVisual& GetHistogramVisual() const { return m_histogramVisual; }
  inline bool HistogramVisualHasBeenSet() const { return m_histogramVisualHasBeenSet; }
  template <typename HistogramVisualT = HistogramVisual>
  void SetHistogramVisual(HistogramVisualT&& value) {
    m_histogramVisualHasBeenSet = true;
    m_histogramVisual = std::forward<HistogramVisualT>(value);
  }
  template <typename HistogramVisualT = HistogramVisual>
  Visual& WithHistogramVisual(HistogramVisualT&& value) {
    SetHistogramVisual(std::forward<HistogramVisualT>(value));
    return *this;
  }
 
 
  inline const WordCloudVisual& GetWordCloudVisual() const { return m_wordCloudVisual; }
  inline bool WordCloudVisualHasBeenSet() const { return m_wordCloudVisualHasBeenSet; }
  template <typename WordCloudVisualT = WordCloudVisual>
  void SetWordCloudVisual(WordCloudVisualT&& value) {
    m_wordCloudVisualHasBeenSet = true;
    m_wordCloudVisual = std::forward<WordCloudVisualT>(value);
  }
  template <typename WordCloudVisualT = WordCloudVisual>
  Visual& WithWordCloudVisual(WordCloudVisualT&& value) {
    SetWordCloudVisual(std::forward<WordCloudVisualT>(value));
    return *this;
  }
 
 
  inline const InsightVisual& GetInsightVisual() const { return m_insightVisual; }
  inline bool InsightVisualHasBeenSet() const { return m_insightVisualHasBeenSet; }
  template <typename InsightVisualT = InsightVisual>
  void SetInsightVisual(InsightVisualT&& value) {
    m_insightVisualHasBeenSet = true;
    m_insightVisual = std::forward<InsightVisualT>(value);
  }
  template <typename InsightVisualT = InsightVisual>
  Visual& WithInsightVisual(InsightVisualT&& value) {
    SetInsightVisual(std::forward<InsightVisualT>(value));
    return *this;
  }
 
 
  inline const SankeyDiagramVisual& GetSankeyDiagramVisual() const { return m_sankeyDiagramVisual; }
  inline bool SankeyDiagramVisualHasBeenSet() const { return m_sankeyDiagramVisualHasBeenSet; }
  template <typename SankeyDiagramVisualT = SankeyDiagramVisual>
  void SetSankeyDiagramVisual(SankeyDiagramVisualT&& value) {
    m_sankeyDiagramVisualHasBeenSet = true;
    m_sankeyDiagramVisual = std::forward<SankeyDiagramVisualT>(value);
  }
  template <typename SankeyDiagramVisualT = SankeyDiagramVisual>
  Visual& WithSankeyDiagramVisual(SankeyDiagramVisualT&& value) {
    SetSankeyDiagramVisual(std::forward<SankeyDiagramVisualT>(value));
    return *this;
  }
 
 
  inline const CustomContentVisual& GetCustomContentVisual() const { return m_customContentVisual; }
  inline bool CustomContentVisualHasBeenSet() const { return m_customContentVisualHasBeenSet; }
  template <typename CustomContentVisualT = CustomContentVisual>
  void SetCustomContentVisual(CustomContentVisualT&& value) {
    m_customContentVisualHasBeenSet = true;
    m_customContentVisual = std::forward<CustomContentVisualT>(value);
  }
  template <typename CustomContentVisualT = CustomContentVisual>
  Visual& WithCustomContentVisual(CustomContentVisualT&& value) {
    SetCustomContentVisual(std::forward<CustomContentVisualT>(value));
    return *this;
  }
 
 
  inline const EmptyVisual& GetEmptyVisual() const { return m_emptyVisual; }
  inline bool EmptyVisualHasBeenSet() const { return m_emptyVisualHasBeenSet; }
  template <typename EmptyVisualT = EmptyVisual>
  void SetEmptyVisual(EmptyVisualT&& value) {
    m_emptyVisualHasBeenSet = true;
    m_emptyVisual = std::forward<EmptyVisualT>(value);
  }
  template <typename EmptyVisualT = EmptyVisual>
  Visual& WithEmptyVisual(EmptyVisualT&& value) {
    SetEmptyVisual(std::forward<EmptyVisualT>(value));
    return *this;
  }
 
 
  inline const RadarChartVisual& GetRadarChartVisual() const { return m_radarChartVisual; }
  inline bool RadarChartVisualHasBeenSet() const { return m_radarChartVisualHasBeenSet; }
  template <typename RadarChartVisualT = RadarChartVisual>
  void SetRadarChartVisual(RadarChartVisualT&& value) {
    m_radarChartVisualHasBeenSet = true;
    m_radarChartVisual = std::forward<RadarChartVisualT>(value);
  }
  template <typename RadarChartVisualT = RadarChartVisual>
  Visual& WithRadarChartVisual(RadarChartVisualT&& value) {
    SetRadarChartVisual(std::forward<RadarChartVisualT>(value));
    return *this;
  }
 
 
  inline const PluginVisual& GetPluginVisual() const { return m_pluginVisual; }
  inline bool PluginVisualHasBeenSet() const { return m_pluginVisualHasBeenSet; }
  template <typename PluginVisualT = PluginVisual>
  void SetPluginVisual(PluginVisualT&& value) {
    m_pluginVisualHasBeenSet = true;
    m_pluginVisual = std::forward<PluginVisualT>(value);
  }
  template <typename PluginVisualT = PluginVisual>
  Visual& WithPluginVisual(PluginVisualT&& value) {
    SetPluginVisual(std::forward<PluginVisualT>(value));
    return *this;
  }
 private:
  TableVisual m_tableVisual;
 
  PivotTableVisual m_pivotTableVisual;
 
  BarChartVisual m_barChartVisual;
 
  KPIVisual m_kPIVisual;
 
  PieChartVisual m_pieChartVisual;
 
  GaugeChartVisual m_gaugeChartVisual;
 
  LineChartVisual m_lineChartVisual;
 
  HeatMapVisual m_heatMapVisual;
 
  TreeMapVisual m_treeMapVisual;
 
  GeospatialMapVisual m_geospatialMapVisual;
 
  FilledMapVisual m_filledMapVisual;
 
  LayerMapVisual m_layerMapVisual;
 
  FunnelChartVisual m_funnelChartVisual;
 
  ScatterPlotVisual m_scatterPlotVisual;
 
  ComboChartVisual m_comboChartVisual;
 
  BoxPlotVisual m_boxPlotVisual;
 
  WaterfallVisual m_waterfallVisual;
 
  HistogramVisual m_histogramVisual;
 
  WordCloudVisual m_wordCloudVisual;
 
  InsightVisual m_insightVisual;
 
  SankeyDiagramVisual m_sankeyDiagramVisual;
 
  CustomContentVisual m_customContentVisual;
 
  EmptyVisual m_emptyVisual;
 
  RadarChartVisual m_radarChartVisual;
 
  PluginVisual m_pluginVisual;
  bool m_tableVisualHasBeenSet = false;
  bool m_pivotTableVisualHasBeenSet = false;
  bool m_barChartVisualHasBeenSet = false;
  bool m_kPIVisualHasBeenSet = false;
  bool m_pieChartVisualHasBeenSet = false;
  bool m_gaugeChartVisualHasBeenSet = false;
  bool m_lineChartVisualHasBeenSet = false;
  bool m_heatMapVisualHasBeenSet = false;
  bool m_treeMapVisualHasBeenSet = false;
  bool m_geospatialMapVisualHasBeenSet = false;
  bool m_filledMapVisualHasBeenSet = false;
  bool m_layerMapVisualHasBeenSet = false;
  bool m_funnelChartVisualHasBeenSet = false;
  bool m_scatterPlotVisualHasBeenSet = false;
  bool m_comboChartVisualHasBeenSet = false;
  bool m_boxPlotVisualHasBeenSet = false;
  bool m_waterfallVisualHasBeenSet = false;
  bool m_histogramVisualHasBeenSet = false;
  bool m_wordCloudVisualHasBeenSet = false;
  bool m_insightVisualHasBeenSet = false;
  bool m_sankeyDiagramVisualHasBeenSet = false;
  bool m_customContentVisualHasBeenSet = false;
  bool m_emptyVisualHasBeenSet = false;
  bool m_radarChartVisualHasBeenSet = false;
  bool m_pluginVisualHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace QuickSight
}  // namespace Aws