InspectionData.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/states/SFN_EXPORTS.h>
#include <aws/states/model/InspectionDataRequest.h>
#include <aws/states/model/InspectionDataResponse.h>
#include <aws/states/model/InspectionErrorDetails.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SFN {
namespace Model {
 
class InspectionData {
 public:
  AWS_SFN_API InspectionData() = default;
  AWS_SFN_API InspectionData(Aws::Utils::Json::JsonView jsonValue);
  AWS_SFN_API InspectionData& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SFN_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetInput() const { return m_input; }
  inline bool InputHasBeenSet() const { return m_inputHasBeenSet; }
  template <typename InputT = Aws::String>
  void SetInput(InputT&& value) {
    m_inputHasBeenSet = true;
    m_input = std::forward<InputT>(value);
  }
  template <typename InputT = Aws::String>
  InspectionData& WithInput(InputT&& value) {
    SetInput(std::forward<InputT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAfterArguments() const { return m_afterArguments; }
  inline bool AfterArgumentsHasBeenSet() const { return m_afterArgumentsHasBeenSet; }
  template <typename AfterArgumentsT = Aws::String>
  void SetAfterArguments(AfterArgumentsT&& value) {
    m_afterArgumentsHasBeenSet = true;
    m_afterArguments = std::forward<AfterArgumentsT>(value);
  }
  template <typename AfterArgumentsT = Aws::String>
  InspectionData& WithAfterArguments(AfterArgumentsT&& value) {
    SetAfterArguments(std::forward<AfterArgumentsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAfterInputPath() const { return m_afterInputPath; }
  inline bool AfterInputPathHasBeenSet() const { return m_afterInputPathHasBeenSet; }
  template <typename AfterInputPathT = Aws::String>
  void SetAfterInputPath(AfterInputPathT&& value) {
    m_afterInputPathHasBeenSet = true;
    m_afterInputPath = std::forward<AfterInputPathT>(value);
  }
  template <typename AfterInputPathT = Aws::String>
  InspectionData& WithAfterInputPath(AfterInputPathT&& value) {
    SetAfterInputPath(std::forward<AfterInputPathT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAfterParameters() const { return m_afterParameters; }
  inline bool AfterParametersHasBeenSet() const { return m_afterParametersHasBeenSet; }
  template <typename AfterParametersT = Aws::String>
  void SetAfterParameters(AfterParametersT&& value) {
    m_afterParametersHasBeenSet = true;
    m_afterParameters = std::forward<AfterParametersT>(value);
  }
  template <typename AfterParametersT = Aws::String>
  InspectionData& WithAfterParameters(AfterParametersT&& value) {
    SetAfterParameters(std::forward<AfterParametersT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResult() const { return m_result; }
  inline bool ResultHasBeenSet() const { return m_resultHasBeenSet; }
  template <typename ResultT = Aws::String>
  void SetResult(ResultT&& value) {
    m_resultHasBeenSet = true;
    m_result = std::forward<ResultT>(value);
  }
  template <typename ResultT = Aws::String>
  InspectionData& WithResult(ResultT&& value) {
    SetResult(std::forward<ResultT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAfterResultSelector() const { return m_afterResultSelector; }
  inline bool AfterResultSelectorHasBeenSet() const { return m_afterResultSelectorHasBeenSet; }
  template <typename AfterResultSelectorT = Aws::String>
  void SetAfterResultSelector(AfterResultSelectorT&& value) {
    m_afterResultSelectorHasBeenSet = true;
    m_afterResultSelector = std::forward<AfterResultSelectorT>(value);
  }
  template <typename AfterResultSelectorT = Aws::String>
  InspectionData& WithAfterResultSelector(AfterResultSelectorT&& value) {
    SetAfterResultSelector(std::forward<AfterResultSelectorT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAfterResultPath() const { return m_afterResultPath; }
  inline bool AfterResultPathHasBeenSet() const { return m_afterResultPathHasBeenSet; }
  template <typename AfterResultPathT = Aws::String>
  void SetAfterResultPath(AfterResultPathT&& value) {
    m_afterResultPathHasBeenSet = true;
    m_afterResultPath = std::forward<AfterResultPathT>(value);
  }
  template <typename AfterResultPathT = Aws::String>
  InspectionData& WithAfterResultPath(AfterResultPathT&& value) {
    SetAfterResultPath(std::forward<AfterResultPathT>(value));
    return *this;
  }
 
 
  inline const InspectionDataRequest& GetRequest() const { return m_request; }
  inline bool RequestHasBeenSet() const { return m_requestHasBeenSet; }
  template <typename RequestT = InspectionDataRequest>
  void SetRequest(RequestT&& value) {
    m_requestHasBeenSet = true;
    m_request = std::forward<RequestT>(value);
  }
  template <typename RequestT = InspectionDataRequest>
  InspectionData& WithRequest(RequestT&& value) {
    SetRequest(std::forward<RequestT>(value));
    return *this;
  }
 
 
  inline const InspectionDataResponse& GetResponse() const { return m_response; }
  inline bool ResponseHasBeenSet() const { return m_responseHasBeenSet; }
  template <typename ResponseT = InspectionDataResponse>
  void SetResponse(ResponseT&& value) {
    m_responseHasBeenSet = true;
    m_response = std::forward<ResponseT>(value);
  }
  template <typename ResponseT = InspectionDataResponse>
  InspectionData& WithResponse(ResponseT&& value) {
    SetResponse(std::forward<ResponseT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVariables() const { return m_variables; }
  inline bool VariablesHasBeenSet() const { return m_variablesHasBeenSet; }
  template <typename VariablesT = Aws::String>
  void SetVariables(VariablesT&& value) {
    m_variablesHasBeenSet = true;
    m_variables = std::forward<VariablesT>(value);
  }
  template <typename VariablesT = Aws::String>
  InspectionData& WithVariables(VariablesT&& value) {
    SetVariables(std::forward<VariablesT>(value));
    return *this;
  }
 
 
  inline const InspectionErrorDetails& GetErrorDetails() const { return m_errorDetails; }
  inline bool ErrorDetailsHasBeenSet() const { return m_errorDetailsHasBeenSet; }
  template <typename ErrorDetailsT = InspectionErrorDetails>
  void SetErrorDetails(ErrorDetailsT&& value) {
    m_errorDetailsHasBeenSet = true;
    m_errorDetails = std::forward<ErrorDetailsT>(value);
  }
  template <typename ErrorDetailsT = InspectionErrorDetails>
  InspectionData& WithErrorDetails(ErrorDetailsT&& value) {
    SetErrorDetails(std::forward<ErrorDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAfterItemsPath() const { return m_afterItemsPath; }
  inline bool AfterItemsPathHasBeenSet() const { return m_afterItemsPathHasBeenSet; }
  template <typename AfterItemsPathT = Aws::String>
  void SetAfterItemsPath(AfterItemsPathT&& value) {
    m_afterItemsPathHasBeenSet = true;
    m_afterItemsPath = std::forward<AfterItemsPathT>(value);
  }
  template <typename AfterItemsPathT = Aws::String>
  InspectionData& WithAfterItemsPath(AfterItemsPathT&& value) {
    SetAfterItemsPath(std::forward<AfterItemsPathT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAfterItemSelector() const { return m_afterItemSelector; }
  inline bool AfterItemSelectorHasBeenSet() const { return m_afterItemSelectorHasBeenSet; }
  template <typename AfterItemSelectorT = Aws::String>
  void SetAfterItemSelector(AfterItemSelectorT&& value) {
    m_afterItemSelectorHasBeenSet = true;
    m_afterItemSelector = std::forward<AfterItemSelectorT>(value);
  }
  template <typename AfterItemSelectorT = Aws::String>
  InspectionData& WithAfterItemSelector(AfterItemSelectorT&& value) {
    SetAfterItemSelector(std::forward<AfterItemSelectorT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAfterItemBatcher() const { return m_afterItemBatcher; }
  inline bool AfterItemBatcherHasBeenSet() const { return m_afterItemBatcherHasBeenSet; }
  template <typename AfterItemBatcherT = Aws::String>
  void SetAfterItemBatcher(AfterItemBatcherT&& value) {
    m_afterItemBatcherHasBeenSet = true;
    m_afterItemBatcher = std::forward<AfterItemBatcherT>(value);
  }
  template <typename AfterItemBatcherT = Aws::String>
  InspectionData& WithAfterItemBatcher(AfterItemBatcherT&& value) {
    SetAfterItemBatcher(std::forward<AfterItemBatcherT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAfterItemsPointer() const { return m_afterItemsPointer; }
  inline bool AfterItemsPointerHasBeenSet() const { return m_afterItemsPointerHasBeenSet; }
  template <typename AfterItemsPointerT = Aws::String>
  void SetAfterItemsPointer(AfterItemsPointerT&& value) {
    m_afterItemsPointerHasBeenSet = true;
    m_afterItemsPointer = std::forward<AfterItemsPointerT>(value);
  }
  template <typename AfterItemsPointerT = Aws::String>
  InspectionData& WithAfterItemsPointer(AfterItemsPointerT&& value) {
    SetAfterItemsPointer(std::forward<AfterItemsPointerT>(value));
    return *this;
  }
 
 
  inline int GetToleratedFailureCount() const { return m_toleratedFailureCount; }
  inline bool ToleratedFailureCountHasBeenSet() const { return m_toleratedFailureCountHasBeenSet; }
  inline void SetToleratedFailureCount(int value) {
    m_toleratedFailureCountHasBeenSet = true;
    m_toleratedFailureCount = value;
  }
  inline InspectionData& WithToleratedFailureCount(int value) {
    SetToleratedFailureCount(value);
    return *this;
  }
 
 
  inline double GetToleratedFailurePercentage() const { return m_toleratedFailurePercentage; }
  inline bool ToleratedFailurePercentageHasBeenSet() const { return m_toleratedFailurePercentageHasBeenSet; }
  inline void SetToleratedFailurePercentage(double value) {
    m_toleratedFailurePercentageHasBeenSet = true;
    m_toleratedFailurePercentage = value;
  }
  inline InspectionData& WithToleratedFailurePercentage(double value) {
    SetToleratedFailurePercentage(value);
    return *this;
  }
 
 
  inline int GetMaxConcurrency() const { return m_maxConcurrency; }
  inline bool MaxConcurrencyHasBeenSet() const { return m_maxConcurrencyHasBeenSet; }
  inline void SetMaxConcurrency(int value) {
    m_maxConcurrencyHasBeenSet = true;
    m_maxConcurrency = value;
  }
  inline InspectionData& WithMaxConcurrency(int value) {
    SetMaxConcurrency(value);
    return *this;
  }
 private:
  Aws::String m_input;
 
  Aws::String m_afterArguments;
 
  Aws::String m_afterInputPath;
 
  Aws::String m_afterParameters;
 
  Aws::String m_result;
 
  Aws::String m_afterResultSelector;
 
  Aws::String m_afterResultPath;
 
  InspectionDataRequest m_request;
 
  InspectionDataResponse m_response;
 
  Aws::String m_variables;
 
  InspectionErrorDetails m_errorDetails;
 
  Aws::String m_afterItemsPath;
 
  Aws::String m_afterItemSelector;
 
  Aws::String m_afterItemBatcher;
 
  Aws::String m_afterItemsPointer;
 
  int m_toleratedFailureCount{0};
 
  double m_toleratedFailurePercentage{0.0};
 
  int m_maxConcurrency{0};
  bool m_inputHasBeenSet = false;
  bool m_afterArgumentsHasBeenSet = false;
  bool m_afterInputPathHasBeenSet = false;
  bool m_afterParametersHasBeenSet = false;
  bool m_resultHasBeenSet = false;
  bool m_afterResultSelectorHasBeenSet = false;
  bool m_afterResultPathHasBeenSet = false;
  bool m_requestHasBeenSet = false;
  bool m_responseHasBeenSet = false;
  bool m_variablesHasBeenSet = false;
  bool m_errorDetailsHasBeenSet = false;
  bool m_afterItemsPathHasBeenSet = false;
  bool m_afterItemSelectorHasBeenSet = false;
  bool m_afterItemBatcherHasBeenSet = false;
  bool m_afterItemsPointerHasBeenSet = false;
  bool m_toleratedFailureCountHasBeenSet = false;
  bool m_toleratedFailurePercentageHasBeenSet = false;
  bool m_maxConcurrencyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SFN
}  // namespace Aws