mutate_in_specs.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/subdoc/fwd/command.hxx>
#include <couchbase/subdoc/fwd/command_bundle.hxx>
 
#include <couchbase/codec/default_json_transcoder.hxx>
#include <couchbase/subdoc/array_add_unique.hxx>
#include <couchbase/subdoc/array_append.hxx>
#include <couchbase/subdoc/array_insert.hxx>
#include <couchbase/subdoc/array_prepend.hxx>
#include <couchbase/subdoc/counter.hxx>
#include <couchbase/subdoc/insert.hxx>
#include <couchbase/subdoc/mutate_in_macro.hxx>
#include <couchbase/subdoc/remove.hxx>
#include <couchbase/subdoc/replace.hxx>
#include <couchbase/subdoc/upsert.hxx>
 
#include <vector>
 
namespace couchbase
{
#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
namespace
{
template<typename Value>
std::vector<std::vector<std::byte>>
encode_array(const Value& value)
{
  return { std::move(codec::default_json_transcoder::encode(value).data) };
}
 
template<typename Value>
std::vector<std::vector<std::byte>>
encode_array(std::vector<std::vector<std::byte>>&& output, const Value& value)
{
  output.emplace_back(std::move(codec::default_json_transcoder::encode(value).data));
  return std::move(output);
}
 
template<typename Value, typename... Rest>
std::vector<std::vector<std::byte>>
encode_array(std::vector<std::vector<std::byte>>&& output, const Value& value, Rest... args)
{
  output.emplace_back(std::move(codec::default_json_transcoder::encode(value).data));
  return encode_array(std::move(output), args...);
}
 
template<typename Value, typename... Rest>
std::vector<std::vector<std::byte>>
encode_array(const Value& value, Rest... args)
{
  return encode_array(encode_array(value), args...);
}
 
} // namespace
#endif
 
class mutate_in_specs
{
public:
  mutate_in_specs() = default;
 
  template<typename... Operation>
  explicit mutate_in_specs(Operation... args)
  {
    push_back(args...);
  }
 
  template<typename Value>
  static auto replace(std::string path, const Value& value) -> subdoc::replace
  {
    return { std::move(path), std::move(codec::default_json_transcoder::encode(value).data) };
  }
 
  static auto replace(std::string path, subdoc::mutate_in_macro value) -> subdoc::replace
  {
    return { std::move(path), value };
  }
 
  static auto replace_raw(std::string path,
                          std::vector<std::byte> value,
                          bool expand_macro = false) -> subdoc::replace
  {
    return { std::move(path), std::move(value), expand_macro };
  }
 
  template<typename Value>
  static auto insert(std::string path, const Value& value) -> subdoc::insert
  {
    return { std::move(path), std::move(codec::default_json_transcoder::encode(value).data) };
  }
 
  static auto insert(std::string path, subdoc::mutate_in_macro value) -> subdoc::insert
  {
    return { std::move(path), value };
  }
 
  static auto insert_raw(std::string path,
                         std::vector<std::byte> value,
                         bool expand_macro = false) -> subdoc::insert
  {
    return { std::move(path), std::move(value), expand_macro };
  }
 
  static auto remove(std::string path) -> subdoc::remove
  {
    return subdoc::remove{ std::move(path) };
  }
 
  template<typename Value>
  static auto upsert(std::string path, const Value& value) -> subdoc::upsert
  {
    return { std::move(path), std::move(codec::default_json_transcoder::encode(value).data) };
  }
 
  static auto upsert(std::string path, subdoc::mutate_in_macro value) -> subdoc::upsert
  {
    return { std::move(path), value };
  }
 
  static auto upsert_raw(std::string path,
                         std::vector<std::byte> value,
                         bool expand_macro = false) -> subdoc::upsert
  {
    return { std::move(path), std::move(value), expand_macro };
  }
 
  static auto increment(std::string path, std::int64_t delta) -> subdoc::counter
  {
    if (delta < 0) {
      throw std::system_error(errc::common::invalid_argument,
                              "only positive delta allowed in subdoc increment, given: " +
                                std::to_string(delta));
    }
    return { std::move(path), delta };
  }
 
  static auto decrement(std::string path, std::int64_t delta) -> subdoc::counter
  {
    if (delta < 0) {
      throw std::system_error(errc::common::invalid_argument,
                              "only positive delta allowed in subdoc decrement, given: " +
                                std::to_string(delta));
    }
    return { std::move(path), -1 * delta };
  }
 
  template<typename... Values>
  static auto array_append(std::string path, Values... values) -> subdoc::array_append
  {
    return { std::move(path), encode_array(values...) };
  }
 
  static auto array_append_raw(std::string path,
                               std::vector<std::byte> values) -> subdoc::array_append
  {
    return { std::move(path), { std::move(values) } };
  }
 
  template<typename... Values>
  static auto array_prepend(std::string path, Values... values) -> subdoc::array_prepend
  {
    return { std::move(path), encode_array(values...) };
  }
 
  static auto array_prepend_raw(std::string path,
                                std::vector<std::byte> values) -> subdoc::array_prepend
  {
    return { std::move(path), { std::move(values) } };
  }
 
  template<typename... Values>
  static auto array_insert(std::string path, Values... values) -> subdoc::array_insert
  {
    return { std::move(path), encode_array(values...) };
  }
 
  static auto array_insert_raw(std::string path,
                               std::vector<std::byte> values) -> subdoc::array_insert
  {
    return { std::move(path), { std::move(values) } };
  }
 
  template<typename Value>
  static auto array_add_unique(std::string path, const Value& value) -> subdoc::array_add_unique
  {
    return { std::move(path), std::move(codec::default_json_transcoder::encode(value).data) };
  }
 
  static auto array_add_unique(std::string path,
                               subdoc::mutate_in_macro value) -> subdoc::array_add_unique
  {
    return { std::move(path), value };
  }
 
  static auto array_add_unique_raw(std::string path,
                                   std::vector<std::byte> value,
                                   bool expand_macro = false) -> subdoc::array_add_unique
  {
    return { std::move(path), std::move(value), expand_macro };
  }
 
  template<typename Operation>
  void push_back(const Operation& operation)
  {
    operation.encode(bundle());
  }
 
  template<typename Operation, typename... Rest>
  void push_back(const Operation& operation, Rest... args)
  {
    push_back(operation);
    push_back(args...);
  }
 
  [[nodiscard]] auto specs() const -> const std::vector<core::impl::subdoc::command>&;
 
private:
  [[nodiscard]] auto bundle() -> core::impl::subdoc::command_bundle&;
 
  std::shared_ptr<core::impl::subdoc::command_bundle> specs_{};
};
} // namespace couchbase