Relevance.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/kendra/Kendra_EXPORTS.h>
#include <aws/kendra/model/Order.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace kendra {
namespace Model {
 
class Relevance {
 public:
  AWS_KENDRA_API Relevance() = default;
  AWS_KENDRA_API Relevance(Aws::Utils::Json::JsonView jsonValue);
  AWS_KENDRA_API Relevance& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_KENDRA_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline bool GetFreshness() const { return m_freshness; }
  inline bool FreshnessHasBeenSet() const { return m_freshnessHasBeenSet; }
  inline void SetFreshness(bool value) {
    m_freshnessHasBeenSet = true;
    m_freshness = value;
  }
  inline Relevance& WithFreshness(bool value) {
    SetFreshness(value);
    return *this;
  }
 
 
  inline int GetImportance() const { return m_importance; }
  inline bool ImportanceHasBeenSet() const { return m_importanceHasBeenSet; }
  inline void SetImportance(int value) {
    m_importanceHasBeenSet = true;
    m_importance = value;
  }
  inline Relevance& WithImportance(int value) {
    SetImportance(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDuration() const { return m_duration; }
  inline bool DurationHasBeenSet() const { return m_durationHasBeenSet; }
  template <typename DurationT = Aws::String>
  void SetDuration(DurationT&& value) {
    m_durationHasBeenSet = true;
    m_duration = std::forward<DurationT>(value);
  }
  template <typename DurationT = Aws::String>
  Relevance& WithDuration(DurationT&& value) {
    SetDuration(std::forward<DurationT>(value));
    return *this;
  }
 
 
  inline Order GetRankOrder() const { return m_rankOrder; }
  inline bool RankOrderHasBeenSet() const { return m_rankOrderHasBeenSet; }
  inline void SetRankOrder(Order value) {
    m_rankOrderHasBeenSet = true;
    m_rankOrder = value;
  }
  inline Relevance& WithRankOrder(Order value) {
    SetRankOrder(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, int>& GetValueImportanceMap() const { return m_valueImportanceMap; }
  inline bool ValueImportanceMapHasBeenSet() const { return m_valueImportanceMapHasBeenSet; }
  template <typename ValueImportanceMapT = Aws::Map<Aws::String, int>>
  void SetValueImportanceMap(ValueImportanceMapT&& value) {
    m_valueImportanceMapHasBeenSet = true;
    m_valueImportanceMap = std::forward<ValueImportanceMapT>(value);
  }
  template <typename ValueImportanceMapT = Aws::Map<Aws::String, int>>
  Relevance& WithValueImportanceMap(ValueImportanceMapT&& value) {
    SetValueImportanceMap(std::forward<ValueImportanceMapT>(value));
    return *this;
  }
  inline Relevance& AddValueImportanceMap(Aws::String key, int value) {
    m_valueImportanceMapHasBeenSet = true;
    m_valueImportanceMap.emplace(key, value);
    return *this;
  }
 private:
  bool m_freshness{false};
 
  int m_importance{0};
 
  Aws::String m_duration;
 
  Order m_rankOrder{Order::NOT_SET};
 
  Aws::Map<Aws::String, int> m_valueImportanceMap;
  bool m_freshnessHasBeenSet = false;
  bool m_importanceHasBeenSet = false;
  bool m_durationHasBeenSet = false;
  bool m_rankOrderHasBeenSet = false;
  bool m_valueImportanceMapHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace kendra
}  // namespace Aws