LambdaExecutionParameters.h

 
#pragma once
#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 <aws/greengrassv2/GreengrassV2_EXPORTS.h>
#include <aws/greengrassv2/model/LambdaEventSource.h>
#include <aws/greengrassv2/model/LambdaInputPayloadEncodingType.h>
#include <aws/greengrassv2/model/LambdaLinuxProcessParams.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GreengrassV2 {
namespace Model {
 
class LambdaExecutionParameters {
 public:
  AWS_GREENGRASSV2_API LambdaExecutionParameters() = default;
  AWS_GREENGRASSV2_API LambdaExecutionParameters(Aws::Utils::Json::JsonView jsonValue);
  AWS_GREENGRASSV2_API LambdaExecutionParameters& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GREENGRASSV2_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<LambdaEventSource>& GetEventSources() const { return m_eventSources; }
  inline bool EventSourcesHasBeenSet() const { return m_eventSourcesHasBeenSet; }
  template <typename EventSourcesT = Aws::Vector<LambdaEventSource>>
  void SetEventSources(EventSourcesT&& value) {
    m_eventSourcesHasBeenSet = true;
    m_eventSources = std::forward<EventSourcesT>(value);
  }
  template <typename EventSourcesT = Aws::Vector<LambdaEventSource>>
  LambdaExecutionParameters& WithEventSources(EventSourcesT&& value) {
    SetEventSources(std::forward<EventSourcesT>(value));
    return *this;
  }
  template <typename EventSourcesT = LambdaEventSource>
  LambdaExecutionParameters& AddEventSources(EventSourcesT&& value) {
    m_eventSourcesHasBeenSet = true;
    m_eventSources.emplace_back(std::forward<EventSourcesT>(value));
    return *this;
  }
 
 
  inline int GetMaxQueueSize() const { return m_maxQueueSize; }
  inline bool MaxQueueSizeHasBeenSet() const { return m_maxQueueSizeHasBeenSet; }
  inline void SetMaxQueueSize(int value) {
    m_maxQueueSizeHasBeenSet = true;
    m_maxQueueSize = value;
  }
  inline LambdaExecutionParameters& WithMaxQueueSize(int value) {
    SetMaxQueueSize(value);
    return *this;
  }
 
 
  inline int GetMaxInstancesCount() const { return m_maxInstancesCount; }
  inline bool MaxInstancesCountHasBeenSet() const { return m_maxInstancesCountHasBeenSet; }
  inline void SetMaxInstancesCount(int value) {
    m_maxInstancesCountHasBeenSet = true;
    m_maxInstancesCount = value;
  }
  inline LambdaExecutionParameters& WithMaxInstancesCount(int value) {
    SetMaxInstancesCount(value);
    return *this;
  }
 
 
  inline int GetMaxIdleTimeInSeconds() const { return m_maxIdleTimeInSeconds; }
  inline bool MaxIdleTimeInSecondsHasBeenSet() const { return m_maxIdleTimeInSecondsHasBeenSet; }
  inline void SetMaxIdleTimeInSeconds(int value) {
    m_maxIdleTimeInSecondsHasBeenSet = true;
    m_maxIdleTimeInSeconds = value;
  }
  inline LambdaExecutionParameters& WithMaxIdleTimeInSeconds(int value) {
    SetMaxIdleTimeInSeconds(value);
    return *this;
  }
 
 
  inline int GetTimeoutInSeconds() const { return m_timeoutInSeconds; }
  inline bool TimeoutInSecondsHasBeenSet() const { return m_timeoutInSecondsHasBeenSet; }
  inline void SetTimeoutInSeconds(int value) {
    m_timeoutInSecondsHasBeenSet = true;
    m_timeoutInSeconds = value;
  }
  inline LambdaExecutionParameters& WithTimeoutInSeconds(int value) {
    SetTimeoutInSeconds(value);
    return *this;
  }
 
 
  inline int GetStatusTimeoutInSeconds() const { return m_statusTimeoutInSeconds; }
  inline bool StatusTimeoutInSecondsHasBeenSet() const { return m_statusTimeoutInSecondsHasBeenSet; }
  inline void SetStatusTimeoutInSeconds(int value) {
    m_statusTimeoutInSecondsHasBeenSet = true;
    m_statusTimeoutInSeconds = value;
  }
  inline LambdaExecutionParameters& WithStatusTimeoutInSeconds(int value) {
    SetStatusTimeoutInSeconds(value);
    return *this;
  }
 
 
  inline bool GetPinned() const { return m_pinned; }
  inline bool PinnedHasBeenSet() const { return m_pinnedHasBeenSet; }
  inline void SetPinned(bool value) {
    m_pinnedHasBeenSet = true;
    m_pinned = value;
  }
  inline LambdaExecutionParameters& WithPinned(bool value) {
    SetPinned(value);
    return *this;
  }
 
 
  inline LambdaInputPayloadEncodingType GetInputPayloadEncodingType() const { return m_inputPayloadEncodingType; }
  inline bool InputPayloadEncodingTypeHasBeenSet() const { return m_inputPayloadEncodingTypeHasBeenSet; }
  inline void SetInputPayloadEncodingType(LambdaInputPayloadEncodingType value) {
    m_inputPayloadEncodingTypeHasBeenSet = true;
    m_inputPayloadEncodingType = value;
  }
  inline LambdaExecutionParameters& WithInputPayloadEncodingType(LambdaInputPayloadEncodingType value) {
    SetInputPayloadEncodingType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetExecArgs() const { return m_execArgs; }
  inline bool ExecArgsHasBeenSet() const { return m_execArgsHasBeenSet; }
  template <typename ExecArgsT = Aws::Vector<Aws::String>>
  void SetExecArgs(ExecArgsT&& value) {
    m_execArgsHasBeenSet = true;
    m_execArgs = std::forward<ExecArgsT>(value);
  }
  template <typename ExecArgsT = Aws::Vector<Aws::String>>
  LambdaExecutionParameters& WithExecArgs(ExecArgsT&& value) {
    SetExecArgs(std::forward<ExecArgsT>(value));
    return *this;
  }
  template <typename ExecArgsT = Aws::String>
  LambdaExecutionParameters& AddExecArgs(ExecArgsT&& value) {
    m_execArgsHasBeenSet = true;
    m_execArgs.emplace_back(std::forward<ExecArgsT>(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>>
  LambdaExecutionParameters& WithEnvironmentVariables(EnvironmentVariablesT&& value) {
    SetEnvironmentVariables(std::forward<EnvironmentVariablesT>(value));
    return *this;
  }
  template <typename EnvironmentVariablesKeyT = Aws::String, typename EnvironmentVariablesValueT = Aws::String>
  LambdaExecutionParameters& AddEnvironmentVariables(EnvironmentVariablesKeyT&& key, EnvironmentVariablesValueT&& value) {
    m_environmentVariablesHasBeenSet = true;
    m_environmentVariables.emplace(std::forward<EnvironmentVariablesKeyT>(key), std::forward<EnvironmentVariablesValueT>(value));
    return *this;
  }
 
 
  inline const LambdaLinuxProcessParams& GetLinuxProcessParams() const { return m_linuxProcessParams; }
  inline bool LinuxProcessParamsHasBeenSet() const { return m_linuxProcessParamsHasBeenSet; }
  template <typename LinuxProcessParamsT = LambdaLinuxProcessParams>
  void SetLinuxProcessParams(LinuxProcessParamsT&& value) {
    m_linuxProcessParamsHasBeenSet = true;
    m_linuxProcessParams = std::forward<LinuxProcessParamsT>(value);
  }
  template <typename LinuxProcessParamsT = LambdaLinuxProcessParams>
  LambdaExecutionParameters& WithLinuxProcessParams(LinuxProcessParamsT&& value) {
    SetLinuxProcessParams(std::forward<LinuxProcessParamsT>(value));
    return *this;
  }
 private:
  Aws::Vector<LambdaEventSource> m_eventSources;
 
  int m_maxQueueSize{0};
 
  int m_maxInstancesCount{0};
 
  int m_maxIdleTimeInSeconds{0};
 
  int m_timeoutInSeconds{0};
 
  int m_statusTimeoutInSeconds{0};
 
  bool m_pinned{false};
 
  LambdaInputPayloadEncodingType m_inputPayloadEncodingType{LambdaInputPayloadEncodingType::NOT_SET};
 
  Aws::Vector<Aws::String> m_execArgs;
 
  Aws::Map<Aws::String, Aws::String> m_environmentVariables;
 
  LambdaLinuxProcessParams m_linuxProcessParams;
  bool m_eventSourcesHasBeenSet = false;
  bool m_maxQueueSizeHasBeenSet = false;
  bool m_maxInstancesCountHasBeenSet = false;
  bool m_maxIdleTimeInSecondsHasBeenSet = false;
  bool m_timeoutInSecondsHasBeenSet = false;
  bool m_statusTimeoutInSecondsHasBeenSet = false;
  bool m_pinnedHasBeenSet = false;
  bool m_inputPayloadEncodingTypeHasBeenSet = false;
  bool m_execArgsHasBeenSet = false;
  bool m_environmentVariablesHasBeenSet = false;
  bool m_linuxProcessParamsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GreengrassV2
}  // namespace Aws