nvp.hpp

// Copyright 2016 MongoDB 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 <mangrove/config/prelude.hpp>

#include <cstddef>
#include <stdexcept>
#include <tuple>
#include <type_traits>

#include <bsoncxx/types.hpp>

#include <mangrove/expression_syntax.hpp>
#include <mangrove/macros.hpp>
#include <mangrove/util.hpp>

namespace mangrove {
MANGROVE_INLINE_NAMESPACE_BEGIN

template <typename NvpT, typename T>
class nvp_base;

struct current_date_t {
    constexpr current_date_t() {
    }
};
constexpr current_date_t current_date;

template <typename Base, typename T>
class nvp : public nvp_base<nvp<Base, T>, T> {
   public:
    using type = T;
    // In case this field is wrapped in an optional, store the underlying type.
    using no_opt_type = remove_optional_t<T>;

    constexpr nvp(T Base::*t, const char* name) : t(t), name(name) {
    }

    constexpr update_expr<nvp<Base, T>, no_opt_type> operator=(const no_opt_type& val) const {
        return {*this, val, "$set"};
    }

    template <typename U = no_opt_type>
    constexpr std::enable_if_t<is_date_v<U>, current_date_expr<nvp>> operator=(
        const current_date_t&) const {
        return {*this, true};
    }

    template <typename U = no_opt_type>
    constexpr std::enable_if_t<std::is_same<bsoncxx::types::b_timestamp, U>::value,
                               current_date_expr<nvp>>
    operator=(const current_date_t&) const {
        return {*this, false};
    }

    std::string get_name() const {
        return name;
    }

    std::string& append_name(std::string& s) const {
        return s.append(name);
    }

    T Base::*t;
    const char* name;
};

template <typename Base, typename T, typename Parent>
class nvp_child : public nvp_base<nvp_child<Base, T, Parent>, T> {
   public:
    using type = T;
    // In case this field is wrapped in an optional, store the underlying type.
    using no_opt_type = remove_optional_t<T>;

    constexpr nvp_child(T Base::*t, const char* name, const Parent& parent)
        : t(t), name(name), parent(parent) {
    }

    constexpr update_expr<nvp_child<Base, T, Parent>, T> operator=(const no_opt_type& val) const {
        return {*this, val, "$set"};
    }

    template <typename U = no_opt_type>
    constexpr std::enable_if_t<is_date_v<U>, current_date_expr<nvp_child>> operator=(
        const current_date_t&) const {
        return {*this, true};
    }

    template <typename U = no_opt_type>
    constexpr std::enable_if_t<std::is_same<bsoncxx::types::b_timestamp, U>::value,
                               current_date_expr<nvp_child>>
    operator=(const current_date_t&) const {
        return {*this, false};
    }

    std::string get_name() const {
        std::string s;
        return append_name(s);
    }

    std::string& append_name(std::string& s) const {
        return parent.append_name(s).append(1, '.').append(name);
    }

    T Base::*t;
    const char* name;
    const Parent& parent;
};

template <typename NvpT>
class array_element_nvp
    : public nvp_base<array_element_nvp<NvpT>, iterable_value_t<typename NvpT::no_opt_type>> {
   public:
    using type = iterable_value_t<typename NvpT::no_opt_type>;
    // In case this field is wrapped in an optional, store the underlying type.
    using no_opt_type = remove_optional_t<type>;

    constexpr array_element_nvp(const NvpT& nvp, std::size_t i) : _nvp(nvp), _i(i) {
    }

    constexpr update_expr<array_element_nvp<NvpT>, no_opt_type> operator=(
        const no_opt_type& val) const {
        return {*this, val, "$set"};
    }

    std::string get_name() const {
        std::string s;
        return append_name(s);
    }

    std::string& append_name(std::string& s) const {
        return _nvp.append_name(s).append(1, '.').append(std::to_string(_i));
    }

   private:
    const NvpT& _nvp;
    const std::size_t _i;
};

template <typename T>
class free_nvp : public nvp_base<free_nvp<T>, T> {
   public:
    // In case this corresponds to an optional type, store the underlying type.
    using no_opt_type = remove_optional_t<T>;
    using type = T;

