ComparedFace.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/rekognition/Rekognition_EXPORTS.h>
#include <aws/rekognition/model/BoundingBox.h>
#include <aws/rekognition/model/Emotion.h>
#include <aws/rekognition/model/ImageQuality.h>
#include <aws/rekognition/model/Landmark.h>
#include <aws/rekognition/model/Pose.h>
#include <aws/rekognition/model/Smile.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Rekognition {
namespace Model {
 
class ComparedFace {
 public:
  AWS_REKOGNITION_API ComparedFace() = default;
  AWS_REKOGNITION_API ComparedFace(Aws::Utils::Json::JsonView jsonValue);
  AWS_REKOGNITION_API ComparedFace& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_REKOGNITION_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const BoundingBox& GetBoundingBox() const { return m_boundingBox; }
  inline bool BoundingBoxHasBeenSet() const { return m_boundingBoxHasBeenSet; }
  template <typename BoundingBoxT = BoundingBox>
  void SetBoundingBox(BoundingBoxT&& value) {
    m_boundingBoxHasBeenSet = true;
    m_boundingBox = std::forward<BoundingBoxT>(value);
  }
  template <typename BoundingBoxT = BoundingBox>
  ComparedFace& WithBoundingBox(BoundingBoxT&& value) {
    SetBoundingBox(std::forward<BoundingBoxT>(value));
    return *this;
  }
 
 
  inline double GetConfidence() const { return m_confidence; }
  inline bool ConfidenceHasBeenSet() const { return m_confidenceHasBeenSet; }
  inline void SetConfidence(double value) {
    m_confidenceHasBeenSet = true;
    m_confidence = value;
  }
  inline ComparedFace& WithConfidence(double value) {
    SetConfidence(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Landmark>& GetLandmarks() const { return m_landmarks; }
  inline bool LandmarksHasBeenSet() const { return m_landmarksHasBeenSet; }
  template <typename LandmarksT = Aws::Vector<Landmark>>
  void SetLandmarks(LandmarksT&& value) {
    m_landmarksHasBeenSet = true;
    m_landmarks = std::forward<LandmarksT>(value);
  }
  template <typename LandmarksT = Aws::Vector<Landmark>>
  ComparedFace& WithLandmarks(LandmarksT&& value) {
    SetLandmarks(std::forward<LandmarksT>(value));
    return *this;
  }
  template <typename LandmarksT = Landmark>
  ComparedFace& AddLandmarks(LandmarksT&& value) {
    m_landmarksHasBeenSet = true;
    m_landmarks.emplace_back(std::forward<LandmarksT>(value));
    return *this;
  }
 
 
  inline const Pose& GetPose() const { return m_pose; }
  inline bool PoseHasBeenSet() const { return m_poseHasBeenSet; }
  template <typename PoseT = Pose>
  void SetPose(PoseT&& value) {
    m_poseHasBeenSet = true;
    m_pose = std::forward<PoseT>(value);
  }
  template <typename PoseT = Pose>
  ComparedFace& WithPose(PoseT&& value) {
    SetPose(std::forward<PoseT>(value));
    return *this;
  }
 
 
  inline const ImageQuality& GetQuality() const { return m_quality; }
  inline bool QualityHasBeenSet() const { return m_qualityHasBeenSet; }
  template <typename QualityT = ImageQuality>
  void SetQuality(QualityT&& value) {
    m_qualityHasBeenSet = true;
    m_quality = std::forward<QualityT>(value);
  }
  template <typename QualityT = ImageQuality>
  ComparedFace& WithQuality(QualityT&& value) {
    SetQuality(std::forward<QualityT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Emotion>& GetEmotions() const { return m_emotions; }
  inline bool EmotionsHasBeenSet() const { return m_emotionsHasBeenSet; }
  template <typename EmotionsT = Aws::Vector<Emotion>>
  void SetEmotions(EmotionsT&& value) {
    m_emotionsHasBeenSet = true;
    m_emotions = std::forward<EmotionsT>(value);
  }
  template <typename EmotionsT = Aws::Vector<Emotion>>
  ComparedFace& WithEmotions(EmotionsT&& value) {
    SetEmotions(std::forward<EmotionsT>(value));
    return *this;
  }
  template <typename EmotionsT = Emotion>
  ComparedFace& AddEmotions(EmotionsT&& value) {
    m_emotionsHasBeenSet = true;
    m_emotions.emplace_back(std::forward<EmotionsT>(value));
    return *this;
  }
 
 
  inline const Smile& GetSmile() const { return m_smile; }
  inline bool SmileHasBeenSet() const { return m_smileHasBeenSet; }
  template <typename SmileT = Smile>
  void SetSmile(SmileT&& value) {
    m_smileHasBeenSet = true;
    m_smile = std::forward<SmileT>(value);
  }
  template <typename SmileT = Smile>
  ComparedFace& WithSmile(SmileT&& value) {
    SetSmile(std::forward<SmileT>(value));
    return *this;
  }
 private:
  BoundingBox m_boundingBox;
 
  double m_confidence{0.0};
 
  Aws::Vector<Landmark> m_landmarks;
 
  Pose m_pose;
 
  ImageQuality m_quality;
 
  Aws::Vector<Emotion> m_emotions;
 
  Smile m_smile;
  bool m_boundingBoxHasBeenSet = false;
  bool m_confidenceHasBeenSet = false;
  bool m_landmarksHasBeenSet = false;
  bool m_poseHasBeenSet = false;
  bool m_qualityHasBeenSet = false;
  bool m_emotionsHasBeenSet = false;
  bool m_smileHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Rekognition
}  // namespace Aws