ServiceConfig.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/lambda-web/LambdaWeb_EXPORTS.h>
#include <aws/lambda-web/model/TelemetryConfig.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace LambdaWeb {
namespace Model {
 
class ServiceConfig {
 public:
  AWS_LAMBDAWEB_API ServiceConfig() = default;
  AWS_LAMBDAWEB_API ServiceConfig(Aws::Utils::Json::JsonView jsonValue);
  AWS_LAMBDAWEB_API ServiceConfig& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_LAMBDAWEB_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetExecutionRoleArn() const { return m_executionRoleArn; }
  inline bool ExecutionRoleArnHasBeenSet() const { return m_executionRoleArnHasBeenSet; }
  template <typename ExecutionRoleArnT = Aws::String>
  void SetExecutionRoleArn(ExecutionRoleArnT&& value) {
    m_executionRoleArnHasBeenSet = true;
    m_executionRoleArn = std::forward<ExecutionRoleArnT>(value);
  }
  template <typename ExecutionRoleArnT = Aws::String>
  ServiceConfig& WithExecutionRoleArn(ExecutionRoleArnT&& value) {
    SetExecutionRoleArn(std::forward<ExecutionRoleArnT>(value));
    return *this;
  }
 
 
  inline int GetTimeoutSeconds() const { return m_timeoutSeconds; }
  inline bool TimeoutSecondsHasBeenSet() const { return m_timeoutSecondsHasBeenSet; }
  inline void SetTimeoutSeconds(int value) {
    m_timeoutSecondsHasBeenSet = true;
    m_timeoutSeconds = value;
  }
  inline ServiceConfig& WithTimeoutSeconds(int value) {
    SetTimeoutSeconds(value);
    return *this;
  }
 
 
  inline const Aws::String& GetEgressNetworkConnectorArn() const { return m_egressNetworkConnectorArn; }
  inline bool EgressNetworkConnectorArnHasBeenSet() const { return m_egressNetworkConnectorArnHasBeenSet; }
  template <typename EgressNetworkConnectorArnT = Aws::String>
  void SetEgressNetworkConnectorArn(EgressNetworkConnectorArnT&& value) {
    m_egressNetworkConnectorArnHasBeenSet = true;
    m_egressNetworkConnectorArn = std::forward<EgressNetworkConnectorArnT>(value);
  }
  template <typename EgressNetworkConnectorArnT = Aws::String>
  ServiceConfig& WithEgressNetworkConnectorArn(EgressNetworkConnectorArnT&& value) {
    SetEgressNetworkConnectorArn(std::forward<EgressNetworkConnectorArnT>(value));
    return *this;
  }
 
 
  inline int GetMaxConcurrencyPerEnvironment() const { return m_maxConcurrencyPerEnvironment; }
  inline bool MaxConcurrencyPerEnvironmentHasBeenSet() const { return m_maxConcurrencyPerEnvironmentHasBeenSet; }
  inline void SetMaxConcurrencyPerEnvironment(int value) {
    m_maxConcurrencyPerEnvironmentHasBeenSet = true;
    m_maxConcurrencyPerEnvironment = value;
  }
  inline ServiceConfig& WithMaxConcurrencyPerEnvironment(int value) {
    SetMaxConcurrencyPerEnvironment(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetEnvironmentVariables() const { return m_environmentVariables; }
  inline bool EnvironmentVariablesHasBeenSet() const { return m_environmentVariablesHasBeenSet; }
  template <typename EnvironmentVariablesT = Aws::Map<Aws::String, Aws::String>>
  void SetEnvironmentVariables(EnvironmentVariablesT&& value) {
    m_environmentVariablesHasBeenSet = true;
    m_environmentVariables = std::forward<EnvironmentVariablesT>(value);
  }
  template <typename EnvironmentVariablesT = Aws::Map<Aws::String, Aws::String>>
  ServiceConfig& WithEnvironmentVariables(EnvironmentVariablesT&& value) {
    SetEnvironmentVariables(std::forward<EnvironmentVariablesT>(value));
    return *this;
  }
  template <typename EnvironmentVariablesKeyT = Aws::String, typename EnvironmentVariablesValueT = Aws::String>
  ServiceConfig& AddEnvironmentVariables(EnvironmentVariablesKeyT&& key, EnvironmentVariablesValueT&& value) {
    m_environmentVariablesHasBeenSet = true;
    m_environmentVariables.emplace(std::forward<EnvironmentVariablesKeyT>(key), std::forward<EnvironmentVariablesValueT>(value));
    return *this;
  }
 
 
  inline const TelemetryConfig& GetTelemetryConfig() const { return m_telemetryConfig; }
  inline bool TelemetryConfigHasBeenSet() const { return m_telemetryConfigHasBeenSet; }
  template <typename TelemetryConfigT = TelemetryConfig>
  void SetTelemetryConfig(TelemetryConfigT&& value) {
    m_telemetryConfigHasBeenSet = true;
    m_telemetryConfig = std::forward<TelemetryConfigT>(value);
  }
  template <typename TelemetryConfigT = TelemetryConfig>
  ServiceConfig& WithTelemetryConfig(TelemetryConfigT&& value) {
    SetTelemetryConfig(std::forward<TelemetryConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_executionRoleArn;
 
  int m_timeoutSeconds{0};
 
  Aws::String m_egressNetworkConnectorArn;
 
  int m_maxConcurrencyPerEnvironment{0};
 
  Aws::Map<Aws::String, Aws::String> m_environmentVariables;
 
  TelemetryConfig m_telemetryConfig;
  bool m_executionRoleArnHasBeenSet = false;
  bool m_timeoutSecondsHasBeenSet = false;
  bool m_egressNetworkConnectorArnHasBeenSet = false;
  bool m_maxConcurrencyPerEnvironmentHasBeenSet = false;
  bool m_environmentVariablesHasBeenSet = false;
  bool m_telemetryConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace LambdaWeb
}  // namespace Aws