    // TODO This shouldn't have a name, but it needs to work with Expressions when building queries.
    std::string& append_name(std::string& s) const {
        return s;
    }
};

template <typename NvpT>
struct is_free_nvp : public std::false_type {};

template <typename T>
struct is_free_nvp<free_nvp<T>> : public std::true_type {};

template <typename T>
constexpr bool is_free_nvp_v = is_free_nvp<T>::value;

template <typename NvpT>
class dollar_operator_nvp : public nvp_base<dollar_operator_nvp<NvpT>, typename NvpT::type> {
   public:
    using type = iterable_value_t<typename NvpT::no_opt_type>;
    // In case this field is wrapped in an optional, store the underlying type.
    using no_opt_type = remove_optional_t<type>;

    constexpr dollar_operator_nvp(const NvpT& nvp) : _nvp(nvp) {
    }

    constexpr update_expr<dollar_operator_nvp<NvpT>, no_opt_type> operator=(
        const no_opt_type& val) const {
        return {*this, val, "$set"};
    }

    std::string get_name() const {
        std::string s;
        return append_name(s);
    }

    std::string& append_name(std::string& s) const {
        return _nvp.append_name(s).append(1, '.').append(1, '$');
    }

   private:
    const NvpT& _nvp;
};

template <typename NvpT, typename T>
class nvp_base {
   private:
    // Type trait that checks if the given iterable class contains the same value type as either
    // a) this nvp's type, or
    // b) this nvp's value type, if this nvp is also an iterable.
    template <typename Iterable, typename Default = void>
    using enable_if_matching_iterable_t =
        std::enable_if_t<is_iterable_not_string_v<Iterable> &&
                             std::is_convertible<iterable_value_t<Iterable>,
                                                 iterable_value_t<remove_optional_t<T>>>::value,
                         Default>;

   public:
    using type = T;
    // In case this field is wrapped in an optional, store the underlying type.
    using no_opt_type = remove_optional_t<T>;
    using child_base_type = iterable_value_t<no_opt_type>;

