EngineConfiguration.h

 
#pragma once
#include <aws/athena/Athena_EXPORTS.h>
#include <aws/athena/model/Classification.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Athena {
namespace Model {
 
class EngineConfiguration {
 public:
  AWS_ATHENA_API EngineConfiguration() = default;
  AWS_ATHENA_API EngineConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_ATHENA_API EngineConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_ATHENA_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline int GetCoordinatorDpuSize() const { return m_coordinatorDpuSize; }
  inline bool CoordinatorDpuSizeHasBeenSet() const { return m_coordinatorDpuSizeHasBeenSet; }
  inline void SetCoordinatorDpuSize(int value) {
    m_coordinatorDpuSizeHasBeenSet = true;
    m_coordinatorDpuSize = value;
  }
  inline EngineConfiguration& WithCoordinatorDpuSize(int value) {
    SetCoordinatorDpuSize(value);
    return *this;
  }
 
 
  inline int GetMaxConcurrentDpus() const { return m_maxConcurrentDpus; }
  inline bool MaxConcurrentDpusHasBeenSet() const { return m_maxConcurrentDpusHasBeenSet; }
  inline void SetMaxConcurrentDpus(int value) {
    m_maxConcurrentDpusHasBeenSet = true;
    m_maxConcurrentDpus = value;
  }
  inline EngineConfiguration& WithMaxConcurrentDpus(int value) {
    SetMaxConcurrentDpus(value);
    return *this;
  }
 
 
  inline int GetDefaultExecutorDpuSize() const { return m_defaultExecutorDpuSize; }
  inline bool DefaultExecutorDpuSizeHasBeenSet() const { return m_defaultExecutorDpuSizeHasBeenSet; }
  inline void SetDefaultExecutorDpuSize(int value) {
    m_defaultExecutorDpuSizeHasBeenSet = true;
    m_defaultExecutorDpuSize = value;
  }
  inline EngineConfiguration& WithDefaultExecutorDpuSize(int value) {
    SetDefaultExecutorDpuSize(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetAdditionalConfigs() const { return m_additionalConfigs; }
  inline bool AdditionalConfigsHasBeenSet() const { return m_additionalConfigsHasBeenSet; }
  template <typename AdditionalConfigsT = Aws::Map<Aws::String, Aws::String>>
  void SetAdditionalConfigs(AdditionalConfigsT&& value) {
    m_additionalConfigsHasBeenSet = true;
    m_additionalConfigs = std::forward<AdditionalConfigsT>(value);
  }
  template <typename AdditionalConfigsT = Aws::Map<Aws::String, Aws::String>>
  EngineConfiguration& WithAdditionalConfigs(AdditionalConfigsT&& value) {
    SetAdditionalConfigs(std::forward<AdditionalConfigsT>(value));
    return *this;
  }
  template <typename AdditionalConfigsKeyT = Aws::String, typename AdditionalConfigsValueT = Aws::String>
  EngineConfiguration& AddAdditionalConfigs(AdditionalConfigsKeyT&& key, AdditionalConfigsValueT&& value) {
    m_additionalConfigsHasBeenSet = true;
    m_additionalConfigs.emplace(std::forward<AdditionalConfigsKeyT>(key), std::forward<AdditionalConfigsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetSparkProperties() const { return m_sparkProperties; }
  inline bool SparkPropertiesHasBeenSet() const { return m_sparkPropertiesHasBeenSet; }
  template <typename SparkPropertiesT = Aws::Map<Aws::String, Aws::String>>
  void SetSparkProperties(SparkPropertiesT&& value) {
    m_sparkPropertiesHasBeenSet = true;
    m_sparkProperties = std::forward<SparkPropertiesT>(value);
  }
  template <typename SparkPropertiesT = Aws::Map<Aws::String, Aws::String>>
  EngineConfiguration& WithSparkProperties(SparkPropertiesT&& value) {
    SetSparkProperties(std::forward<SparkPropertiesT>(value));
    return *this;
  }
  template <typename SparkPropertiesKeyT = Aws::String, typename SparkPropertiesValueT = Aws::String>
  EngineConfiguration& AddSparkProperties(SparkPropertiesKeyT&& key, SparkPropertiesValueT&& value) {
    m_sparkPropertiesHasBeenSet = true;
    m_sparkProperties.emplace(std::forward<SparkPropertiesKeyT>(key), std::forward<SparkPropertiesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Classification>& GetClassifications() const { return m_classifications; }
  inline bool ClassificationsHasBeenSet() const { return m_classificationsHasBeenSet; }
  template <typename ClassificationsT = Aws::Vector<Classification>>
  void SetClassifications(ClassificationsT&& value) {
    m_classificationsHasBeenSet = true;
    m_classifications = std::forward<ClassificationsT>(value);
  }
  template <typename ClassificationsT = Aws::Vector<Classification>>
  EngineConfiguration& WithClassifications(ClassificationsT&& value) {
    SetClassifications(std::forward<ClassificationsT>(value));
    return *this;
  }
  template <typename ClassificationsT = Classification>
  EngineConfiguration& AddClassifications(ClassificationsT&& value) {
    m_classificationsHasBeenSet = true;
    m_classifications.emplace_back(std::forward<ClassificationsT>(value));
    return *this;
  }
 private:
  int m_coordinatorDpuSize{0};
 
  int m_maxConcurrentDpus{0};
 
  int m_defaultExecutorDpuSize{0};
 
  Aws::Map<Aws::String, Aws::String> m_additionalConfigs;
 
  Aws::Map<Aws::String, Aws::String> m_sparkProperties;
 
  Aws::Vector<Classification> m_classifications;
  bool m_coordinatorDpuSizeHasBeenSet = false;
  bool m_maxConcurrentDpusHasBeenSet = false;
  bool m_defaultExecutorDpuSizeHasBeenSet = false;
  bool m_additionalConfigsHasBeenSet = false;
  bool m_sparkPropertiesHasBeenSet = false;
  bool m_classificationsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Athena
}  // namespace Aws