void operator()(R&&, T&&) const
{
CONCEPT_ASSERT_MSG(RandomAccessRange<R>(),
"ranges::at(rng, idx): rng argument must be a model of the RandomAccessRange concept.");
CONCEPT_ASSERT_MSG(ConvertibleTo<T, range_difference_type_t<R>>(),
"ranges::at(rng, idx): idx argument must be convertible to range_difference_type_t<rng>.");
}
void operator()(Val, std::ptrdiff_t) const
{
CONCEPT_ASSERT_MSG(std::is_object<Val>(),
"The value passed to view::repeat must be an object.");
CONCEPT_ASSERT_MSG(CopyConstructible<Val>(),
"The value passed to view::repeat must be CopyConstructible.");
}
void operator()(Rng &&) const
{
CONCEPT_ASSERT_MSG(InputRange<Rng>(),
"The argument of view::keys must be a model of the InputRange concept.");
CONCEPT_ASSERT_MSG(detail::PairLike<range_value_t<Rng>>(),
"The value type of the range passed to view::keys must look like a std::pair; "
"That is, it must have first and second data members.");
}
void operator()(G, std::size_t) const
{
CONCEPT_ASSERT_MSG(Function<G>(),
"The argument to view::generate must be a function that is callable with "
"no arguments");
CONCEPT_ASSERT_MSG(meta::not_<Same<void, concepts::Function::result_t<G>>>(),
"The return type of the function G must not be void.");
}
void operator()(Rng &&, Pred) const
{
CONCEPT_ASSERT_MSG(ForwardRange<Rng>(),
"Rng must model the ForwardRange concept");
CONCEPT_ASSERT_MSG(IndirectCallablePredicate<Pred, range_iterator_t<Rng>,
range_iterator_t<Rng>>(),
"Function Pred must be callable with two arguments of the range's common "
"reference type, and it must return something convertible to bool.");
}
void
operator()(Rng &&, Val) const
{
CONCEPT_ASSERT_MSG(Iterable<Rng>(),
"Rng must model the Iterable concept");
CONCEPT_ASSERT_MSG(EqualityComparable<Val, range_value_t<Rng>>(),
"The delimiting value type must be EqualityComparable to the "
"range's value type.");
}
void
operator()(Rng &&, Val) const
{
CONCEPT_ASSERT_MSG(Range<Rng>(),
"Rng must model the Range concept");
CONCEPT_ASSERT_MSG(EqualityComparable<Val, range_common_reference_t<Rng>>(),
"The delimiting value type must be EqualityComparable to the "
"range's common reference type.");
}
void operator()(Rng &&) const
{
CONCEPT_ASSERT_MSG(ForwardRange<Rng>(),
"The object on which view::unique operates must be a model the "
"ForwardRange concept.");
CONCEPT_ASSERT_MSG(EqualityComparable<range_value_t<Rng>>(),
"The value type of the range passed to view::unique must be "
"EqualityComparable.");
}
void operator()(Arg &&) const
{
CONCEPT_ASSERT_MSG(CopyConstructible<Val>(),
"The object passed to view::single must be a model of the CopyConstructible "
"concept; that is, it needs to be copy and move constructible, and destructible.");
CONCEPT_ASSERT_MSG(!CopyConstructible<Val>() || Constructible<Val, Arg>(),
"The object type passed to view::single must be initializable from the "
"actual argument expression.");
}
void operator()(Rng &&, Pred) const
{
CONCEPT_ASSERT_MSG(InputRange<Rng>(),
"The first argument to view::drop_while must be a model of the "
"InputRange concept");
CONCEPT_ASSERT_MSG(IndirectPredicate<Pred, iterator_t<Rng>>(),
"The second argument to view::drop_while must be callable with "
"an argument of the range's common reference type, and its return value "
"must be convertible to bool");
}
void operator()(Rng &&, T &&) const
{
CONCEPT_ASSERT_MSG(ForwardRange<Rng>(),
"The object on which action::drop operates must be a model of the "
"ForwardRange concept.");
using I = iterator_t<Rng>;
CONCEPT_ASSERT_MSG(ErasableRange<Rng, I, I>(),
"The object on which action::drop operates must allow element removal.");
CONCEPT_ASSERT_MSG(ConvertibleTo<T, range_difference_type_t<Rng>>(),
"The count passed to action::drop must be an integral type.");
}
void operator()(Rng &&, F) const
{
CONCEPT_ASSERT_MSG(Range<Rng>(),
"Rng is not a model of the Range concept.");
CONCEPT_ASSERT_MSG(IndirectCallable<F, range_iterator_t<Rng>>(),
"The function F is not callable with arguments of the type of the range's "
"common reference type.");
CONCEPT_ASSERT_MSG(Range<concepts::Callable::result_t<F,
range_common_reference_t<Rng>>>(),
"To use view::for_each, the function F must return a model of the Range "
"concept.");
}
void operator()(Rng &&, T &&) const
{
CONCEPT_ASSERT_MSG(ForwardRange<Rng>(),
"The object on which action::take operates must be a model of the "
"ForwardRange concept.");
using I = range_iterator_t<Rng>;
using S = range_sentinel_t<Rng>;
CONCEPT_ASSERT_MSG(EraseableRange<Rng, I, S>(),
"The object on which action::take operates must allow element removal.");
CONCEPT_ASSERT_MSG(Convertible<T, range_difference_t<Rng>>(),
"The stride argument to action::take must be convertible to the range's "
"difference type.");
}
void operator()(Rng &&, Pred, Proj) const
{
CONCEPT_ASSERT_MSG(InputRange<Rng>(),
"The first argument to view::drop_while must be a model of the "
"InputRange concept");
using Itr = iterator_t<Rng>;
CONCEPT_ASSERT_MSG(IndirectInvocable<Proj, Itr>(),
"The projection function must accept arguments of the iterator's "
"value type, reference type, and common reference type.");
CONCEPT_ASSERT_MSG(IndirectPredicate<Pred, projected<Itr, Proj>>(),
"The second argument to view::drop_while must accept "
"values returned by the projection function.");
}
void operator()(Rng &&, Fun &&) const
{
CONCEPT_ASSERT_MSG(ForwardRange<Rng>(),
"The object on which action::drop_while operates must be a model of the "
"ForwardRange concept.");
CONCEPT_ASSERT_MSG(IndirectPredicate<Fun, iterator_t<Rng>>(),
"The function passed to action::drop_while must be callable with objects "
"of the range's common reference type, and it must return something convertible to "
"bool.");
using I = iterator_t<Rng>;
CONCEPT_ASSERT_MSG(ErasableRange<Rng, I, I>(),
"The object on which action::drop_while operates must allow element "
"removal.");
}
void operator()(Rng &&, T &&, U &&) const
{
CONCEPT_ASSERT_MSG(ForwardIterable<Rng>(),
"The object on which action::slice operates must be a model of the "
"ForwardIterable concept.");
using I = range_iterator_t<Rng>;
CONCEPT_ASSERT_MSG(EraseableIterable<Rng, I, I>(),
"The object on which action::slice operates must allow element "
"removal.");
CONCEPT_ASSERT_MSG(meta::and_<Convertible<T, range_difference_t<Rng>>,
Convertible<U, range_difference_t<Rng>>>(),
"The bounds passed to action::slice must be convertible to the range's "
"difference type. TODO slicing from the end with 'end-2' syntax is not "
"supported yet, sorry!");
}
void operator()(Val &&) const
{
CONCEPT_ASSERT_MSG(SemiRegular<Val>(),
"The object passed to view::single must be a model of the SemiRegular "
"concept; that is, it needs to be default constructible, copy and move "
" constructible, and destructible.");
}
void operator()(Rng &&, C && = C{}, P && = P{}) const
{
CONCEPT_ASSERT_MSG(ForwardRange<Rng>(),
"The object on which action::stable_sort operates must be a model of the "
"ForwardRange concept.");
using I = range_iterator_t<Rng>;
CONCEPT_ASSERT_MSG(IndirectCallable<P, I>(),
"The projection function must accept objects of the iterator's value type, "
"reference type, and common reference type.");
CONCEPT_ASSERT_MSG(IndirectCallableRelation<C, Projected<I, P>>(),
"The comparator passed to action::stable_sort must accept objects returned "
"by the projection function, or of the range's value type if no projection "
"is specified.");
CONCEPT_ASSERT_MSG(Permutable<I>(),
"The iterator type of the range passed to action::stable_sort must allow its "
"elements to be permuted; that is, the values must be movable and the "
"iterator must be mutable.");
}
void operator()(Rng &&, F &&, P && = P{}) const
{
CONCEPT_ASSERT_MSG(InputIterable<Rng>(),
"The object on which action::transform operates must be a model of the "
"InputIterable concept.");
CONCEPT_ASSERT_MSG(Invokable<P, range_value_t<Rng>>(),
"The projection argument to action::transform must be callable with "
"objects of the range's value type.");
CONCEPT_ASSERT_MSG(Invokable<F,
concepts::Invokable::result_t<P, range_value_t<Rng>>>(),
"The function argument to action::transform must be callable with "
"the result of the projection argument, or with objects of the range's "
"value type is no projection is specified.");
CONCEPT_ASSERT_MSG(Writable<range_iterator_t<Rng>,
concepts::Invokable::result_t<F,
concepts::Invokable::result_t<P, range_value_t<Rng>>>>(),
"The result type of the function passed to action::transform must "
"be writable back into the source range.");
}
void operator()(Rng &&, F &&, P && = P{}) const
{
CONCEPT_ASSERT_MSG(InputRange<Rng>(),
"The object on which action::transform operates must be a model of the "
"InputRange concept.");
using I = iterator_t<Rng>;
CONCEPT_ASSERT_MSG(IndirectInvocable<P, I>(),
"The projection function must accept objects of the iterator's value type, "
"reference type, and common reference type.");
CONCEPT_ASSERT_MSG(IndirectInvocable<F, projected<I, P>>(),
"The function argument to action::transform must be callable with "
"the result of the projection argument, or with objects of the range's "
"common reference type if no projection is specified.");
CONCEPT_ASSERT_MSG(Writable<iterator_t<Rng>,
concepts::Invocable::result_t<F&,
concepts::Invocable::result_t<P&, range_common_reference_t<Rng>>>>(),
"The result type of the function passed to action::transform must "
"be writable back into the source range.");
}
void operator()(Rng &&, C &&, P && = P{}) const
{
CONCEPT_ASSERT_MSG(ForwardRange<Rng>(),
"The object on which action::remove_if operates must be a model of the "
"ForwardRange concept.");
using I = range_iterator_t<Rng>;
CONCEPT_ASSERT_MSG(EraseableRange<Rng, I, I>(),
"The object on which action::remove_if operates must allow element "
"removal.");
CONCEPT_ASSERT_MSG(Projectable<I, P>(),
"The projection function must accept objects of the iterator's value type, "
"reference type, and rvalue reference type.");
CONCEPT_ASSERT_MSG(IndirectCallablePredicate<C, Project<I, P>>(),
"The predicate passed to action::remove_if must accept objects returned "
"by the projection function, or of the range's value type if no projection "
"is specified.");
CONCEPT_ASSERT_MSG(Permutable<I>(),
"The iterator type of the range passed to action::remove_if must allow its "
"elements to be permutaed; that is, the values must be movable and the "
"iterator must be mutable.");
}
void operator()(Rng &&, C && = C{}, P && = P{}) const
{
CONCEPT_ASSERT_MSG(ForwardIterable<Rng>(),
"The object on which action::unique operates must be a model of the "
"ForwardIterable concept.");
using I = range_iterator_t<Rng>;
using S = range_sentinel_t<Rng>;
CONCEPT_ASSERT_MSG(EraseableIterable<Rng, I, S>(),
"The object on which action::unique operates must allow element "
"removal.");
using V = iterator_value_t<I>;
CONCEPT_ASSERT_MSG(Invokable<P, V>(),
"The projection argument passed to action::unique must accept objects "
"of the range's value type.");
using X = concepts::Invokable::result_t<P, V>;
CONCEPT_ASSERT_MSG(InvokableRelation<C, X, X>(),
"The comparator passed to action::unique must accept objects returned "
"by the projection function, or of the range's value type if no projection "
"is specified.");
CONCEPT_ASSERT_MSG(Permutable<I>(),
"The iterator type of the range passed to action::unique must allow its "
"elements to be permuted; that is, the values must be movable and the "
"iterator must be mutable.");
}
void operator()(Val) const
{
CONCEPT_ASSERT_MSG(SemiRegular<Val>(),
"The value passed to view::repeat must be SemiRegular; that is, it needs "
"to be default constructable, copy and move constructable, and destructable.");
}
void operator()(Val, Val) const
{
CONCEPT_ASSERT_MSG(Integral<Val>(),
"The object passed to view::indices must be Integral");
}
