SearchRequest.h

 
#pragma once
#include <aws/cloudsearchdomain/CloudSearchDomain_EXPORTS.h>
#include <aws/cloudsearchdomain/CloudSearchDomainRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/cloudsearchdomain/model/QueryParser.h>
#include <utility>
 
namespace Aws
{
namespace Http
{
    class URI;
} //namespace Http
namespace CloudSearchDomain
{
namespace Model
{
 
  class SearchRequest : public CloudSearchDomainRequest
  {
  public:
    AWS_CLOUDSEARCHDOMAIN_API SearchRequest() = default;
 
    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "Search"; }
 
    AWS_CLOUDSEARCHDOMAIN_API Aws::String SerializePayload() const override;
 
    AWS_CLOUDSEARCHDOMAIN_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
 
 
 
    inline const Aws::String& GetCursor() const { return m_cursor; }
    inline bool CursorHasBeenSet() const { return m_cursorHasBeenSet; }
    template<typename CursorT = Aws::String>
    void SetCursor(CursorT&& value) { m_cursorHasBeenSet = true; m_cursor = std::forward<CursorT>(value); }
    template<typename CursorT = Aws::String>
    SearchRequest& WithCursor(CursorT&& value) { SetCursor(std::forward<CursorT>(value)); return *this;}
 
 
    inline const Aws::String& GetExpr() const { return m_expr; }
    inline bool ExprHasBeenSet() const { return m_exprHasBeenSet; }
    template<typename ExprT = Aws::String>
    void SetExpr(ExprT&& value) { m_exprHasBeenSet = true; m_expr = std::forward<ExprT>(value); }
    template<typename ExprT = Aws::String>
    SearchRequest& WithExpr(ExprT&& value) { SetExpr(std::forward<ExprT>(value)); return *this;}
 
 
    inline const Aws::String& GetFacet() const { return m_facet; }
    inline bool FacetHasBeenSet() const { return m_facetHasBeenSet; }
    template<typename FacetT = Aws::String>
    void SetFacet(FacetT&& value) { m_facetHasBeenSet = true; m_facet = std::forward<FacetT>(value); }
    template<typename FacetT = Aws::String>
    SearchRequest& WithFacet(FacetT&& value) { SetFacet(std::forward<FacetT>(value)); return *this;}
 
 
    inline const Aws::String& GetFilterQuery() const { return m_filterQuery; }
    inline bool FilterQueryHasBeenSet() const { return m_filterQueryHasBeenSet; }
    template<typename FilterQueryT = Aws::String>
    void SetFilterQuery(FilterQueryT&& value) { m_filterQueryHasBeenSet = true; m_filterQuery = std::forward<FilterQueryT>(value); }
    template<typename FilterQueryT = Aws::String>
    SearchRequest& WithFilterQuery(FilterQueryT&& value) { SetFilterQuery(std::forward<FilterQueryT>(value)); return *this;}
 
 
    inline const Aws::String& GetHighlight() const { return m_highlight; }
    inline bool HighlightHasBeenSet() const { return m_highlightHasBeenSet; }
    template<typename HighlightT = Aws::String>
    void SetHighlight(HighlightT&& value) { m_highlightHasBeenSet = true; m_highlight = std::forward<HighlightT>(value); }
    template<typename HighlightT = Aws::String>
    SearchRequest& WithHighlight(HighlightT&& value) { SetHighlight(std::forward<HighlightT>(value)); return *this;}
 
 
    inline bool GetPartial() const { return m_partial; }
    inline bool PartialHasBeenSet() const { return m_partialHasBeenSet; }
    inline void SetPartial(bool value) { m_partialHasBeenSet = true; m_partial = value; }
    inline SearchRequest& WithPartial(bool value) { SetPartial(value); return *this;}
 
 
    inline const Aws::String& GetQuery() const { return m_query; }
    inline bool QueryHasBeenSet() const { return m_queryHasBeenSet; }
    template<typename QueryT = Aws::String>
    void SetQuery(QueryT&& value) { m_queryHasBeenSet = true; m_query = std::forward<QueryT>(value); }
    template<typename QueryT = Aws::String>
    SearchRequest& WithQuery(QueryT&& value) { SetQuery(std::forward<QueryT>(value)); return *this;}
 
 
    inline const Aws::String& GetQueryOptions() const { return m_queryOptions; }
    inline bool QueryOptionsHasBeenSet() const { return m_queryOptionsHasBeenSet; }
    template<typename QueryOptionsT = Aws::String>
    void SetQueryOptions(QueryOptionsT&& value) { m_queryOptionsHasBeenSet = true; m_queryOptions = std::forward<QueryOptionsT>(value); }
    template<typename QueryOptionsT = Aws::String>
    SearchRequest& WithQueryOptions(QueryOptionsT&& value) { SetQueryOptions(std::forward<QueryOptionsT>(value)); return *this;}
 
 
    inline QueryParser GetQueryParser() const { return m_queryParser; }
    inline bool QueryParserHasBeenSet() const { return m_queryParserHasBeenSet; }
    inline void SetQueryParser(QueryParser value) { m_queryParserHasBeenSet = true; m_queryParser = value; }
    inline SearchRequest& WithQueryParser(QueryParser value) { SetQueryParser(value); return *this;}
 
 
    inline const Aws::String& GetReturn() const { return m_return; }
    inline bool ReturnHasBeenSet() const { return m_returnHasBeenSet; }
    template<typename ReturnT = Aws::String>
    void SetReturn(ReturnT&& value) { m_returnHasBeenSet = true; m_return = std::forward<ReturnT>(value); }
    template<typename ReturnT = Aws::String>
    SearchRequest& WithReturn(ReturnT&& value) { SetReturn(std::forward<ReturnT>(value)); return *this;}
 
 
    inline long long GetSize() const { return m_size; }
    inline bool SizeHasBeenSet() const { return m_sizeHasBeenSet; }
    inline void SetSize(long long value) { m_sizeHasBeenSet = true; m_size = value; }
    inline SearchRequest& WithSize(long long value) { SetSize(value); return *this;}
 
 
    inline const Aws::String& GetSort() const { return m_sort; }
    inline bool SortHasBeenSet() const { return m_sortHasBeenSet; }
    template<typename SortT = Aws::String>
    void SetSort(SortT&& value) { m_sortHasBeenSet = true; m_sort = std::forward<SortT>(value); }
    template<typename SortT = Aws::String>
    SearchRequest& WithSort(SortT&& value) { SetSort(std::forward<SortT>(value)); return *this;}
 
 
    inline long long GetStart() const { return m_start; }
    inline bool StartHasBeenSet() const { return m_startHasBeenSet; }
    inline void SetStart(long long value) { m_startHasBeenSet = true; m_start = value; }
    inline SearchRequest& WithStart(long long value) { SetStart(value); return *this;}
 
 
    inline const Aws::String& GetStats() const { return m_stats; }
    inline bool StatsHasBeenSet() const { return m_statsHasBeenSet; }
    template<typename StatsT = Aws::String>
    void SetStats(StatsT&& value) { m_statsHasBeenSet = true; m_stats = std::forward<StatsT>(value); }
    template<typename StatsT = Aws::String>
    SearchRequest& WithStats(StatsT&& value) { SetStats(std::forward<StatsT>(value)); return *this;}
  private:
 
    Aws::String m_cursor;
    bool m_cursorHasBeenSet = false;
 
    Aws::String m_expr;
    bool m_exprHasBeenSet = false;
 
    Aws::String m_facet;
    bool m_facetHasBeenSet = false;
 
    Aws::String m_filterQuery;
    bool m_filterQueryHasBeenSet = false;
 
    Aws::String m_highlight;
    bool m_highlightHasBeenSet = false;
 
    bool m_partial{false};
    bool m_partialHasBeenSet = false;
 
    Aws::String m_query;
    bool m_queryHasBeenSet = false;
 
    Aws::String m_queryOptions;
    bool m_queryOptionsHasBeenSet = false;
 
    QueryParser m_queryParser{QueryParser::NOT_SET};
    bool m_queryParserHasBeenSet = false;
 
    Aws::String m_return;
    bool m_returnHasBeenSet = false;
 
    long long m_size{0};
    bool m_sizeHasBeenSet = false;
 
    Aws::String m_sort;
    bool m_sortHasBeenSet = false;
 
    long long m_start{0};
    bool m_startHasBeenSet = false;
 
    Aws::String m_stats;
    bool m_statsHasBeenSet = false;
  };
 
} // namespace Model
} // namespace CloudSearchDomain
} // namespace Aws