LambdaFunctionInfo.h

 
#pragma once
#include <aws/codedeploy/CodeDeploy_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CodeDeploy {
namespace Model {
 
class LambdaFunctionInfo {
 public:
  AWS_CODEDEPLOY_API LambdaFunctionInfo() = default;
  AWS_CODEDEPLOY_API LambdaFunctionInfo(Aws::Utils::Json::JsonView jsonValue);
  AWS_CODEDEPLOY_API LambdaFunctionInfo& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CODEDEPLOY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetFunctionName() const { return m_functionName; }
  inline bool FunctionNameHasBeenSet() const { return m_functionNameHasBeenSet; }
  template <typename FunctionNameT = Aws::String>
  void SetFunctionName(FunctionNameT&& value) {
    m_functionNameHasBeenSet = true;
    m_functionName = std::forward<FunctionNameT>(value);
  }
  template <typename FunctionNameT = Aws::String>
  LambdaFunctionInfo& WithFunctionName(FunctionNameT&& value) {
    SetFunctionName(std::forward<FunctionNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFunctionAlias() const { return m_functionAlias; }
  inline bool FunctionAliasHasBeenSet() const { return m_functionAliasHasBeenSet; }
  template <typename FunctionAliasT = Aws::String>
  void SetFunctionAlias(FunctionAliasT&& value) {
    m_functionAliasHasBeenSet = true;
    m_functionAlias = std::forward<FunctionAliasT>(value);
  }
  template <typename FunctionAliasT = Aws::String>
  LambdaFunctionInfo& WithFunctionAlias(FunctionAliasT&& value) {
    SetFunctionAlias(std::forward<FunctionAliasT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCurrentVersion() const { return m_currentVersion; }
  inline bool CurrentVersionHasBeenSet() const { return m_currentVersionHasBeenSet; }
  template <typename CurrentVersionT = Aws::String>
  void SetCurrentVersion(CurrentVersionT&& value) {
    m_currentVersionHasBeenSet = true;
    m_currentVersion = std::forward<CurrentVersionT>(value);
  }
  template <typename CurrentVersionT = Aws::String>
  LambdaFunctionInfo& WithCurrentVersion(CurrentVersionT&& value) {
    SetCurrentVersion(std::forward<CurrentVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetVersion() const { return m_targetVersion; }
  inline bool TargetVersionHasBeenSet() const { return m_targetVersionHasBeenSet; }
  template <typename TargetVersionT = Aws::String>
  void SetTargetVersion(TargetVersionT&& value) {
    m_targetVersionHasBeenSet = true;
    m_targetVersion = std::forward<TargetVersionT>(value);
  }
  template <typename TargetVersionT = Aws::String>
  LambdaFunctionInfo& WithTargetVersion(TargetVersionT&& value) {
    SetTargetVersion(std::forward<TargetVersionT>(value));
    return *this;
  }
 
 
  inline double GetTargetVersionWeight() const { return m_targetVersionWeight; }
  inline bool TargetVersionWeightHasBeenSet() const { return m_targetVersionWeightHasBeenSet; }
  inline void SetTargetVersionWeight(double value) {
    m_targetVersionWeightHasBeenSet = true;
    m_targetVersionWeight = value;
  }
  inline LambdaFunctionInfo& WithTargetVersionWeight(double value) {
    SetTargetVersionWeight(value);
    return *this;
  }
 private:
  Aws::String m_functionName;
 
  Aws::String m_functionAlias;
 
  Aws::String m_currentVersion;
 
  Aws::String m_targetVersion;
 
  double m_targetVersionWeight{0.0};
  bool m_functionNameHasBeenSet = false;
  bool m_functionAliasHasBeenSet = false;
  bool m_currentVersionHasBeenSet = false;
  bool m_targetVersionHasBeenSet = false;
  bool m_targetVersionWeightHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CodeDeploy
}  // namespace Aws