Relevance.h

 
#pragma once
#include <aws/kendra/Kendra_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/kendra/model/Order.h>
#include <aws/core/utils/memory/stl/AWSMap.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};
    bool m_freshnessHasBeenSet = false;
 
    int m_importance{0};
    bool m_importanceHasBeenSet = false;
 
    Aws::String m_duration;
    bool m_durationHasBeenSet = false;
 
    Order m_rankOrder{Order::NOT_SET};
    bool m_rankOrderHasBeenSet = false;
 
    Aws::Map<Aws::String, int> m_valueImportanceMap;
    bool m_valueImportanceMapHasBeenSet = false;
  };
 
} // namespace Model
} // namespace kendra
} // namespace Aws