GaugeChartConfiguration.h

 
#pragma once
#include <aws/quicksight/QuickSight_EXPORTS.h>
#include <aws/quicksight/model/DataLabelOptions.h>
#include <aws/quicksight/model/GaugeChartColorConfiguration.h>
#include <aws/quicksight/model/GaugeChartFieldWells.h>
#include <aws/quicksight/model/GaugeChartOptions.h>
#include <aws/quicksight/model/TooltipOptions.h>
#include <aws/quicksight/model/VisualInteractionOptions.h>
#include <aws/quicksight/model/VisualPalette.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace QuickSight {
namespace Model {
 
class GaugeChartConfiguration {
 public:
  AWS_QUICKSIGHT_API GaugeChartConfiguration() = default;
  AWS_QUICKSIGHT_API GaugeChartConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API GaugeChartConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const GaugeChartFieldWells& GetFieldWells() const { return m_fieldWells; }
  inline bool FieldWellsHasBeenSet() const { return m_fieldWellsHasBeenSet; }
  template <typename FieldWellsT = GaugeChartFieldWells>
  void SetFieldWells(FieldWellsT&& value) {
    m_fieldWellsHasBeenSet = true;
    m_fieldWells = std::forward<FieldWellsT>(value);
  }
  template <typename FieldWellsT = GaugeChartFieldWells>
  GaugeChartConfiguration& WithFieldWells(FieldWellsT&& value) {
    SetFieldWells(std::forward<FieldWellsT>(value));
    return *this;
  }
 
 
  inline const GaugeChartOptions& GetGaugeChartOptions() const { return m_gaugeChartOptions; }
  inline bool GaugeChartOptionsHasBeenSet() const { return m_gaugeChartOptionsHasBeenSet; }
  template <typename GaugeChartOptionsT = GaugeChartOptions>
  void SetGaugeChartOptions(GaugeChartOptionsT&& value) {
    m_gaugeChartOptionsHasBeenSet = true;
    m_gaugeChartOptions = std::forward<GaugeChartOptionsT>(value);
  }
  template <typename GaugeChartOptionsT = GaugeChartOptions>
  GaugeChartConfiguration& WithGaugeChartOptions(GaugeChartOptionsT&& value) {
    SetGaugeChartOptions(std::forward<GaugeChartOptionsT>(value));
    return *this;
  }
 
 
  inline const DataLabelOptions& GetDataLabels() const { return m_dataLabels; }
  inline bool DataLabelsHasBeenSet() const { return m_dataLabelsHasBeenSet; }
  template <typename DataLabelsT = DataLabelOptions>
  void SetDataLabels(DataLabelsT&& value) {
    m_dataLabelsHasBeenSet = true;
    m_dataLabels = std::forward<DataLabelsT>(value);
  }
  template <typename DataLabelsT = DataLabelOptions>
  GaugeChartConfiguration& WithDataLabels(DataLabelsT&& value) {
    SetDataLabels(std::forward<DataLabelsT>(value));
    return *this;
  }
 
 
  inline const TooltipOptions& GetTooltipOptions() const { return m_tooltipOptions; }
  inline bool TooltipOptionsHasBeenSet() const { return m_tooltipOptionsHasBeenSet; }
  template <typename TooltipOptionsT = TooltipOptions>
  void SetTooltipOptions(TooltipOptionsT&& value) {
    m_tooltipOptionsHasBeenSet = true;
    m_tooltipOptions = std::forward<TooltipOptionsT>(value);
  }
  template <typename TooltipOptionsT = TooltipOptions>
  GaugeChartConfiguration& WithTooltipOptions(TooltipOptionsT&& value) {
    SetTooltipOptions(std::forward<TooltipOptionsT>(value));
    return *this;
  }
 
 
  inline const VisualPalette& GetVisualPalette() const { return m_visualPalette; }
  inline bool VisualPaletteHasBeenSet() const { return m_visualPaletteHasBeenSet; }
  template <typename VisualPaletteT = VisualPalette>
  void SetVisualPalette(VisualPaletteT&& value) {
    m_visualPaletteHasBeenSet = true;
    m_visualPalette = std::forward<VisualPaletteT>(value);
  }
  template <typename VisualPaletteT = VisualPalette>
  GaugeChartConfiguration& WithVisualPalette(VisualPaletteT&& value) {
    SetVisualPalette(std::forward<VisualPaletteT>(value));
    return *this;
  }
 
 
  inline const GaugeChartColorConfiguration& GetColorConfiguration() const { return m_colorConfiguration; }
  inline bool ColorConfigurationHasBeenSet() const { return m_colorConfigurationHasBeenSet; }
  template <typename ColorConfigurationT = GaugeChartColorConfiguration>
  void SetColorConfiguration(ColorConfigurationT&& value) {
    m_colorConfigurationHasBeenSet = true;
    m_colorConfiguration = std::forward<ColorConfigurationT>(value);
  }
  template <typename ColorConfigurationT = GaugeChartColorConfiguration>
  GaugeChartConfiguration& WithColorConfiguration(ColorConfigurationT&& value) {
    SetColorConfiguration(std::forward<ColorConfigurationT>(value));
    return *this;
  }
 
 
  inline const VisualInteractionOptions& GetInteractions() const { return m_interactions; }
  inline bool InteractionsHasBeenSet() const { return m_interactionsHasBeenSet; }
  template <typename InteractionsT = VisualInteractionOptions>
  void SetInteractions(InteractionsT&& value) {
    m_interactionsHasBeenSet = true;
    m_interactions = std::forward<InteractionsT>(value);
  }
  template <typename InteractionsT = VisualInteractionOptions>
  GaugeChartConfiguration& WithInteractions(InteractionsT&& value) {
    SetInteractions(std::forward<InteractionsT>(value));
    return *this;
  }
 private:
  GaugeChartFieldWells m_fieldWells;
 
  GaugeChartOptions m_gaugeChartOptions;
 
  DataLabelOptions m_dataLabels;
 
  TooltipOptions m_tooltipOptions;
 
  VisualPalette m_visualPalette;
 
  GaugeChartColorConfiguration m_colorConfiguration;
 
  VisualInteractionOptions m_interactions;
  bool m_fieldWellsHasBeenSet = false;
  bool m_gaugeChartOptionsHasBeenSet = false;
  bool m_dataLabelsHasBeenSet = false;
  bool m_tooltipOptionsHasBeenSet = false;
  bool m_visualPaletteHasBeenSet = false;
  bool m_colorConfigurationHasBeenSet = false;
  bool m_interactionsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace QuickSight
}  // namespace Aws