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"); }