5#include <bsoncxx/config/prelude.hpp>
8inline namespace v_noabi {
11#define bsoncxx_ttparam \
17using type_t =
typename T::type;
21using value_type_t =
typename T::value_type;
23template <
bool B,
typename T =
void>
24using enable_if_t =
typename std::enable_if<B, T>::type;
26#pragma push_macro("DECL_ALIAS")
27#define DECL_ALIAS(Name) \
28 template <typename T> \
29 using Name##_t = type_t<std::Name<T>>
31DECL_ALIAS(make_signed);
32DECL_ALIAS(make_unsigned);
33DECL_ALIAS(remove_reference);
34DECL_ALIAS(remove_const);
35DECL_ALIAS(remove_volatile);
38DECL_ALIAS(add_volatile);
39DECL_ALIAS(add_lvalue_reference);
40DECL_ALIAS(add_rvalue_reference);
41#pragma pop_macro("DECL_ALIAS")
43template <
typename... Ts>
44using common_type_t = type_t<std::common_type<Ts...>>;
50using remove_cvref_t = remove_cv_t<remove_reference_t<T>>;
56using const_reference_t = add_lvalue_reference_t<const remove_cvref_t<T>>;
63template <
typename... Ts>
70using bool_constant = std::integral_constant<bool, B>;
81namespace impl_detection {
92 typename SfinaeHere = Oper<Args...>>
93std::true_type is_detected_f(mp_list<Args...>*);
97template <bsoncxx_ttparam Oper,
typename... Args>
98std::false_type is_detected_f(...);
101template <
bool IsDetected>
106struct detection<false> {
108 template <
typename Default, bsoncxx_ttparam,
typename...>
114struct detection<true> {
115 template <
typename, bsoncxx_ttparam Oper,
typename... Args>
116 using f = Oper<Args...>;
126 ~nonesuch() =
delete;
127 nonesuch(nonesuch
const&) =
delete;
128 void operator=(nonesuch
const&) =
delete;
138template <bsoncxx_ttparam Oper,
typename... Args>
140 : decltype(impl_detection::is_detected_f<Oper>(static_cast<mp_list<Args...>*>(nullptr))) {};
150template <
typename Dflt, bsoncxx_ttparam Oper,
typename... Args>
151using detected_or =
typename impl_detection::detection<
152 is_detected<Oper, Args...>::value>::template f<Dflt, Oper, Args...>;
161template <bsoncxx_ttparam Oper,
typename... Args>
162using detected_t = detected_or<nonesuch, Oper, Args...>;
173 template <
typename IfTrue,
typename>
178struct conditional<false> {
179 template <
typename,
typename IfFalse>
190template <
bool B,
typename T,
typename F>
191using conditional_t =
typename conditional<B>::template f<T, F>;
194namespace impl_logic {
196template <
typename FalseType,
typename Opers>
199template <
typename H,
typename... Tail>
200struct conj<bool_constant<H::value || !sizeof...(Tail)>, mp_list<H, Tail...>> : H {};
202template <
typename F,
typename H,
typename... Tail>
203struct conj<F, mp_list<H, Tail...>> : conj<F, mp_list<Tail...>> {};
206struct conj<std::false_type, mp_list<H>> : H {};
209struct conj<std::false_type, mp_list<>> : std::true_type {};
211template <
typename TrueType,
typename Opers>
214template <
typename H,
typename... Tail>
215struct disj<bool_constant<H::value && sizeof...(Tail)>, mp_list<H, Tail...>> : H {};
217template <
typename F,
typename H,
typename... Tail>
218struct disj<F, mp_list<H, Tail...>> : disj<F, mp_list<Tail...>> {};
221struct disj<std::true_type, mp_list<H>> : H {};
224struct disj<std::true_type, mp_list<>> : std::false_type {};
236template <
typename... Cond>
237struct conjunction : impl_logic::conj<std::false_type, mp_list<Cond...>> {};
247template <
typename... Cond>
248struct disjunction : impl_logic::disj<std::true_type, mp_list<Cond...>> {};
256struct negation : bool_constant<!T::value> {};
264template <
typename...>
265using true_t = std::true_type;
267namespace impl_requires {
270R norm_conjunction(...);
272template <
typename R,
typename... Cs>
273conjunction<Cs...> norm_conjunction(
const conjunction<Cs...>&);
276using norm_conjunction_t =
decltype(norm_conjunction<T>(std::declval<const T&>()));
278template <
typename Constra
int,
typename =
void>
281template <
typename FailingRequirement>
282struct failed_requirement {
283 failed_requirement(
int) =
delete;
285 template <
typename T>
286 static T explain(failed_requirement);
289template <
typename... SubRequirements>
290struct failed_requirement<conjunction<SubRequirements...>> {
291 failed_requirement(
int) =
delete;
293 template <
typename T>
294 static auto explain(
int)
295 -> common_type_t<
decltype(requirement<SubRequirements>::test::template explain<T>(0))...>;
298template <
typename Constra
int,
typename>
300 using test = failed_requirement<impl_requires::norm_conjunction_t<Constraint>>;
303template <
typename Constra
int>
304struct requirement<Constraint, enable_if_t<Constraint::value>> {
306 template <
typename T>
307 static T explain(
int);
322template <
typename Type,
typename... Traits>
323#if defined _MSC_VER && _MSC_VER < 1920
325using requires_t = enable_if_t<conjunction<Traits...>::value, Type>;
329 decltype(impl_requires::requirement<conjunction<Traits...>>::test::template explain<Type>(0));
341template <
typename Type,
typename... Traits>
342using requires_not_t = requires_t<Type, negation<disjunction<Traits...>>>;
345namespace impl_invoke {
347#pragma push_macro("RETURNS")
348#define RETURNS(...) \
349 noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { \
350 return __VA_ARGS__; \
352 static_assert(true, "")
354template <
bool IsMemberObject,
bool IsMemberFunction>
356 template <
typename F,
typename... Args>
357 constexpr static auto apply(F&& fun, Args&&... args)
358 RETURNS(
static_cast<F&&
>(fun)(
static_cast<Args&&
>(args)...));
362struct invoker<false, true> {
363 template <
typename F,
typename Self,
typename... Args>
364 constexpr static auto apply(F&& fun, Self&& self, Args&&... args)
365 RETURNS((
static_cast<Self&&
>(self).*fun)(
static_cast<Args&&
>(args)...));
369struct invoker<true, false> {
370 template <
typename F,
typename Self>
371 constexpr static auto apply(F&& fun, Self&& self) RETURNS(
static_cast<Self&&
>(self).*fun);
376static constexpr struct invoke_fn {
384 template <
typename F,
typename... Args,
typename Fd = remove_cvref_t<F>>
385 constexpr auto operator()(F&& fn, Args&&... args)
const
386 RETURNS(impl_invoke::invoker<std::is_member_object_pointer<Fd>::value,
387 std::is_member_function_pointer<Fd>::value>
388 ::apply(
static_cast<F&&
>(fn),
static_cast<Args&&
>(args)...));
391#pragma pop_macro("RETURNS")
399template <
typename F,
typename... Args>
400using invoke_result_t =
decltype(invoke(std::declval<F>(), std::declval<Args>()...));
408template <
typename Fun,
typename... Args>
409#if defined(_MSC_VER) && _MSC_VER < 1910
410using is_invocable = is_detected<invoke_result_t, Fun, Args...>;
412struct is_invocable : is_detected<invoke_result_t, Fun, Args...> {
420template <
typename T,
typename U>
421struct is_alike : std::is_same<remove_cvref_t<T>, remove_cvref_t<U>> {};
429#include <bsoncxx/config/postlude.hpp>
The top-level namespace for bsoncxx library entities.
Definition element.hpp:24