Problem.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/devicefarm/DeviceFarm_EXPORTS.h>
#include <aws/devicefarm/model/Device.h>
#include <aws/devicefarm/model/ExecutionResult.h>
#include <aws/devicefarm/model/ProblemDetail.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DeviceFarm {
namespace Model {
 
class Problem {
 public:
  AWS_DEVICEFARM_API Problem() = default;
  AWS_DEVICEFARM_API Problem(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEVICEFARM_API Problem& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEVICEFARM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const ProblemDetail& GetRun() const { return m_run; }
  inline bool RunHasBeenSet() const { return m_runHasBeenSet; }
  template <typename RunT = ProblemDetail>
  void SetRun(RunT&& value) {
    m_runHasBeenSet = true;
    m_run = std::forward<RunT>(value);
  }
  template <typename RunT = ProblemDetail>
  Problem& WithRun(RunT&& value) {
    SetRun(std::forward<RunT>(value));
    return *this;
  }
 
 
  inline const ProblemDetail& GetJob() const { return m_job; }
  inline bool JobHasBeenSet() const { return m_jobHasBeenSet; }
  template <typename JobT = ProblemDetail>
  void SetJob(JobT&& value) {
    m_jobHasBeenSet = true;
    m_job = std::forward<JobT>(value);
  }
  template <typename JobT = ProblemDetail>
  Problem& WithJob(JobT&& value) {
    SetJob(std::forward<JobT>(value));
    return *this;
  }
 
 
  inline const ProblemDetail& GetSuite() const { return m_suite; }
  inline bool SuiteHasBeenSet() const { return m_suiteHasBeenSet; }
  template <typename SuiteT = ProblemDetail>
  void SetSuite(SuiteT&& value) {
    m_suiteHasBeenSet = true;
    m_suite = std::forward<SuiteT>(value);
  }
  template <typename SuiteT = ProblemDetail>
  Problem& WithSuite(SuiteT&& value) {
    SetSuite(std::forward<SuiteT>(value));
    return *this;
  }
 
 
  inline const ProblemDetail& GetTest() const { return m_test; }
  inline bool TestHasBeenSet() const { return m_testHasBeenSet; }
  template <typename TestT = ProblemDetail>
  void SetTest(TestT&& value) {
    m_testHasBeenSet = true;
    m_test = std::forward<TestT>(value);
  }
  template <typename TestT = ProblemDetail>
  Problem& WithTest(TestT&& value) {
    SetTest(std::forward<TestT>(value));
    return *this;
  }
 
 
  inline const Device& GetDevice() const { return m_device; }
  inline bool DeviceHasBeenSet() const { return m_deviceHasBeenSet; }
  template <typename DeviceT = Device>
  void SetDevice(DeviceT&& value) {
    m_deviceHasBeenSet = true;
    m_device = std::forward<DeviceT>(value);
  }
  template <typename DeviceT = Device>
  Problem& WithDevice(DeviceT&& value) {
    SetDevice(std::forward<DeviceT>(value));
    return *this;
  }
 
 
  inline ExecutionResult GetResult() const { return m_result; }
  inline bool ResultHasBeenSet() const { return m_resultHasBeenSet; }
  inline void SetResult(ExecutionResult value) {
    m_resultHasBeenSet = true;
    m_result = value;
  }
  inline Problem& WithResult(ExecutionResult value) {
    SetResult(value);
    return *this;
  }
 
 
  inline const Aws::String& GetMessage() const { return m_message; }
  inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
  template <typename MessageT = Aws::String>
  void SetMessage(MessageT&& value) {
    m_messageHasBeenSet = true;
    m_message = std::forward<MessageT>(value);
  }
  template <typename MessageT = Aws::String>
  Problem& WithMessage(MessageT&& value) {
    SetMessage(std::forward<MessageT>(value));
    return *this;
  }
 private:
  ProblemDetail m_run;
 
  ProblemDetail m_job;
 
  ProblemDetail m_suite;
 
  ProblemDetail m_test;
 
  Device m_device;
 
  ExecutionResult m_result{ExecutionResult::NOT_SET};
 
  Aws::String m_message;
  bool m_runHasBeenSet = false;
  bool m_jobHasBeenSet = false;
  bool m_suiteHasBeenSet = false;
  bool m_testHasBeenSet = false;
  bool m_deviceHasBeenSet = false;
  bool m_resultHasBeenSet = false;
  bool m_messageHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DeviceFarm
}  // namespace Aws