search_options.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *   Copyright 2020-Present Couchbase, Inc.
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
 
#pragma once
 
#include <couchbase/common_options.hxx>
#include <couchbase/error.hxx>
#include <couchbase/highlight_style.hxx>
#include <couchbase/mutation_state.hxx>
#include <couchbase/search_facet.hxx>
#include <couchbase/search_result.hxx>
#include <couchbase/search_scan_consistency.hxx>
#include <couchbase/search_scoring.hxx>
#include <couchbase/search_sort.hxx>
 
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <stdexcept>
#include <type_traits>
 
namespace couchbase
{
namespace codec
{
class tao_json_serializer;
}

struct search_options : public common_options<search_options> {
  struct built : public common_options<search_options>::built {
    std::optional<std::string> client_context_id{};
    bool include_locations{ false };
    bool disable_scoring{ false };
    std::optional<bool> explain{};
    std::optional<std::uint32_t> limit{};
    std::optional<std::uint32_t> skip{};
    std::vector<std::string> collections{};
    std::vector<std::string> fields{};
    std::vector<std::string> highlight_fields{};
    std::optional<couchbase::highlight_style> highlight_style{};
    std::optional<search_scan_consistency> scan_consistency{};
    std::vector<mutation_token> mutation_state{};
    std::map<std::string, codec::binary, std::less<>> raw{};
    std::map<std::string, std::shared_ptr<search_facet>, std::less<>> facets{};
    std::vector<std::shared_ptr<search_sort>> sort{};
    std::vector<std::string> sort_string{};
    std::optional<search_scoring::built> scoring{};
  };

  [[nodiscard]] auto build() const -> built
  {
    return {
      build_common_options(),
      client_context_id_,
      include_locations_,
      disable_scoring_,
      explain_,
      limit_,
      skip_,
      collections_,
      fields_,
      highlight_fields_,
      highlight_style_,
      scan_consistency_,
      mutation_state_,
      raw_,
      facets_,
      sort_,
      sort_string_,
      scoring_,
    };
  }

  auto client_context_id(std::string client_context_id) -> search_options&
  {
    if (client_context_id.empty()) {
      client_context_id_.reset();
    } else {
      client_context_id_ = std::move(client_context_id);
    }
    return self();
  }

  auto scan_consistency(search_scan_consistency scan_consistency) -> search_options&
  {
    scan_consistency_ = scan_consistency;
    mutation_state_.clear();
    return self();
  }

  auto consistent_with(const mutation_state& state) -> search_options&
  {
    mutation_state_ = state.tokens();
    scan_consistency_.reset();
    return self();
  }

  template<typename Value,
           typename Serializer = codec::tao_json_serializer,
           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
  auto raw(std::string name, const Value& value) -> search_options&
  {
    raw_[std::move(name)] = std::move(Serializer::template serialize<Value>(value));
    return self();
  }

  auto skip(std::uint32_t skip) -> search_options&
  {
    skip_ = skip;
    return self();
  }

  auto limit(std::uint32_t limit) -> search_options&
  {
    limit_ = limit;
    return self();
  }

  auto explain(bool explain) -> search_options&
  {
    explain_ = explain;
    return self();
  }

  [[deprecated("Use search_options::scoring(search_scoring_none{}) instead.")]]
  auto disable_scoring(bool disable) -> search_options&
  {
    if (disable && scoring_.has_value()) {
      throw std::invalid_argument("disable_scoring() cannot be used together with scoring()");
    }
    disable_scoring_ = disable;
    return self();
  }

  template<typename Scoring,
           std::enable_if_t<std::is_base_of_v<search_scoring, Scoring>, bool> = true>
  auto scoring(const Scoring& scoring) -> search_options&
  {
    if (disable_scoring_) {
      throw std::invalid_argument("scoring() cannot be used together with disable_scoring()");
    }
    scoring_ = scoring.build();
    return self();
  }

  auto include_locations(bool include) -> search_options&
  {
    include_locations_ = include;
    return self();
  }

  auto collections(std::vector<std::string> collections) -> search_options&
  {
    collections_ = std::move(collections);
    return self();
  }

  auto fields(std::vector<std::string> fields) -> search_options&
  {
    fields_ = std::move(fields);
    return self();
  }

  auto highlight(highlight_style style = highlight_style::html,
                 std::vector<std::string> fields = {}) -> search_options&
  {
    highlight_style_ = style;
    highlight_fields_ = std::move(fields);
    return self();
  }

  auto highlight(std::vector<std::string> fields) -> search_options&
  {
    highlight_style_ = highlight_style::html;
    highlight_fields_ = std::move(fields);
    return self();
  }

  auto sort(std::vector<std::string> sort_expressions) -> search_options&
  {
    sort_string_ = std::move(sort_expressions);
    return self();
  }

  auto sort(std::vector<std::shared_ptr<search_sort>> sort_objects) -> search_options&
  {
    sort_ = std::move(sort_objects);
    return self();
  }

  auto facets(std::map<std::string, std::shared_ptr<search_facet>> facets) -> search_options&
  {
    facets_.clear();
    for (auto& [name, facet] : facets) {
      facets_[name] = std::move(facet);
    }
    return self();
  }

  template<typename... Facets>
  auto facets(const Facets&... facets) -> search_options&
  {
    facets_.clear();
    encode_facet(facets...);
    return self();
  }

  auto facet(std::string name, std::shared_ptr<search_facet> facet) -> search_options&
  {
    facets_[std::move(name)] = std::move(facet);
    return self();
  }

  template<typename Facet>
  auto facet(std::string name, Facet facet) -> search_options&
  {
    facets_[std::move(name)] = std::make_shared<Facet>(std::move(facet));
    return self();
  }
 
private:
  template<typename Name, typename Facet, typename... Rest>
  void encode_facet(const std::pair<Name, Facet>& facet, Rest... args)
  {
    facets_[std::move(facet.first)] = std::make_shared<Facet>(std::move(facet.second));
    if constexpr (sizeof...(args) > 0) {
      encode_facet(args...);
    }
  }
 
  std::optional<std::string> client_context_id_{};
  bool include_locations_{ false };
  bool disable_scoring_{ false };
  std::optional<bool> explain_{};
  std::optional<std::uint32_t> limit_{};
  std::optional<std::uint32_t> skip_{};
  std::vector<std::string> collections_{};
  std::vector<std::string> fields_{};
  std::vector<std::string> highlight_fields_{};
  std::optional<highlight_style> highlight_style_{};
  std::optional<search_scan_consistency> scan_consistency_{};
  std::vector<mutation_token> mutation_state_{};
  std::map<std::string, codec::binary, std::less<>> raw_{};
  std::map<std::string, std::shared_ptr<search_facet>, std::less<>> facets_{};
  std::vector<std::shared_ptr<search_sort>> sort_{};
  std::vector<std::string> sort_string_{};
  std::optional<search_scoring::built> scoring_{};
};

using search_handler = std::function<void(error, search_result)>;
} // namespace couchbase