FunctionConfiguration.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/greengrass/Greengrass_EXPORTS.h>
#include <aws/greengrass/model/EncodingType.h>
#include <aws/greengrass/model/FunctionConfigurationEnvironment.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Greengrass {
namespace Model {
 
class FunctionConfiguration {
 public:
  AWS_GREENGRASS_API FunctionConfiguration() = default;
  AWS_GREENGRASS_API FunctionConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_GREENGRASS_API FunctionConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GREENGRASS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline EncodingType GetEncodingType() const { return m_encodingType; }
  inline bool EncodingTypeHasBeenSet() const { return m_encodingTypeHasBeenSet; }
  inline void SetEncodingType(EncodingType value) {
    m_encodingTypeHasBeenSet = true;
    m_encodingType = value;
  }
  inline FunctionConfiguration& WithEncodingType(EncodingType value) {
    SetEncodingType(value);
    return *this;
  }
 
 
  inline const FunctionConfigurationEnvironment& GetEnvironment() const { return m_environment; }
  inline bool EnvironmentHasBeenSet() const { return m_environmentHasBeenSet; }
  template <typename EnvironmentT = FunctionConfigurationEnvironment>
  void SetEnvironment(EnvironmentT&& value) {
    m_environmentHasBeenSet = true;
    m_environment = std::forward<EnvironmentT>(value);
  }
  template <typename EnvironmentT = FunctionConfigurationEnvironment>
  FunctionConfiguration& WithEnvironment(EnvironmentT&& value) {
    SetEnvironment(std::forward<EnvironmentT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecArgs() const { return m_execArgs; }
  inline bool ExecArgsHasBeenSet() const { return m_execArgsHasBeenSet; }
  template <typename ExecArgsT = Aws::String>
  void SetExecArgs(ExecArgsT&& value) {
    m_execArgsHasBeenSet = true;
    m_execArgs = std::forward<ExecArgsT>(value);
  }
  template <typename ExecArgsT = Aws::String>
  FunctionConfiguration& WithExecArgs(ExecArgsT&& value) {
    SetExecArgs(std::forward<ExecArgsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecutable() const { return m_executable; }
  inline bool ExecutableHasBeenSet() const { return m_executableHasBeenSet; }
  template <typename ExecutableT = Aws::String>
  void SetExecutable(ExecutableT&& value) {
    m_executableHasBeenSet = true;
    m_executable = std::forward<ExecutableT>(value);
  }
  template <typename ExecutableT = Aws::String>
  FunctionConfiguration& WithExecutable(ExecutableT&& value) {
    SetExecutable(std::forward<ExecutableT>(value));
    return *this;
  }
 
 
  inline int GetMemorySize() const { return m_memorySize; }
  inline bool MemorySizeHasBeenSet() const { return m_memorySizeHasBeenSet; }
  inline void SetMemorySize(int value) {
    m_memorySizeHasBeenSet = true;
    m_memorySize = value;
  }
  inline FunctionConfiguration& WithMemorySize(int value) {
    SetMemorySize(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 FunctionConfiguration& WithPinned(bool value) {
    SetPinned(value);
    return *this;
  }
 
 
  inline int GetTimeout() const { return m_timeout; }
  inline bool TimeoutHasBeenSet() const { return m_timeoutHasBeenSet; }
  inline void SetTimeout(int value) {
    m_timeoutHasBeenSet = true;
    m_timeout = value;
  }
  inline FunctionConfiguration& WithTimeout(int value) {
    SetTimeout(value);
    return *this;
  }
 
 
  inline const Aws::String& GetFunctionRuntimeOverride() const { return m_functionRuntimeOverride; }
  inline bool FunctionRuntimeOverrideHasBeenSet() const { return m_functionRuntimeOverrideHasBeenSet; }
  template <typename FunctionRuntimeOverrideT = Aws::String>
  void SetFunctionRuntimeOverride(FunctionRuntimeOverrideT&& value) {
    m_functionRuntimeOverrideHasBeenSet = true;
    m_functionRuntimeOverride = std::forward<FunctionRuntimeOverrideT>(value);
  }
  template <typename FunctionRuntimeOverrideT = Aws::String>
  FunctionConfiguration& WithFunctionRuntimeOverride(FunctionRuntimeOverrideT&& value) {
    SetFunctionRuntimeOverride(std::forward<FunctionRuntimeOverrideT>(value));
    return *this;
  }
 private:
  EncodingType m_encodingType{EncodingType::NOT_SET};
 
  FunctionConfigurationEnvironment m_environment;
 
  Aws::String m_execArgs;
 
  Aws::String m_executable;
 
  int m_memorySize{0};
 
  bool m_pinned{false};
 
  int m_timeout{0};
 
  Aws::String m_functionRuntimeOverride;
  bool m_encodingTypeHasBeenSet = false;
  bool m_environmentHasBeenSet = false;
  bool m_execArgsHasBeenSet = false;
  bool m_executableHasBeenSet = false;
  bool m_memorySizeHasBeenSet = false;
  bool m_pinnedHasBeenSet = false;
  bool m_timeoutHasBeenSet = false;
  bool m_functionRuntimeOverrideHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Greengrass
}  // namespace Aws