util.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 <chrono>
#include <ctime>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>

#include <bsoncxx/stdx/optional.hpp>
#include <bsoncxx/types.hpp>

namespace mangrove {
MANGROVE_INLINE_NAMESPACE_BEGIN

template <bool...>
struct bool_pack;

template <bool... bs>
struct all_true : public std::is_same<bool_pack<bs..., true>, bool_pack<true, bs...>> {};

template <typename S>
struct is_string
    : std::integral_constant<
          bool, std::is_same<char *, typename std::decay<S>::type>::value ||
                    std::is_same<const char *, typename std::decay<S>::type>::value ||
                    std::is_same<wchar_t *, typename std::decay<S>::type>::value ||
                    std::is_same<const wchar_t *, typename std::decay<S>::type>::value> {};

template <typename Char, typename Traits, typename Allocator>
struct is_string<std::basic_string<Char, Traits, Allocator>> : std::true_type {};

template <typename S>
constexpr bool is_string_v = is_string<S>::value;

// To allow ADL with custom begin/end
using std::begin;
using std::end;

template <typename T>
auto is_iterable_impl(int)
    -> decltype(begin(std::declval<T &>()) !=
                    end(std::declval<T &>()),  // begin/end and operator !=
                void(),                        // Handle evil operator ,
                ++std::declval<decltype(begin(std::declval<T &>())) &>(),  // operator ++
                void(*begin(std::declval<T &>())),                         // operator*
                std::true_type{});

template <typename>
std::false_type is_iterable_impl(...);

template <typename T>
using is_iterable = decltype(is_iterable_impl<T>(0));

template <typename T>
constexpr bool is_iterable_v = is_iterable<T>::value;

// Matches iterables, but NOT strings or char arrays.
template <typename T>
using is_iterable_not_string = std::integral_constant<int, is_iterable_v<T> && !is_string_v<T>>;

template <typename T>
constexpr bool is_iterable_not_string_v = is_iterable_not_string<T>::value;

template <typename T>
typename T::iterator::value_type iterable_value_impl(int);

template <typename T>
T iterable_value_impl(...);

template <typename T>
using iterable_value_t = decltype(iterable_value_impl<T>(0));

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

template <typename T>
struct is_optional<bsoncxx::stdx::optional<T>> : public std::true_type {};

template <typename T>
constexpr bool is_optional_v = is_optional<T>::value;

template <typename T>
struct remove_optional {
    using type = T;
};

template <typename T>
struct remove_optional<bsoncxx::stdx::optional<T>> {
    using type = T;
};

template <typename T>
using remove_optional_t = typename remove_optional<T>::type;

constexpr std::int64_t bit_positions_to_mask() {
    return 0;
}

template <typename... Args>
constexpr std::int64_t bit_positions_to_mask(std::int64_t pos, Args... positions) {
    pos<0 || pos> 63 ? throw std::logic_error("Invalid pos") : 0;
    return (1 << pos) | bit_positions_to_mask(positions...);
}

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

template <typename Rep, typename Period>
struct is_date<std::chrono::duration<Rep, Period>> : public std::true_type {};

template <typename Clock, typename Duration>
struct is_date<std::chrono::time_point<Clock, Duration>> : public std::true_type {};

template <>
struct is_date<bsoncxx::types::b_date> : public std::true_type {};

template <typename T>
constexpr bool is_date_v = is_date<T>::value;

template <typename Map, typename... Ts, size_t... idxs>
constexpr void tuple_for_each_impl(const std::tuple<Ts...> &tup, Map &&map,
                                   std::index_sequence<idxs...>) {
    (void)std::initializer_list<int>{(map(std::get<idxs>(tup)), 0)...};
}

template <typename Map, typename... Ts>
constexpr void tuple_for_each(const std::tuple<Ts...> &tup, Map &&map) {
    return tuple_for_each_impl(tup, std::forward<Map>(map), std::index_sequence_for<Ts...>());
}

template <typename... Ts>
struct first_two_types_are_same : public std::false_type {};

template <typename T, typename T2, typename... Ts>
struct first_two_types_are_same<T, T2, Ts...> : public std::is_same<T, std::decay_t<T2>> {};

template <typename container_type, typename T>
struct container_of : public std::is_same<typename container_type::value_type, T> {};

template <typename container_type, typename T>
constexpr bool container_of_v = container_of<container_type, T>::value;

template <typename iterator_type, typename T>
struct iterator_of
    : public std::is_same<typename std::iterator_traits<iterator_type>::value_type, T> {};

template <typename iterator_type, typename T>
constexpr bool iterator_of_v = iterator_of<iterator_type, T>::value;

MANGROVE_INLINE_NAMESPACE_END
}  // namespace mangrove

#include <mangrove/config/postlude.hpp>