    template <typename U>
    constexpr nvp_child<iterable_value_t<no_opt_type>, U, NvpT> operator->*(
        const nvp<iterable_value_t<no_opt_type>, U>& child) const {
        return {child.t, child.name, *static_cast<const NvpT*>(this)};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>>
    constexpr array_element_nvp<NvpT> operator[](std::size_t i) const {
        return {*static_cast<const NvpT*>(this), i};
    }

    constexpr sort_expr<NvpT> sort(bool ascending) const {
        return {*static_cast<const NvpT*>(this), ascending};
    }

    template <typename Iterable, typename = enable_if_matching_iterable_t<Iterable>>
    constexpr comparison_expr<NvpT, Iterable> in(const Iterable& iter) const {
        return {*static_cast<const NvpT*>(this), iter, "$in"};
    }

    template <typename Iterable, typename = enable_if_matching_iterable_t<Iterable>>
    constexpr comparison_expr<NvpT, Iterable> nin(const Iterable& iter) const {
        return {*static_cast<const NvpT*>(this), iter, "$nin"};
    }

    template <typename U = T, typename = std::enable_if_t<is_optional_v<U>>>
    constexpr comparison_expr<NvpT, bool> exists(const bool& exists) const {
        return {*static_cast<const NvpT*>(this), exists, "$exists"};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<std::is_arithmetic<U>::value>>
    constexpr mod_expr<NvpT> mod(const int& divisor, const int& remainder) const {
        return {*static_cast<const NvpT*>(this), divisor, remainder};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_string_v<U>>>
    constexpr comparison_value_expr<NvpT, bsoncxx::types::b_regex> regex(
        const char* regex, const char* options) const {
        return {*static_cast<const NvpT*>(this), bsoncxx::types::b_regex(regex, options), "$regex"};
    }

    /* Array Query operators */

    template <typename Iterable, typename = enable_if_matching_iterable_t<Iterable>,
              typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>>
    constexpr comparison_expr<NvpT, Iterable> all(const Iterable& iter) const {
        return {*static_cast<const NvpT*>(this), iter, "$all"};
    }

    template <typename Expr, typename = std::enable_if_t<details::is_query_expression_v<Expr>>,
              typename U = no_opt_type, typename = std::enable_if_t<is_iterable_v<U>>>
    constexpr comparison_expr<NvpT, Expr> elem_match(const Expr& queries) const {
        return {*static_cast<const NvpT*>(this), queries, "$elemMatch"};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>>
    constexpr free_nvp<iterable_value_t<no_opt_type>> element() const {
        return {};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>>
    constexpr comparison_expr<NvpT, std::int64_t> size(const std::int64_t& n) const {
        return {*static_cast<const NvpT*>(this), n, "$size"};
    }

    /* bitwise queries, enabled only for integral types. */

    template <typename U = no_opt_type,
              typename = std::enable_if_t<std::is_integral<U>::value ||
                                          std::is_same<U, bsoncxx::types::b_binary>::value>,
              typename Mask,
              typename = std::enable_if_t<std::is_integral<Mask>::value ||
                                          std::is_same<Mask, bsoncxx::types::b_binary>::value>>
    constexpr comparison_expr<NvpT, Mask> bits_all_set(const Mask& bitmask) const {
        return {*static_cast<const NvpT*>(this), bitmask, "$bitsAllSet"};
    }

    template <typename U = no_opt_type,
              typename = std::enable_if_t<std::is_integral<U>::value ||
                                          std::is_same<U, bsoncxx::types::b_binary>::value>,
              typename... Args>
    constexpr comparison_value_expr<NvpT, std::int64_t> bits_all_set(std::int64_t pos1,
                                                                     std::int64_t pos2,
                                                                     Args... positions) const {
        return {*static_cast<const NvpT*>(this), bit_positions_to_mask(pos1, pos2, positions...),
                "$bitsAllSet"};
    }

    template <typename U = no_opt_type,
              typename = std::enable_if_t<std::is_integral<U>::value ||
                                          std::is_same<U, bsoncxx::types::b_binary>::value>,
              typename Mask,
              typename = std::enable_if_t<std::is_integral<Mask>::value ||
                                          std::is_same<Mask, bsoncxx::types::b_binary>::value>>
    constexpr comparison_expr<NvpT, Mask> bits_any_set(const Mask& bitmask) const {
        return {*static_cast<const NvpT*>(this), bitmask, "$bitsAnySet"};
    }

    template <typename U = no_opt_type,
              typename = std::enable_if_t<std::is_integral<U>::value ||
                                          std::is_same<U, bsoncxx::types::b_binary>::value>,
              typename... Args>
    constexpr comparison_value_expr<NvpT, std::int64_t> bits_any_set(std::int64_t pos1,
                                                                     std::int64_t pos2,
                                                                     Args... positions) const {
        return {*static_cast<const NvpT*>(this), bit_positions_to_mask(pos1, pos2, positions...),
                "$bitsAnySet"};
    }

    template <typename U = no_opt_type,
              typename = std::enable_if_t<std::is_integral<U>::value ||
                                          std::is_same<U, bsoncxx::types::b_binary>::value>,
              typename Mask,
              typename = std::enable_if_t<std::is_integral<Mask>::value ||
                                          std::is_same<Mask, bsoncxx::types::b_binary>::value>>
    constexpr comparison_value_expr<NvpT, Mask> bits_all_clear(const Mask& bitmask) const {
        return {*static_cast<const NvpT*>(this), bitmask, "$bitsAllClear"};
    }

    template <typename U = no_opt_type,
              typename = std::enable_if_t<std::is_integral<U>::value ||
                                          std::is_same<U, bsoncxx::types::b_binary>::value>,
              typename... Args>
    constexpr comparison_value_expr<NvpT, std::int64_t> bits_all_clear(std::int64_t pos1,
                                                                       std::int64_t pos2,
                                                                       Args... positions) const {
        return {*static_cast<const NvpT*>(this), bit_positions_to_mask(pos1, pos2, positions...),
                "$bitsAllClear"};
    }

    template <typename U = no_opt_type,
              typename = std::enable_if_t<std::is_integral<U>::value ||
                                          std::is_same<U, bsoncxx::types::b_binary>::value>,
              typename Mask,
              typename = std::enable_if_t<std::is_integral<Mask>::value ||
                                          std::is_same<Mask, bsoncxx::types::b_binary>::value>>
    constexpr comparison_expr<NvpT, Mask> bits_any_clear(const Mask& bitmask) const {
        return {*static_cast<const NvpT*>(this), bitmask, "$bitsAnyClear"};
    }

    template <typename U = no_opt_type,
              typename = std::enable_if_t<std::is_integral<U>::value ||
                                          std::is_same<U, bsoncxx::types::b_binary>::value>,
              typename... Args>
    constexpr comparison_value_expr<NvpT, std::int64_t> bits_any_clear(std::int64_t pos1,
                                                                       std::int64_t pos2,
                                                                       Args... positions) const {
        return {*static_cast<const NvpT*>(this), bit_positions_to_mask(pos1, pos2, positions...),
                "$bitsAnyClear"};
    }

    constexpr update_expr<NvpT, no_opt_type> set_on_insert(const no_opt_type& val) const {
        return {*static_cast<const NvpT*>(this), val, "$setOnInsert"};
    }

    /* Update operators */

    template <typename U = T, typename = std::enable_if_t<is_optional_v<U>>>
    constexpr unset_expr<NvpT> unset() const {
        return {*static_cast<const NvpT*>(this)};
    }

    constexpr update_expr<NvpT, no_opt_type> min(const no_opt_type& val) const {
        return {*static_cast<const NvpT*>(this), val, "$min"};
    }

    constexpr update_expr<NvpT, no_opt_type> max(const no_opt_type& val) const {
        return {*static_cast<const NvpT*>(this), val, "$max"};
    }

    /* Array update operators */
    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>>
    constexpr dollar_operator_nvp<NvpT> first_match() const {
        return {*static_cast<const NvpT*>(this)};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>>
    constexpr update_value_expr<NvpT, int> pop(bool last) const {
        return {*static_cast<const NvpT*>(this), last ? 1 : -1, "$pop"};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>>
    constexpr update_expr<NvpT, iterable_value_t<no_opt_type>> pull(
        const iterable_value_t<no_opt_type>& val) const {
        return {*static_cast<const NvpT*>(this), val, "$pull"};
    }
    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>,
              typename Expr>
    constexpr std::enable_if_t<details::is_query_expression_v<Expr>, update_expr<NvpT, Expr>> pull(
        const Expr& expr) const {
        return {*static_cast<const NvpT*>(this), expr, "$pull"};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>,
              typename Iterable, typename = enable_if_matching_iterable_t<Iterable>>
    constexpr update_expr<NvpT, Iterable> pull_all(const Iterable& iter) const {
        return {*static_cast<const NvpT*>(this), iter, "$pullAll"};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>>
    constexpr add_to_set_update_expr<NvpT, iterable_value_t<no_opt_type>> add_to_set(
        const iterable_value_t<no_opt_type>& val) const {
        return {*static_cast<const NvpT*>(this), val, false};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>,
              typename Iterable, typename = enable_if_matching_iterable_t<Iterable>>
    constexpr add_to_set_update_expr<NvpT, Iterable> add_to_set(const Iterable& iter) const {
        return {*static_cast<const NvpT*>(this), iter, true};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>>
    constexpr push_update_expr<NvpT, iterable_value_t<no_opt_type>> push(
        const iterable_value_t<no_opt_type>& val) const {
        return {*static_cast<const NvpT*>(this), val, false};
    }

    template <typename U = no_opt_type, typename = std::enable_if_t<is_iterable_not_string_v<U>>,
              typename Iterable, typename = enable_if_matching_iterable_t<Iterable>,
              typename Sort = int,
              typename = std::enable_if_t<details::is_sort_expression_v<Sort> ||
                                          std::is_same<int, Sort>::value>>
    constexpr push_update_expr<NvpT, Iterable, Sort> push(
        const Iterable& iter, bsoncxx::stdx::optional<std::int32_t> slice = bsoncxx::stdx::nullopt,
        const bsoncxx::stdx::optional<Sort>& sort = bsoncxx::stdx::nullopt,
        bsoncxx::stdx::optional<std::uint32_t> position = bsoncxx::stdx::nullopt) const {
        return {*static_cast<const NvpT*>(this), iter, true, slice, sort, position};
    }
};

template <typename>
struct is_nvp : public std::false_type {};

template <typename Base, typename T>
struct is_nvp<nvp<Base, T>> : public std::true_type {};

template <typename Base, typename T, typename Parent>
struct is_nvp<nvp_child<Base, T, Parent>> : public std::true_type {};

template <typename T>
struct is_nvp<free_nvp<T>> : public std::true_type {};

template <typename NvpT>
struct is_nvp<array_element_nvp<NvpT>> : public std::true_type {};

template <typename T>
constexpr bool is_nvp_v = is_nvp<T>::value;

/* Create a name-value pair from a object member and its name */
template <typename Base, typename T>
nvp<Base, T> constexpr make_nvp(T Base::*t, const char* name) {
    return nvp<Base, T>(t, name);
}

template <typename Base, typename T, typename Parent>
nvp_child<Base, T, Parent> constexpr make_nvp_with_parent(const nvp<Base, T>& child,
                                                          const Parent& parent) {
    return nvp_child<Base, T, Parent>(child.t, child.name, parent);
}

// By default, if N>=M the index is out of bounds and hasField is false-y.
template <typename Base, typename T, size_t N, size_t M, bool = (N < M)>
struct hasField : public std::false_type {};

// Nth member in the Base::fields tuple (i.e. the list of fields for which we
// have name-value pairs)
// Must have same type as the given argument.
template <typename Base, typename T, size_t N, size_t M>
struct hasField<Base, T, N, M, true>
    : public std::is_same<T Base::*, decltype(std::get<N>(Base::mangrove_mapped_fields()).t)> {};

// forward declarations for wrapbool
template <typename Base, typename T, size_t N, size_t M, T Base::*t>
    constexpr std::enable_if_t < N<M && !hasField<Base, T, N, M>::value, bool> wrapbool();

template <typename Base, typename T, size_t N, size_t M, T Base::*>
constexpr std::enable_if_t<N == M, bool> wrapbool();

template <typename Base, typename T, size_t N, size_t M, T Base::*t>
    constexpr std::enable_if_t < N<M && hasField<Base, T, N, M>::value, bool> wrapbool() {
    if (std::get<N>(Base::mangrove_mapped_fields()).t == t) {
        return true;
    } else {
        return wrapbool<Base, T, N + 1, M, t>();
    }
}

template <typename Base, typename T, size_t N, size_t M, T Base::*t>
    constexpr std::enable_if_t < N<M && !hasField<Base, T, N, M>::value, bool> wrapbool() {
    return wrapbool<Base, T, N + 1, M, t>();
}

template <typename Base, typename T, size_t N, size_t M, T Base::*>
constexpr std::enable_if_t<N == M, bool> wrapbool() {
    return false;
}

// forward declarations for wrapimpl
template <typename Base, typename T, size_t N, size_t M>
constexpr std::enable_if_t<N == M, const nvp<Base, T>> wrapimpl(T Base::*t);

template <typename Base, typename T, size_t N, size_t M>
constexpr std::enable_if_t<(N < M) && !hasField<Base, T, N, M>::value, const nvp<Base, T>> wrapimpl(
    T Base::*t);

// If Nth field has same type as T, check that it points to the same member.
// If not, check (N+1)th field.
template <typename Base, typename T, size_t N, size_t M>
constexpr std::enable_if_t<(N < M) && hasField<Base, T, N, M>::value, const nvp<Base, T>> wrapimpl(
    T Base::*t) {
    if (std::get<N>(Base::mangrove_mapped_fields()).t == t) {
        return std::get<N>(Base::mangrove_mapped_fields());
    } else {
        return wrapimpl<Base, T, N + 1, M>(t);
    }
}

// If current field doesn't match the type of T, check (N+1)th field.
template <typename Base, typename T, size_t N, size_t M>
constexpr std::enable_if_t<(N < M) && !hasField<Base, T, N, M>::value, const nvp<Base, T>> wrapimpl(
    T Base::*t) {
    return wrapimpl<Base, T, N + 1, M>(t);
}

// If N==M, we've gone past the last field, return nullptr.
template <typename Base, typename T, size_t N, size_t M>
constexpr std::enable_if_t<N == M, const nvp<Base, T>> wrapimpl(T Base::*) {
    return nvp<Base, T>(nullptr, nullptr);
}

template <typename Base, typename T>
constexpr const nvp<Base, T> wrap(T Base::*t) {
    return wrapimpl<Base, T, 0, std::tuple_size<decltype(Base::mangrove_mapped_fields())>::value>(
        t);
}

template <typename T, T, typename = void>
struct hasCallIfFieldIsPresent {};

template <typename Base, typename T, T Base::*ptr>
struct hasCallIfFieldIsPresent<
    T Base::*, ptr,
    std::enable_if_t<wrapbool<
        Base, T, 0, std::tuple_size<decltype(Base::mangrove_mapped_fields())>::value, ptr>()>> {
    static constexpr const nvp<Base, T> call() {
        return wrap(ptr);
    }
};

MANGROVE_INLINE_NAMESPACE_END
}  // namespace mangrove

#include <mangrove/config/postlude.hpp>