core::v2 Namespace Reference

Namespaces

 impl
 
 meta
 

Classes

struct  aligned_union
 
struct  any
 
struct  apply_functor
 
class  bad_any_cast
 
struct  basic_string_view
 
struct  bit_and
 
struct  bit_and< void >
 
struct  bit_not
 
struct  bit_not< void >
 
struct  bit_or
 
struct  bit_or< void >
 
struct  bit_xor
 
struct  bit_xor< void >
 
struct  capture
 
struct  common_type
 
struct  common_type< T >
 
struct  common_type< T, U >
 
struct  common_type< T, U, Ts... >
 
struct  conjunction
 
struct  conjunction< T, Ts... >
 
struct  conjunction<>
 
struct  converter
 
struct  disjunction
 
struct  disjunction< T, Ts... >
 
struct  disjunction<>
 
struct  divides
 
struct  divides< void >
 
struct  equal_to
 
struct  equal_to< void >
 
struct  erased_type
 
struct  function_traits
 
struct  function_traits< R(*)(Args...)>
 
struct  function_traits< R(Args...)>
 
struct  function_traits< R(C::*)(Args...) const >
 
struct  function_traits< R(C::*)(Args...) const volatile >
 
struct  function_traits< R(C::*)(Args...) volatile >
 
struct  function_traits< R(C::*)(Args...)>
 
struct  function_traits< R(C::*)>
 
struct  greater
 
struct  greater< void >
 
struct  greater_equal
 
struct  greater_equal< void >
 
struct  invokable
 
struct  invoke_of
 
struct  is_null_pointer
 
struct  is_null_pointer< add_cv_t<::std::nullptr_t > >
 
struct  is_null_pointer<::std::nullptr_t >
 
struct  is_null_pointer<::std::nullptr_t const >
 
struct  is_null_pointer<::std::nullptr_t volatile >
 
struct  is_range
 
struct  less
 
struct  less< void >
 
struct  less_equal
 
struct  less_equal< void >
 
struct  logical_and
 
struct  logical_and< void >
 
struct  logical_not
 
struct  logical_not< void >
 
struct  logical_or
 
struct  logical_or< void >
 
struct  minus
 
struct  minus< void >
 
struct  modulus
 
struct  modulus< void >
 
struct  multiplies
 
struct  multiplies< void >
 
struct  negate
 
struct  negate< void >
 
struct  negation
 
struct  negation< T, Ts... >
 
struct  negation<>
 
struct  nonesuch
 
struct  not_equal_to
 
struct  not_equal_to< void >
 
struct  not_fn_functor
 
struct  number_iterator
 
struct  ostream_joiner
 
struct  plus
 
struct  plus< void >
 
struct  range
 
struct  result_of
 
struct  result_of< F(Args...)>
 
struct  scope_guard
 
struct  transmit_const
 
struct  transmit_cv
 
struct  transmit_volatile
 

Typedefs

template
<
class
T
>
using add_const_t = typename ::std::add_const< T >::type
 
template
<
class
T
>
using add_cv_t = typename ::std::add_cv< T >::type
 
template
<
class
T
>
using add_lvalue_reference_t = typename ::std::add_lvalue_reference< T >::type
 
template
<
class
T
>
using add_pointer_t = typename ::std::add_pointer< T >::type
 
template
<
class
T
>
using add_rvalue_reference_t = typename ::std::add_rvalue_reference< T >::type
 
template
<
class
T
>
using add_volatile_t = typename ::std::add_volatile< T >::type
 
template<::std::size_t Len, ::std::size_t Align = alignof(typename ::std::aligned_storage<Len>::type)>
using aligned_storage_t = typename ::std::aligned_storage< Len, Align >::type
 
template<::std::size_t Len, class... Types>
using aligned_union_t = typename aligned_union< Len, Types... >::type
 
template<bool B>
using bool_constant = ::std::integral_constant< bool, B >
 
template
<
class
T
>
using class_of = impl::class_of< T >
 
template
<
class
T
>
using class_of_t = impl::class_of_t< T >
 
template<class... T>
using common_type_t = typename common_type< T... >::type
 
template<bool B, class T , class F >
using conditional_t = typename ::std::conditional< B, T, F >::type
 
template
<
class
T
>
using decay_t = impl::decay_t< T >
 
template<class T , template< class... > class U, class... Args>
using detected_or = impl::make_detect< T, void, U, Args... >
 
template<class T , template< class... > class U, class... Args>
using detected_or_t = typename detected_or< T, U, Args... >::type
 
template<template< class... > class T, class... Args>
using detected_t = typename detected_or< nonesuch, T, Args... >::type
 
template<bool B, class T = void>
using enable_if_t = typename ::std::enable_if< B, T >::type
 
template
<
class
T
>
using identity = meta::identity< T >
 
template
<
class
T
>
using identity_t = typename meta::identity< T >::type
 
template<::std::size_t... I>
using index_sequence = integer_sequence<::std::size_t, I... >
 
template<class... Ts>
using index_sequence_for = make_index_sequence< sizeof...(Ts)>
 
template<class T , T... I>
using integer_sequence = meta::integer_sequence< T, I... >
 
template<class... Args>
using invoke_of_t = typename invoke_of< Args... >::type
 
template<template< class... > class T, class... Args>
using is_detected = typename detected_or< nonesuch, T, Args... >::value_t
 
template<class To , template< class... > class T, class... Args>
using is_detected_convertible = ::std::is_convertible< detected_t< T, Args... >, To >
 
template<class T , template< class... > class U, class... Args>
using is_detected_same = ::std::is_same< T, detected_t< U, Args... > >
 
template
<
class
T
,
class
U
=
T
>
using is_nothrow_swappable = impl::is_nothrow_swappable< T, U >
 
template
<
class
T
>
using is_reference_wrapper = meta::is_specialization_of< remove_cv_t< T >, ::std::reference_wrapper >
 
template<::std::size_t N>
using make_index_sequence = make_integer_sequence<::std::size_t, N >
 
template<class T , T N>
using make_integer_sequence = typename meta::iota< T, N, N >::type
 
template
<
class
T
>
using make_signed_t = typename ::std::make_signed< T >::type
 
template
<
class
T
>
using make_unsigned_t = typename ::std::make_unsigned< T >::type
 
template
<
class
T
>
using remove_all_extents_t = typename ::std::remove_all_extents< T >::type
 
template
<
class
T
>
using remove_const_t = typename ::std::remove_const< T >::type
 
template
<
class
T
>
using remove_cv_t = typename ::std::remove_cv< T >::type
 
template
<
class
T
>
using remove_extent_t = typename ::std::remove_extent< T >::type
 
template
<
class
T
>
using remove_pointer_t = typename ::std::remove_pointer< T >::type
 
template
<
class
T
>
using remove_reference_t = typename ::std::remove_reference< T >::type
 
template
<
class
T
>
using remove_volatile_t = typename ::std::remove_volatile< T >::type
 
template
<
class
T
>
using result_of_t = typename result_of< T >::type
 
using string_view = basic_string_view< char >
 
template
<
class
T
,
class
U
>
using transmit_const_t = typename transmit_const< T, U >::type
 
template
<
class
T
,
class
U
>
using transmit_cv_t = typename transmit_cv< T, U >::type
 
template
<
class
T
,
class
U
>
using transmit_volatile_t = typename transmit_volatile< T, U >::type
 
template<::std::size_t I, class T >
using tuple_element_t = typename ::std::tuple_element< I, T >::type
 
template
<
class
T
>
using tuple_size_t = typename ::std::tuple_size< T >::type
 
using type_info = ::std::type_info
 
using u16string_view = basic_string_view< char16_t >
 
using u32string_view = basic_string_view< char32_t >
 
template
<
class
T
>
using underlying_type_t = typename ::std::underlying_type< T >::type
 
template<class... Ts>
using void_t = meta::deduce< Ts... >
 
using wstring_view = basic_string_view< wchar_t >
 

Functions

template<class T , class Compare = ::core::less<>, class Difference = ::core::minus<>>
constexpr auto abs_diff (T const &a, T const &b, Compare compare=Compare { }, Difference diff=Difference { }) -> decltype(compare(a, b) ? diff(b, a) :diff(a, b))
 
template
<
class
Range
>
auto adjacent_find (Range &&rng) -> meta::when< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
BinaryPredicate
>
auto adjacent_find (Range &&rng, BinaryPredicate &&bp) -> meta::when< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto all_of (Range &&rng, UnaryPredicate &&p) -> meta::when< is_range< Range >::value, bool >
 
template
<
class
T
>
T const * any_cast (any const *operand) noexcept
 
template
<
class
T
>
T * any_cast (any *operand) noexcept
 
template<class T , class = meta::when< meta::any< ::std::is_reference<T>::value, ::std::is_copy_constructible<T>::value >() >>
any_cast (any const &operand)
 
template<class T , class = meta::when< meta::any< ::std::is_reference<T>::value, ::std::is_copy_constructible<T>::value >() >>
any_cast (any &&operand)
 
template<class T , class = meta::when< meta::any< ::std::is_reference<T>::value, ::std::is_copy_constructible<T>::value >() >>
any_cast (any &operand)
 
template
<
class
Range
,
class
UnaryPredicate
>
auto any_of (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, bool >
 
template<class F , class T , ::std::size_t... I>
auto apply (F &&f, T &&t, index_sequence< I... >) -> decltype(invoke(core::forward< F >(f), ::std::get< I >(core::forward< T >(t))...))
 
template<class Functor , class T , class I = make_index_sequence<::std::tuple_size<decay_t<T>>::value>>
auto apply (Functor &&f, T &&t) -> decltype(apply(core::forward< Functor >(f), core::forward< T >(t), I
 
inline ::std::uintptr_t as_int (void const *ptr) noexcept
 
template
<
class
E
>
constexpr auto as_under (E e) noexcept -> meta::when< std::is_enum< E >::value, underlying_type_t< E > >
 
template
<
class
T
>
void const * as_void (T const *ptr)
 
template
<
class
T
>
void * as_void (T *ptr)
 
template
<
class
T
>
void const * as_void (T const &ref)
 
template
<
class
T
>
void * as_void (T &ref)
 
template
<
class
Container
>
constexpr auto back (Container const &container) -> decltype(container.back())
 
template
<
class
Container
>
constexpr auto back (Container &container) -> decltype(container.back())
 
template<class T , ::std::size_t N>
constexpr T const & back (T const (&array)[N]) noexcept
 
template<class T , ::std::size_t N>
constexpr T & back (T(&array)[N]) noexcept
 
template
<
class
Range
,
class
T
>
auto binary_search (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
,
class
T
,
class
Compare
>
auto binary_search (Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Container
>
auto cbegin (Container const &container) -> decltype(::std::begin(container))
 
template
<
class
Container
>
auto cend (Container const &container) -> decltype(::std::end(container))
 
template<class T , class Compare = less<>>
constexpr T const & clamp (T const &value, T const &low, T const &high, Compare compare=Compare { })
 
template
<
class
Range
,
class
OutputIt
>
auto copy (Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
BidirIt
>
auto copy_backward (Range &&rng, BidirIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< BidirIt > >
 
template
<
class
Range
,
class
OutputIt
,
class
UnaryPredicate
>
auto copy_if (Range &&rng, OutputIt &&it, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
OutputIt
,
class
T
>
OutputIt copy_until (Range &&r, OutputIt it, T const &value)
 
template
<
class
Range
,
class
T
>
auto count (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::count(::std::begin(::core::forward< Range >(rng)), ::std::end(::core::forward< Range >(rng)), value)) >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto count_if (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, decltype(::std::count_if(::std::begin(::core::forward< Range >(rng)), ::std::end(::core::forward< Range >(rng)), ::core::forward< UnaryPredicate >(p))) >
 
template
<
class
Container
>
auto crbegin (Container const &container) -> decltype(rbegin(container))
 
template
<
class
Container
>
auto crend (Container const &container) -> decltype(rend(container))
 
template
<
class
Container
>
constexpr auto data (Container const &container) noexcept -> decltype(container.data())
 
template
<
class
Container
>
constexpr auto data (Container &container) noexcept -> decltype(container.data())
 
template<class T , ::std::size_t N>
constexpr T const * data (T const (&array)[N]) noexcept
 
template<class T , ::std::size_t N>
constexpr T * data (T(&array)[N]) noexcept
 
template
<
class
Container
>
constexpr bool empty (Container const &container) noexcept
 
template<class T , std::size_t N>
constexpr bool empty (T const (&)[N]) noexcept
 
template
<
class
InputIt
1
,
class
InputIt
2
,
class
BinaryPredicate
>
bool equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate bp)
 
template
<
class
InputIt
1
,
class
InputIt
2
>
bool equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
 
template<class Range1 , class Range2 , meta::require< meta::all_of< meta::list< Range1, Range2 >, is_range >() > = __LINE__>
bool equal (Range1 &&range1, Range2 &&range2)
 
template<class Range1 , class Range2 , class BinaryPredicate , meta::require< meta::all_of< meta::list< Range1, Range2 >, is_range >() > = __LINE__>
bool equal (Range1 &&range1, Range2 &&range2, BinaryPredicate &&bp)
 
template<class Range , class InputIt , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >::value >()>() > = __LINE__>
bool equal (Range &&rng, InputIt &&it)
 
template<class Range , class InputIt , class BinaryPredicate , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >>()>() > = __LINE__>
bool equal (Range &&rng, InputIt &&it, BinaryPredicate &&bp)
 
template
<
class
Range
,
class
T
>
auto equal_range (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, range< decltype(::std::begin(::core::forward< Range >(rng)))> >
 
template
<
class
Range
,
class
T
,
class
Compare
>
auto equal_range (Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, range< decltype(::std::begin(::core::forward< Range >(rng)))> >
 
template
<
class
T
,
class
U
=
T
>
exchange (T &obj, U &&value) noexcept(meta::all< ::std::is_nothrow_move_constructible< T >, ::std::is_nothrow_assignable< add_lvalue_reference_t< T >, U > >())
 
template
<
class
Range
,
class
T
>
auto fill (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
T
>
auto find (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
1
,
class
Range
2
>
auto find_end (Range1 &&rng1, Range2 &&rng2) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decltype(::std::begin(::core::forward< Range1 >(rng1))) >
 
template
<
class
Range
1
,
class
Range
2
,
class
BinaryPred
>
auto find_end (Range1 &&rng1, Range2 &&rng2, BinaryPred &bp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decltype(::std::begin(::core::forward< Range1 >(rng1))) >
 
template
<
class
IRange
,
class
FRange
>
auto find_first_of (IRange &&irng, FRange &&frng) -> meta::when< meta::all_of< meta::list< IRange, FRange >, is_range >(), decltype(::std::begin(::core::forward< IRange >(irng))) >
 
template
<
class
IRange
,
class
FRange
,
class
BinaryPred
>
auto find_first_of (IRange &&irng, FRange &&frng, BinaryPred &&bp) -> meta::when< meta::all_of< meta::list< IRange, FRange >, is_range >(), decltype(::std::begin(::core::forward< IRange >(irng))) >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto find_if (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto find_if_not (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
UnaryFunction
>
auto for_each (Range &&rng, UnaryFunction &&f) -> enable_if_t< is_range< Range >::value, decay_t< UnaryFunction > >
 
template
<
class
Range
,
class
UnaryFunction
,
class
UnaryPredicate
>
UnaryFunction for_each_if (Range &&r, UnaryFunction uf, UnaryPredicate up)
 
template
<
class
Range
,
class
UnaryFunction
,
class
T
>
auto for_each_until (Range &&r, UnaryFunction f, T const &value) -> decltype(begin(make_range(::core::forward< Range >(r))))
 
template
<
class
Range
,
class
UnaryFunction
,
class
UnaryPredicate
>
auto for_each_while (Range &&r, UnaryFunction f, UnaryPredicate p) -> decltype(begin(make_range(::core::forward< Range >(r))))
 
template
<
class
T
>
constexpr T && forward (remove_reference_t< T > &t) noexcept
 
template
<
class
T
>
constexpr T && forward (remove_reference_t< T > &&t) noexcept
 
template
<
class
Container
>
constexpr auto front (Container const &container) -> decltype(container.front())
 
template
<
class
Container
>
constexpr auto front (Container &container) -> decltype(container.front())
 
template<class T , ::std::size_t N>
constexpr T const & front (T const (&array)[N]) noexcept
 
template<class T , ::std::size_t N>
constexpr T & front (T(&array)[N]) noexcept
 
template
<
class
Range
1
,
class
Range
2
>
auto includes (Range1 &&rng1, Range2 &&rng2) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
 
template
<
class
Range
1
,
class
Range
2
,
class
Compare
>
auto includes (Range1 &&rng1, Range2 &&rng2, Compare &&cmp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
 
template
<
class
Range
,
class
BidirIt
>
auto inplace_merge (Range &&rng, BidirIt &&it) -> meta::when< is_range< Range >::value >
 
template
<
class
Range
,
class
BidirIt
,
class
Compare
>
auto inplace_merge (Range &&rng, BidirIt &&it, Compare &&cmp) -> meta::when< is_range< Range >::value >
 
template<class Functor , class... Args>
auto invoke (Functor &&f, Args &&... args) -> enable_if_t< ::std::is_member_pointer< decay_t< Functor >>::value, result_of_t< Functor &&(Args &&...)> >
 
template
<
class
Range
>
auto is_heap (Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
,
class
Compare
>
auto is_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
>
auto is_heap_until (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
Compare
>
auto is_heap_until (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto is_partitioned (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
1
,
class
Range
2
>
auto is_permutation (Range1 &&rng1, Range2 &&rng2) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
 
template
<
class
Range
1
,
class
Range
2
,
class
BinaryPredicate
>
auto is_permutation (Range1 &&rng1, Range2 &&rng2, BinaryPredicate &&bp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
 
template
<
class
Range
>
auto is_sorted (Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
,
class
Compare
>
auto is_sorted (Range &&rng, Compare &&compare) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
>
auto is_sorted_until (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
Compare
>
auto is_sorted_until (Range &&rng, Compare &&compare) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
1
,
class
Range
2
>
auto lexicographical_compare (Range1 &&rng1, Range2 &&rng2) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
 
template
<
class
Range
1
,
class
Range
2
,
class
Compare
>
auto lexicographical_compare (Range1 &&rng1, Range2 &&rng2, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
 
template
<
class
Range
,
class
T
>
auto lower_bound (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
T
,
class
Compare
>
auto lower_bound (Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
F
>
auto make_apply (F &&f) -> apply_functor< F >
 
template
<
class
T
>
auto make_capture (remove_reference_t< T > &ref) -> capture< T >
 
template
<
class
T
>
auto make_capture (remove_reference_t< T > &&ref) -> capture< T >
 
template
<
class
Range
>
auto make_heap (Range &&rng) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
Compare
>
auto make_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Iter
>
range<::std::move_iterator< Iter > > make_move_range (Iter start, Iter stop)
 
template
<
class
T
>
range<::std::move_iterator< T * > > make_move_range (T *ptr, ::std::size_t n)
 
template
<
class
T
>
number_iterator< T > make_number_iterator (T value, T step) noexcept
 
template
<
class
T
>
number_iterator< T > make_number_iterator (T value) noexcept
 
template
<
class
T
>
range< number_iterator< T > > make_number_range (T start, T stop, T step) noexcept
 
template
<
class
T
>
range< number_iterator< T > > make_number_range (T start, T stop) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
DelimT
>
ostream_joiner< decay_t< DelimT >, CharT, Traits > make_ostream_joiner (::std::basic_ostream< CharT, Traits > &stream, DelimT &&delimiter)
 
template
<
class
T
>
auto make_range (T *ptr, ::std::size_t n) -> range< T *>
 
template
<
class
Iterator
>
auto make_range (Iterator begin, Iterator end) -> range< Iterator >
 
template
<
class
Range
>
auto make_range (Range &&value) -> range< decltype(begin(value))>
 
template<class T , class CharT , class Traits = ::std::char_traits<CharT>>
auto make_range (::std::basic_istream< CharT, Traits > &stream) -> range< ::std::istream_iterator< T, CharT, Traits > >
 
template<class CharT , class Traits = ::std::char_traits<CharT>>
auto make_range (::std::basic_streambuf< CharT, Traits > *buffer) -> range< ::std::istreambuf_iterator< CharT, Traits > >
 
template
<
class
Iterator
>
::std::reverse_iterator< Iterator > make_reverse_iterator (Iterator iter)
 
template
<
class
Callable
>
auto make_scope_guard (Callable &&callable) -> scope_guard< decay_t< Callable >>
 
template
<
class
T
>
constexpr T const & max (T const &lhs, T const &rhs)
 
template
<
class
T
,
class
Compare
>
constexpr T const & max (T const &lhs, T const &rhs, Compare compare)
 
template
<
class
Range
>
auto max_element (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
Compare
>
auto max_element (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
>
auto merge (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
,
class
Compare
>
auto merge (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
T
>
constexpr T const & min (T const &lhs, T const &rhs)
 
template
<
class
T
,
class
Compare
>
constexpr T const & min (T const &lhs, T const &rhs, Compare compare)
 
template
<
class
Range
>
auto min_element (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
Compare
>
auto min_element (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
>
auto minmax_element (Range &&rng) -> enable_if_t< is_range< Range >::value, ::std::pair< decltype(::std::begin(::core::forward< Range >(rng))), decltype(::std::end(::core::forward< Range >(rng))) > >
 
template
<
class
Range
,
class
Compare
>
auto minmax_element (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, ::std::pair< range< decltype(::std::begin(::core::forward< Range >(rng)))>, range< decltype(::std::end(::core::forward< Range >(rng)))> > >
 
template
<
class
InputIt
1
,
class
InputIt
2
,
class
BinaryPredicate
>
::std::pair< InputIt1, InputIt2 > mismatch (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate predicate)
 
template
<
class
InputIt
1
,
class
InputIt
2
>
::std::pair< InputIt1, InputIt2 > mismatch (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
 
template<class Range1 , class Range2 , class BinaryPred , meta::require< meta::all_of< meta::list< Range1, Range2 >, is_range >() > = __LINE__>
auto mismatch (Range1 &&r1, Range2 &&r2, BinaryPred &&bp) -> ::std::pair< decltype(::std::begin(::core::forward< Range1 >(r1))), decltype(::std::begin(::core::forward< Range2 >(r2))) >
 
template<class Range , class InputIt , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >::value >()>() > = __LINE__>
auto mismatch (Range &&rng, InputIt &&it) -> ::std::pair< decltype(make_range(::core::forward< Range >(rng)).begin()), decay_t< InputIt > >
 
template<class Range , class InputIt , class BinaryPredicate , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >>()>() > = __LINE__>
auto mismatch (Range &&r, InputIt &&it, BinaryPredicate &&bp) -> ::std::pair< decltype(core::make_range(::core::forward< Range >(r).begin())), decay_t< InputIt > >
 
template
<
class
T
>
constexpr auto move (T &&t) noexcept -> decltype(static_cast< remove_reference_t< T > &&>(t))
 
template
<
class
Range
,
class
OutputIt
>
auto move (Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
BidirIt
>
auto move_backward (Range &&rng, BidirIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< BidirIt > >
 
template
<
class
Range
>
auto next_permutation (Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
,
class
Compare
>
auto next_permutation (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto none_of (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
F
>
not_fn_functor< decay_t< F > > not_fn (F &&f)
 
template
<
class
Range
,
class
RandomIt
>
auto nth_element (Range &&rng, RandomIt &&it) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
RandomIt
,
class
Compare
>
auto nth_element (Range &&rng, RandomIt &&it, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
 
template
<
class
CharT
,
typename
Traits
>
bool operator!= (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator!= (basic_string_view< CharT, Traits > lhs, ::std::basic_string< CharT, Traits, Allocator > const &rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator!= (::std::basic_string< CharT, Traits, Allocator > const &lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator!= (basic_string_view< CharT, Traits > lhs, CharT const *rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator!= (CharT const *lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
typename
Traits
>
bool operator< (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator< (basic_string_view< CharT, Traits > lhs, ::std::basic_string< CharT, Traits, Allocator > const &rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator< (::std::basic_string< CharT, Traits, Allocator > const &lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator< (basic_string_view< CharT, Traits > lhs, CharT const *rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator< (CharT const *lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
::std::basic_ostream< CharT, Traits > & operator<< (::std::basic_ostream< CharT, Traits > &os, basic_string_view< CharT, Traits > const &str)
 
template
<
class
CharT
,
typename
Traits
>
bool operator<= (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator<= (basic_string_view< CharT, Traits > lhs, ::std::basic_string< CharT, Traits, Allocator > const &rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator<= (::std::basic_string< CharT, Traits, Allocator > const &lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator<= (basic_string_view< CharT, Traits > lhs, CharT const *rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator<= (CharT const *lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
typename
Traits
>
bool operator== (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator== (basic_string_view< CharT, Traits > lhs, ::std::basic_string< CharT, Traits, Allocator > const &rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator== (::std::basic_string< CharT, Traits, Allocator > const &lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator== (basic_string_view< CharT, Traits > lhs, CharT const *rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator== (CharT const *lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
typename
Traits
>
bool operator> (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator> (basic_string_view< CharT, Traits > lhs, ::std::basic_string< CharT, Traits, Allocator > const &rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator> (::std::basic_string< CharT, Traits, Allocator > const &lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator> (basic_string_view< CharT, Traits > lhs, CharT const *rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator> (CharT const *lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
typename
Traits
>
bool operator>= (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator>= (basic_string_view< CharT, Traits > lhs, ::std::basic_string< CharT, Traits, Allocator > const &rhs) noexcept
 
template
<
class
CharT
,
class
Traits
,
class
Allocator
>
bool operator>= (::std::basic_string< CharT, Traits, Allocator > const &lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator>= (basic_string_view< CharT, Traits > lhs, CharT const *rhs) noexcept
 
template
<
class
CharT
,
class
Traits
>
bool operator>= (CharT const *lhs, basic_string_view< CharT, Traits > rhs) noexcept
 
template
<
class
Range
,
class
RandomIt
>
auto partial_sort (Range &&rng, RandomIt &&it) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
RandomIt
,
class
Compare
>
auto partial_sort (Range &&rng, RandomIt &&it, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
 
template
<
class
IRange
,
class
RRange
>
auto partial_sort_copy (IRange &&irng, RRange &&rrng) -> meta::when< meta::all_of< meta::list< IRange, RRange >, is_range >(), decltype(::std::begin(::core::forward< RRange >(rrng))) >
 
template
<
class
IRange
,
class
RRange
,
class
Compare
>
auto partial_sort_copy (IRange &&irng, RRange &&rrng, Compare &&cmp) -> meta::when< meta::all_of< meta::list< IRange, RRange >, is_range >(), decltype(::std::begin(::core::forward< RRange >(rrng))) >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto partition (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
OutputTrue
,
class
OutputFalse
,
class
UnaryPred
>
auto partition_copy (Range &&rng, OutputTrue &&ot, OutputFalse &&of, UnaryPred &&up) -> enable_if_t< is_range< Range >::value, ::std::pair< decay_t< OutputTrue >, decay_t< OutputFalse >> >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto partition_point (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
>
auto pop_heap (Range &&rng) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
Compare
>
auto pop_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
>
auto prev_permutation (Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
,
class
Compare
>
auto prev_permutation (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
 
template
<
class
Range
>
auto push_heap (Range &&rng) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
Compare
>
auto push_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Container
>
auto rbegin (Container const &container) -> decltype(container.rbegin())
 
template
<
class
Container
>
auto rbegin (Container &container) -> decltype(container.rbegin())
 
template
<
class
Range
,
class
T
>
auto remove (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
OutputIt
,
class
T
>
auto remove_copy (Range &&rng, OutputIt &&it, T const &value) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
OutputIt
,
class
UnaryPred
>
auto remove_copy_if (Range &&rng, OutputIt &&it, UnaryPred &&up) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
T
>
auto remove_erase (Range &&rng, T const &val) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
UnaryPred
>
auto remove_erase_if (Range &&rng, UnaryPred &&up) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto remove_if (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Container
>
auto rend (Container const &container) -> decltype(container.rend())
 
template
<
class
Container
>
auto rend (Container &container) -> decltype(container.rend())
 
template
<
class
Range
,
class
T
>
auto replace (Range &&rng, T const &old, T const &value) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
OutputIt
,
class
T
>
auto replace_copy (Range &&rng, OutputIt &&it, T const &old, T const &value) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
OutputIt
,
class
UnaryPred
,
class
T
>
auto replace_copy_if (Range &&rng, OutputIt &&it, UnaryPred &&up, T const &value) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
UnaryPred
,
class
T
>
auto replace_if (Range &&rng, UnaryPred &&up, T const &value) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
>
auto reverse (Range &&rng) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
OutputIt
>
auto reverse_copy (Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
ForwardIt
>
auto rotate (Range &&rng, ForwardIt &&it) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
ForwardIt
,
class
OutputIt
>
auto rotate_copy (Range &&rng, ForwardIt &&it, OutputIt &&ot) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
1
,
class
Range
2
>
auto search (Range1 &&rng1, Range2 &&rng2) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decltype(::std::begin(::core::forward< Range1 >(rng1))) >
 
template
<
class
Range
1
,
class
Range
2
,
class
BinaryPred
>
auto search (Range1 &&rng1, Range2 &&rng2, BinaryPred &&bp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decltype(::std::begin(::core::forward< Range1 >(rng1))) >
 
template
<
class
Range
,
class
Size
,
class
T
>
auto search_n (Range &&rng, Size &&count, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
Size
,
class
T
,
class
BinaryPred
>
auto search_n (Range &&rng, Size &&count, T const &value, BinaryPred &&bp) -> meta::when< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
>
auto set_difference (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
,
class
Compare
>
auto set_difference (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
>
auto set_intersection (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
,
class
Compare
>
auto set_intersection (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
>
auto set_symmetric_difference (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
,
class
Compare
>
auto set_symmetric_difference (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
>
auto set_union (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
,
class
Compare
>
auto set_union (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
 
template
<
class
Range
,
class
URNG
>
auto shuffle (Range &&rng, URNG &&g) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Container
>
constexpr auto size (Container const &container) noexcept -> decltype(container.size())
 
template<class T , ::std::size_t N>
constexpr ::std::size_t size (T const (&)[N]) noexcept
 
template
<
class
Range
>
auto sort (Range &&rng) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
Compare
>
auto sort (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
>
auto sort_heap (Range &&rng) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
Compare
>
auto sort_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
UnaryPredicate
>
auto stable_partition (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
>
auto stable_sort (Range &&rng) -> enable_if_t< is_range< Range >::value >
 
template
<
class
Range
,
class
Compare
>
auto stable_sort (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
 
template
<
class
T
>
void swap (number_iterator< T > &lhs, number_iterator< T > &rhs) noexcept
 
void swap (any &lhs, any &rhs) noexcept
 
template
<
class
Iterator
>
void swap (range< Iterator > &lhs, range< Iterator > &rhs) noexcept(noexcept(lhs.swap(rhs)))
 
template
<
class
CharT
,
class
Traits
>
void swap (basic_string_view< CharT, Traits > &lhs, basic_string_view< CharT, Traits > &rhs) noexcept
 
template
<
class
Range
,
class
ForwardIt
>
auto swap_ranges (Range &&rng, ForwardIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< ForwardIt > >
 
void throw_bad_any_cast ()
 
void throw_out_of_range (char const *msg)
 
template
<
class
Range
,
class
OutputIt
,
class
UnaryOperation
>
auto transform (Range &&rng, OutputIt &&it, UnaryOperation &&op) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template<class Range , class InputIt , class OutputIt , class BinaryOperation , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >::value >()>() > = __LINE__>
decay_t< OutputIt > transform (Range &&r, InputIt &&in, OutputIt &&out, BinaryOperation &&op)
 
template<class Range1 , class Range2 , class OutputIt , class BinaryOperation , meta::require< meta::all_of< meta::list< Range1, Range2 >, is_range >() > = __LINE__>
decay_t< OutputIt > transform (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, BinaryOperation &&op)
 
template
<
class
Range
,
class
OutputIt
,
class
UnaryOperation
,
class
UnaryPred
>
auto transform_if (Range &&rng, OutputIt it, UnaryOperation op, UnaryPred up) -> enable_if_t< is_range< Range >::value, OutputIt >
 
template
<
class
Range
1
,
class
Range
2
,
class
OutputIt
,
class
BinaryOperation
,
class
BinaryPredicate
>
auto transform_if (Range1 &&rng1, Range2 &&rng2, OutputIt it, BinaryOperation op, BinaryPredicate bp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), OutputIt >
 
template
<
class
InputIt
,
class
Size
,
class
OutputIt
,
class
UnaryOp
>
OutputIt transform_n (InputIt in, Size count, OutputIt out, UnaryOp op)
 
template
<
class
InputIt
1
,
class
InputIt
2
,
class
Size
,
class
OutputIt
,
class
UnaryOp
>
OutputIt transform_n (InputIt1 in1, InputIt2 in2, Size count, OutputIt out, UnaryOp op)
 
template
<
class
T
>
type_info const & type_of () noexcept
 
template
<
class
Range
>
auto unique (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
BinaryPredicate
>
auto unique (Range &&rng, BinaryPredicate &&bp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
OutputIt
>
auto unique_copy (Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
OutputIt
,
class
BinaryPred
>
auto unique_copy (Range &&rng, OutputIt &&it, BinaryPred &&bp) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
 
template
<
class
Range
,
class
T
>
auto upper_bound (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template
<
class
Range
,
class
T
,
class
Compare
>
auto upper_bound (Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
 
template<::std::size_t N, class T , class... Ts>
constexpr auto value_at (T &&value, Ts &&...) -> enable_if_t< N==0and N<(sizeof...(Ts)+1)
 
template<::std::size_t N, class T , class... Ts>
constexpr autodecltype(::core::forward< T >(value)) constexpr auto value_at (T &&, Ts &&... values) -> enable_if_t< N !=0and N<(sizeof...(Ts)+1)
 

Typedef Documentation

◆ add_const_t

using add_const_t = typename ::std::add_const<T>::type

Definition at line 118 of file type_traits.hpp.

◆ add_cv_t

using add_cv_t = typename ::std::add_cv<T>::type

Definition at line 119 of file type_traits.hpp.

◆ add_lvalue_reference_t

using add_lvalue_reference_t = typename ::std::add_lvalue_reference<T>::type

Definition at line 122 of file type_traits.hpp.

◆ add_pointer_t

using add_pointer_t = typename ::std::add_pointer<T>::type

Definition at line 133 of file type_traits.hpp.

◆ add_rvalue_reference_t

using add_rvalue_reference_t = typename ::std::add_rvalue_reference<T>::type

Definition at line 125 of file type_traits.hpp.

◆ add_volatile_t

using add_volatile_t = typename ::std::add_volatile<T>::type

Definition at line 117 of file type_traits.hpp.

◆ aligned_storage_t

using aligned_storage_t = typename ::std::aligned_storage<Len, Align>::type

Definition at line 148 of file type_traits.hpp.

◆ aligned_union_t

using aligned_union_t = typename aligned_union<Len, Types...>::type

Definition at line 151 of file type_traits.hpp.

◆ bool_constant

using bool_constant = ::std::integral_constant<bool, B>

Definition at line 41 of file type_traits.hpp.

◆ class_of

Definition at line 34 of file type_traits.hpp.

◆ class_of_t

Definition at line 33 of file type_traits.hpp.

◆ common_type_t

using common_type_t = typename common_type<T...>::type

Definition at line 217 of file type_traits.hpp.

◆ conditional_t

using conditional_t = typename ::std::conditional<B, T, F>::type

Definition at line 159 of file type_traits.hpp.

◆ decay_t

using decay_t = impl::decay_t<T>

Definition at line 153 of file type_traits.hpp.

◆ detected_or

using detected_or = impl::make_detect<T, void, U, Args...>

Definition at line 76 of file type_traits.hpp.

◆ detected_or_t

using detected_or_t = typename detected_or<T, U, Args...>::type

Definition at line 82 of file type_traits.hpp.

◆ detected_t

using detected_t = typename detected_or<nonesuch, T, Args...>::type

Definition at line 79 of file type_traits.hpp.

◆ enable_if_t

using enable_if_t = typename ::std::enable_if<B, T>::type

Definition at line 156 of file type_traits.hpp.

◆ identity

Definition at line 30 of file type_traits.hpp.

◆ identity_t

using identity_t = typename meta::identity<T>::type

Definition at line 29 of file type_traits.hpp.

◆ index_sequence

using index_sequence = integer_sequence<::std::size_t, I...>

Definition at line 46 of file utility.hpp.

◆ index_sequence_for

using index_sequence_for = make_index_sequence<sizeof...(Ts)>

Definition at line 55 of file utility.hpp.

◆ integer_sequence

Definition at line 43 of file utility.hpp.

◆ invoke_of_t

using invoke_of_t = typename invoke_of<Args...>::type

Definition at line 182 of file type_traits.hpp.

◆ is_detected

using is_detected = typename detected_or<nonesuch, T, Args...>::value_t

Definition at line 100 of file type_traits.hpp.

◆ is_detected_convertible

using is_detected_convertible = ::std::is_convertible< detected_t<U, Args...>, T >

Definition at line 88 of file type_traits.hpp.

◆ is_detected_same

using is_detected_same = ::std::is_same<T, detected_t<U, Args...> >

Definition at line 91 of file type_traits.hpp.

◆ is_nothrow_swappable

Definition at line 233 of file type_traits.hpp.

◆ is_reference_wrapper

using is_reference_wrapper = meta::is_specialization_of< remove_cv_t<T>, ::std::reference_wrapper >

Definition at line 30 of file functional.hpp.

◆ make_index_sequence

using make_index_sequence = make_integer_sequence<::std::size_t, N>

Definition at line 52 of file utility.hpp.

◆ make_integer_sequence

using make_integer_sequence = typename meta::iota<T, N, N>::type

Definition at line 49 of file utility.hpp.

◆ make_signed_t

using make_signed_t = typename ::std::make_signed<T>::type

Definition at line 137 of file type_traits.hpp.

◆ make_unsigned_t

using make_unsigned_t = typename ::std::make_unsigned<T>::type

Definition at line 136 of file type_traits.hpp.

◆ remove_all_extents_t

using remove_all_extents_t = typename ::std::remove_all_extents<T>::type

Definition at line 143 of file type_traits.hpp.

◆ remove_const_t

using remove_const_t = typename ::std::remove_const<T>::type

Definition at line 113 of file type_traits.hpp.

◆ remove_cv_t

using remove_cv_t = typename ::std::remove_cv<T>::type

Definition at line 114 of file type_traits.hpp.

◆ remove_extent_t

using remove_extent_t = typename ::std::remove_extent<T>::type

Definition at line 140 of file type_traits.hpp.

◆ remove_pointer_t

using remove_pointer_t = typename ::std::remove_pointer<T>::type

Definition at line 131 of file type_traits.hpp.

◆ remove_reference_t

using remove_reference_t = typename ::std::remove_reference<T>::type

Definition at line 128 of file type_traits.hpp.

◆ remove_volatile_t

using remove_volatile_t = typename ::std::remove_volatile<T>::type

Definition at line 110 of file type_traits.hpp.

◆ result_of_t

using result_of_t = typename result_of<T>::type

Definition at line 199 of file type_traits.hpp.

◆ string_view

Definition at line 540 of file string_view.hpp.

◆ transmit_const_t

using transmit_const_t = typename transmit_const<T, U>::type

Definition at line 259 of file type_traits.hpp.

◆ transmit_cv_t

using transmit_cv_t = typename transmit_cv<T, U>::type

Definition at line 262 of file type_traits.hpp.

◆ transmit_volatile_t

using transmit_volatile_t = typename transmit_volatile<T, U>::type

Definition at line 256 of file type_traits.hpp.

◆ tuple_element_t

using tuple_element_t = typename ::std::tuple_element<I, T>::type

Definition at line 37 of file type_traits.hpp.

◆ tuple_size_t

using tuple_size_t = typename ::std::tuple_size<T>::type

Definition at line 38 of file type_traits.hpp.

◆ type_info

using type_info = ::std::type_info

Definition at line 29 of file typeinfo.hpp.

◆ u16string_view

using u16string_view = basic_string_view<char16_t>

Definition at line 538 of file string_view.hpp.

◆ u32string_view

using u32string_view = basic_string_view<char32_t>

Definition at line 537 of file string_view.hpp.

◆ underlying_type_t

using underlying_type_t = typename ::std::underlying_type<T>::type

Definition at line 162 of file type_traits.hpp.

◆ void_t

using void_t = meta::deduce<Ts...>

Definition at line 66 of file type_traits.hpp.

◆ wstring_view

using wstring_view = basic_string_view<wchar_t>

Definition at line 539 of file string_view.hpp.

Function Documentation

◆ abs_diff()

constexpr auto core::v2::abs_diff ( T const &  a,
T const &  b,
Compare  compare = Compare { },
Difference  diff = Difference { } 
) -> decltype(compare(a, b) ? diff(b, a) : diff(a, b))

Definition at line 108 of file algorithm.hpp.

◆ adjacent_find() [1/2]

auto core::v2::adjacent_find ( Range &&  rng) -> meta::when< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 573 of file algorithm.hpp.

References adjacent_find(), and make_range().

◆ adjacent_find() [2/2]

auto core::v2::adjacent_find ( Range &&  rng,
BinaryPredicate &&  bp 
) -> meta::when< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 584 of file algorithm.hpp.

References make_range().

Referenced by adjacent_find().

◆ all_of()

auto core::v2::all_of ( Range &&  rng,
UnaryPredicate &&  p 
) -> meta::when< is_range<Range>::value, bool >

Definition at line 119 of file algorithm.hpp.

References make_range().

◆ any_cast() [1/5]

T const* core::v2::any_cast ( any const *  operand)
noexcept

Definition at line 275 of file any.hpp.

Referenced by any_cast().

◆ any_cast() [2/5]

T* core::v2::any_cast ( any operand)
noexcept

Definition at line 282 of file any.hpp.

◆ any_cast() [3/5]

T core::v2::any_cast ( any const &  operand)

Definition at line 296 of file any.hpp.

References core::v2::meta::any(), any_cast(), and throw_bad_any_cast().

◆ any_cast() [4/5]

T core::v2::any_cast ( any &&  operand)

Definition at line 311 of file any.hpp.

References core::v2::meta::any(), any_cast(), and throw_bad_any_cast().

◆ any_cast() [5/5]

T core::v2::any_cast ( any operand)

Definition at line 326 of file any.hpp.

References any_cast(), and throw_bad_any_cast().

◆ any_of()

auto core::v2::any_of ( Range &&  rng,
UnaryPredicate &&  p 
) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 134 of file algorithm.hpp.

References make_range().

◆ apply() [1/2]

auto core::v2::apply ( F &&  f,
T &&  t,
index_sequence< I... >   
) -> decltype( invoke(core::forward<F>(f), ::std::get<I>(core::forward<T>(t))...) )

Definition at line 92 of file functional.hpp.

References invoke().

Referenced by apply(), and apply_functor< F >::operator()().

◆ apply() [2/2]

auto core::v2::apply ( Functor &&  f,
T &&  t 
) -> decltype( apply(core::forward<Functor>(f), core::forward<T>(t), I

Definition at line 100 of file functional.hpp.

References apply().

◆ as_int()

inline ::std::uintptr_t core::v2::as_int ( void const *  ptr)
noexcept

Definition at line 116 of file utility.hpp.

Referenced by type_of().

◆ as_under()

constexpr auto core::v2::as_under ( e) -> meta::when< std::is_enum<E>::value, underlying_type_t<E> >
noexcept

Definition at line 133 of file utility.hpp.

◆ as_void() [1/4]

void const* core::v2::as_void ( T const *  ptr)

Definition at line 121 of file utility.hpp.

Referenced by as_void().

◆ as_void() [2/4]

void* core::v2::as_void ( T *  ptr)

Definition at line 124 of file utility.hpp.

◆ as_void() [3/4]

void const* core::v2::as_void ( T const &  ref)

Definition at line 127 of file utility.hpp.

References as_void().

◆ as_void() [4/4]

void* core::v2::as_void ( T &  ref)

Definition at line 130 of file utility.hpp.

References as_void().

◆ back() [1/4]

constexpr auto core::v2::back ( Container const &  container) -> decltype( container.back() )

Definition at line 62 of file iterator.hpp.

Referenced by basic_string_view< CharT, Traits >::ends_with().

◆ back() [2/4]

constexpr auto core::v2::back ( Container &  container) -> decltype(container.back())

Definition at line 67 of file iterator.hpp.

◆ back() [3/4]

constexpr T const& core::v2::back ( T const (&)  array[N])
noexcept

Definition at line 72 of file iterator.hpp.

◆ back() [4/4]

constexpr T& core::v2::back ( T(&)  array[N])
noexcept

Definition at line 75 of file iterator.hpp.

◆ binary_search() [1/2]

auto core::v2::binary_search ( Range &&  rng,
T const &  value 
) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 1567 of file algorithm.hpp.

References binary_search(), and make_range().

◆ binary_search() [2/2]

auto core::v2::binary_search ( Range &&  rng,
T const &  value,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 1578 of file algorithm.hpp.

References make_range().

Referenced by binary_search().

◆ cbegin()

auto core::v2::cbegin ( Container const &  container) -> decltype(::std::begin(container))

Definition at line 96 of file iterator.hpp.

◆ cend()

auto core::v2::cend ( Container const &  container) -> decltype(::std::end(container))

Definition at line 101 of file iterator.hpp.

◆ clamp()

constexpr T const& core::v2::clamp ( T const &  value,
T const &  low,
T const &  high,
Compare  compare = Compare { } 
)

Definition at line 90 of file algorithm.hpp.

Referenced by DiagonalConstraint::ApplyConstraint().

◆ copy()

auto core::v2::copy ( Range &&  rng,
OutputIt &&  it 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 677 of file algorithm.hpp.

References make_range().

Referenced by mlpack::GetMemory(), GetMemory(), include_directories(), and macro().

◆ copy_backward()

auto core::v2::copy_backward ( Range &&  rng,
BidirIt &&  it 
) -> enable_if_t< is_range<Range>::value, decay_t<BidirIt> >

Definition at line 721 of file algorithm.hpp.

References make_range().

◆ copy_if()

auto core::v2::copy_if ( Range &&  rng,
OutputIt &&  it,
UnaryPredicate &&  up 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 692 of file algorithm.hpp.

References make_range().

◆ copy_until()

OutputIt core::v2::copy_until ( Range &&  r,
OutputIt  it,
T const &  value 
)

◆ count()

◆ count_if()

auto core::v2::count_if ( Range &&  rng,
UnaryPredicate &&  p 
) -> enable_if_t< is_range<Range>::value, decltype( ::std::count_if( ::std::begin(::core::forward<Range>(rng)), ::std::end(::core::forward<Range>(rng)), ::core::forward<UnaryPredicate>(p) ) ) >

Definition at line 242 of file algorithm.hpp.

References make_range().

◆ crbegin()

auto core::v2::crbegin ( Container const &  container) -> decltype(rbegin(container))

Definition at line 116 of file iterator.hpp.

References rbegin().

◆ crend()

auto core::v2::crend ( Container const &  container) -> decltype(rend(container))

Definition at line 131 of file iterator.hpp.

References rend().

◆ data() [1/4]

constexpr auto core::v2::data ( Container const &  container) -> decltype( container.data() )
noexcept

Definition at line 79 of file iterator.hpp.

Referenced by alpha(), any::any(), RandomizedSVD::Apply(), RPTreeMaxSplit< BoundType, MatType >::AssignToLeftNode(), RPTreeMeanSplit< BoundType, MatType >::AssignToLeftNode(), basic_string_view< CharT, Traits >::begin(), capture< T >::capture(), BallBound< MetricType, VecType >::Center(), HollowBallBound< TMetricType, ElemType >::Center(), any::clear(), CLIOption< N >::CLIOption(), basic_string_view< CharT, Traits >::compare(), mlpack::bindings::markdown::DefaultParam(), mlpack::bindings::python::DefaultParam(), mlpack::bindings::r::DefaultParam(), mlpack::bindings::cli::DefaultParam(), mlpack::bindings::go::DefaultParam(), mlpack::bindings::julia::DefaultParam(), AdaBoostModel::Dimensionality(), any::empty(), basic_string_view< CharT, Traits >::end(), mlpack::bindings::cli::EndProgram(), basic_string_view< CharT, Traits >::ends_with(), capture< T >::get(), mlpack::bindings::cli::GetPrintableParam(), mlpack::bindings::tests::GetPrintableParam(), mlpack::bindings::r::GetPrintableParam(), mlpack::bindings::go::GetPrintableParam(), mlpack::bindings::julia::GetPrintableParam(), mlpack::bindings::markdown::GetPrintableParam(), mlpack::bindings::python::GetPrintableParam(), mlpack::bindings::markdown::GetPrintableType(), mlpack::bindings::cli::GetPrintableType(), mlpack::bindings::julia::GetPrintableType(), GoOption< T >::GoOption(), include(), mlpack::bindings::python::IsSerializable(), JuliaOption< T >::JuliaOption(), MaxVarianceNewCluster::MaxVarianceNewCluster(), MDOption< T >::MDOption(), HRectBound< MetricType >::Metric(), DTree< MatType, TagType >::MinVals(), CFModel::NormalizationType(), CombinedNormalization< NormalizationTypes >::Normalize(), murmur< 4 >::operator()(), murmur< 8 >::operator()(), basic_string_view< CharT, Traits >::operator::std::basic_string(), FastLSTMType< InputType, OutputType >::OutputDimensions(), mlpack::bindings::cli::OutputParam(), MeanSplit< BoundType, MatType >::PerformSplit(), MidpointSplit< BoundType, MatType >::PerformSplit(), RPTreeMaxSplit< BoundType, MatType >::PerformSplit(), RPTreeMeanSplit< BoundType, MatType >::PerformSplit(), VantagePointSplit< BoundType, MatType, MaxNumSamples >::PerformSplit(), mlpack::bindings::python::PrintOutputProcessing(), mlpack::bindings::markdown::PrintTypeDoc(), mlpack::bindings::go::PrintTypeDoc(), mlpack::bindings::r::PrintTypeDoc(), mlpack::bindings::cli::PrintTypeDoc(), mlpack::bindings::python::PrintTypeDoc(), mlpack::bindings::julia::PrintTypeDoc(), NaiveBayesClassifier< ModelMatType >::Probabilities(), PyOption< T >::PyOption(), RefinedStart::RefinedStart(), ROption< T >::ROption(), CombinedNormalization< NormalizationTypes >::serialize(), VantagePointSplit< BoundType, MatType, MaxNumSamples >::SplitInfo::SplitInfo(), basic_string_view< CharT, Traits >::starts_with(), basic_string_view< CharT, Traits >::substr(), any::swap(), TestOption< N >::TestOption(), basic_string_view< CharT, Traits >::to_string(), and EMFit< InitialClusteringType, CovarianceConstraintPolicy, Distribution >::Tolerance().

◆ data() [2/4]

constexpr auto core::v2::data ( Container &  container) -> decltype( container.data() )
noexcept

Definition at line 84 of file iterator.hpp.

◆ data() [3/4]

constexpr T const* core::v2::data ( T const (&)  array[N])
noexcept

Definition at line 89 of file iterator.hpp.

◆ data() [4/4]

constexpr T* core::v2::data ( T(&)  array[N])
noexcept

Definition at line 92 of file iterator.hpp.

◆ empty() [1/2]

constexpr bool core::v2::empty ( Container const &  container)
noexcept

◆ empty() [2/2]

constexpr bool core::v2::empty ( T   const(&)[N])
noexcept

Definition at line 42 of file iterator.hpp.

◆ equal() [1/6]

bool core::v2::equal ( InputIt1  first1,
InputIt1  last1,
InputIt2  first2,
InputIt2  last2,
BinaryPredicate  bp 
)

Definition at line 355 of file algorithm.hpp.

References core::v2::impl::equal(), and make_range().

◆ equal() [2/6]

bool core::v2::equal ( InputIt1  first1,
InputIt1  last1,
InputIt2  first2,
InputIt2  last2 
)

Definition at line 370 of file algorithm.hpp.

References core::v2::impl::equal().

◆ equal() [3/6]

bool core::v2::equal ( Range1 &&  range1,
Range2 &&  range2 
)

Definition at line 380 of file algorithm.hpp.

References core::v2::impl::equal(), and make_range().

◆ equal() [4/6]

bool core::v2::equal ( Range1 &&  range1,
Range2 &&  range2,
BinaryPredicate &&  bp 
)

Definition at line 397 of file algorithm.hpp.

References core::v2::impl::equal(), and make_range().

◆ equal() [5/6]

bool core::v2::equal ( Range &&  rng,
InputIt &&  it 
)

Definition at line 419 of file algorithm.hpp.

References equal(), and make_range().

◆ equal() [6/6]

bool core::v2::equal ( Range &&  rng,
InputIt &&  it,
BinaryPredicate &&  bp 
)

Definition at line 437 of file algorithm.hpp.

References make_range().

Referenced by core::v2::impl::equal(), and equal().

◆ equal_range() [1/2]

auto core::v2::equal_range ( Range &&  rng,
T const &  value 
) -> enable_if_t< is_range<Range>::value, range<decltype(::std::begin(::core::forward<Range>(rng)))> >

Definition at line 1594 of file algorithm.hpp.

References equal_range(), and make_range().

◆ equal_range() [2/2]

auto core::v2::equal_range ( Range &&  rng,
T const &  value,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, range<decltype(::std::begin(::core::forward<Range>(rng)))> >

Definition at line 1605 of file algorithm.hpp.

References make_range().

Referenced by equal_range().

◆ exchange()

T core::v2::exchange ( T &  obj,
U &&  value 
)
noexcept

Definition at line 105 of file utility.hpp.

References move().

◆ fill()

auto core::v2::fill ( Range &&  rng,
T const &  value 
) -> enable_if_t< is_range<Range>::value >

Definition at line 766 of file algorithm.hpp.

References make_range().

Referenced by endif().

◆ find()

auto core::v2::find ( Range &&  rng,
T const &  value 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 450 of file algorithm.hpp.

References make_range().

Referenced by basic_string_view< CharT, Traits >::find().

◆ find_end() [1/2]

auto core::v2::find_end ( Range1 &&  rng1,
Range2 &&  rng2 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), decltype(::std::begin(::core::forward<Range1>(rng1))) >

Definition at line 491 of file algorithm.hpp.

References find_end(), and make_range().

◆ find_end() [2/2]

auto core::v2::find_end ( Range1 &&  rng1,
Range2 &&  rng2,
BinaryPred &  bp 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), decltype(::std::begin(::core::forward<Range1>(rng1))) >

Definition at line 510 of file algorithm.hpp.

References make_range().

Referenced by find_end().

◆ find_first_of() [1/2]

auto core::v2::find_first_of ( IRange &&  irng,
FRange &&  frng 
) -> meta::when< meta::all_of<meta::list<IRange, FRange>, is_range>(), decltype(::std::begin(::core::forward<IRange>(irng))) >

◆ find_first_of() [2/2]

auto core::v2::find_first_of ( IRange &&  irng,
FRange &&  frng,
BinaryPred &&  bp 
) -> meta::when< meta::all_of<meta::list<IRange, FRange>, is_range>(), decltype(::std::begin(::core::forward<IRange>(irng))) >

Definition at line 549 of file algorithm.hpp.

References make_range().

Referenced by find_first_of().

◆ find_if()

auto core::v2::find_if ( Range &&  rng,
UnaryPredicate &&  p 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 461 of file algorithm.hpp.

References make_range().

◆ find_if_not()

auto core::v2::find_if_not ( Range &&  rng,
UnaryPredicate &&  p 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 476 of file algorithm.hpp.

References make_range().

◆ for_each()

auto core::v2::for_each ( Range &&  rng,
UnaryFunction &&  f 
) -> enable_if_t< is_range<Range>::value, decay_t<UnaryFunction> >

Definition at line 164 of file algorithm.hpp.

References make_range().

◆ for_each_if()

UnaryFunction core::v2::for_each_if ( Range &&  r,
UnaryFunction  uf,
UnaryPredicate  up 
)

◆ for_each_until()

auto core::v2::for_each_until ( Range &&  r,
UnaryFunction  f,
T const &  value 
) -> decltype(begin(make_range(::core::forward<Range>(r))))

◆ for_each_while()

auto core::v2::for_each_while ( Range &&  r,
UnaryFunction  f,
UnaryPredicate  p 
) -> decltype(begin(make_range(::core::forward<Range>(r))))

◆ forward() [1/2]

constexpr T&& core::v2::forward ( remove_reference_t< T > &  t)
noexcept

Definition at line 27 of file utility.hpp.

◆ forward() [2/2]

constexpr T&& core::v2::forward ( remove_reference_t< T > &&  t)
noexcept

Definition at line 32 of file utility.hpp.

◆ front() [1/4]

constexpr auto core::v2::front ( Container const &  container) -> decltype( container.front() )

Definition at line 46 of file iterator.hpp.

Referenced by basic_string_view< CharT, Traits >::starts_with().

◆ front() [2/4]

constexpr auto core::v2::front ( Container &  container) -> decltype(container.front())

Definition at line 51 of file iterator.hpp.

◆ front() [3/4]

constexpr T const& core::v2::front ( T const (&)  array[N])
noexcept

Definition at line 56 of file iterator.hpp.

◆ front() [4/4]

constexpr T& core::v2::front ( T(&)  array[N])
noexcept

Definition at line 59 of file iterator.hpp.

◆ includes() [1/2]

auto core::v2::includes ( Range1 &&  rng1,
Range2 &&  rng2 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), bool >

Definition at line 1697 of file algorithm.hpp.

References includes(), and make_range().

Referenced by endif().

◆ includes() [2/2]

auto core::v2::includes ( Range1 &&  rng1,
Range2 &&  rng2,
Compare &&  cmp 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), bool >

Definition at line 1716 of file algorithm.hpp.

References make_range().

Referenced by includes().

◆ inplace_merge() [1/2]

auto core::v2::inplace_merge ( Range &&  rng,
BidirIt &&  it 
) -> meta::when< is_range<Range>::value >

Definition at line 1668 of file algorithm.hpp.

References inplace_merge(), and make_range().

◆ inplace_merge() [2/2]

auto core::v2::inplace_merge ( Range &&  rng,
BidirIt &&  it,
Compare &&  cmp 
) -> meta::when< is_range<Range>::value >

Definition at line 1682 of file algorithm.hpp.

References make_range().

Referenced by inplace_merge().

◆ invoke()

auto invoke ( Functor &&  f,
Args &&...  args 
) -> enable_if_t< ::std::is_member_pointer<decay_t<Functor>>::value, result_of_t<Functor&&(Args&&...)> >

◆ is_heap() [1/2]

auto core::v2::is_heap ( Range &&  rng) -> enable_if_t<is_range<Range>::value, bool>

Definition at line 1921 of file algorithm.hpp.

References is_heap(), and make_range().

◆ is_heap() [2/2]

auto core::v2::is_heap ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 1929 of file algorithm.hpp.

References make_range().

Referenced by is_heap().

◆ is_heap_until() [1/2]

auto core::v2::is_heap_until ( Range &&  rng) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1944 of file algorithm.hpp.

References is_heap_until(), and make_range().

◆ is_heap_until() [2/2]

auto core::v2::is_heap_until ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1955 of file algorithm.hpp.

References make_range().

Referenced by is_heap_until().

◆ is_partitioned()

auto core::v2::is_partitioned ( Range &&  rng,
UnaryPredicate &&  up 
) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 1236 of file algorithm.hpp.

References make_range().

◆ is_permutation() [1/2]

auto core::v2::is_permutation ( Range1 &&  rng1,
Range2 &&  rng2 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), bool >

Definition at line 2186 of file algorithm.hpp.

References is_permutation(), and make_range().

◆ is_permutation() [2/2]

auto core::v2::is_permutation ( Range1 &&  rng1,
Range2 &&  rng2,
BinaryPredicate &&  bp 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), bool >

Definition at line 2204 of file algorithm.hpp.

References make_range().

Referenced by is_permutation().

◆ is_sorted() [1/2]

auto core::v2::is_sorted ( Range &&  rng) -> enable_if_t<is_range<Range>::value, bool>

Definition at line 1320 of file algorithm.hpp.

References is_sorted(), and make_range().

◆ is_sorted() [2/2]

auto core::v2::is_sorted ( Range &&  rng,
Compare &&  compare 
) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 1328 of file algorithm.hpp.

References make_range().

Referenced by is_sorted().

◆ is_sorted_until() [1/2]

auto core::v2::is_sorted_until ( Range &&  rng) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1343 of file algorithm.hpp.

References is_sorted_until(), and make_range().

◆ is_sorted_until() [2/2]

auto core::v2::is_sorted_until ( Range &&  rng,
Compare &&  compare 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1354 of file algorithm.hpp.

References make_range().

Referenced by is_sorted_until().

◆ lexicographical_compare() [1/2]

auto core::v2::lexicographical_compare ( Range1 &&  rng1,
Range2 &&  rng2 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), bool >

Definition at line 2143 of file algorithm.hpp.

References lexicographical_compare(), and make_range().

◆ lexicographical_compare() [2/2]

auto core::v2::lexicographical_compare ( Range1 &&  rng1,
Range2 &&  rng2,
Compare &&  cmp 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), bool >

Definition at line 2162 of file algorithm.hpp.

References make_range().

Referenced by lexicographical_compare().

◆ lower_bound() [1/2]

auto core::v2::lower_bound ( Range &&  rng,
T const &  value 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1513 of file algorithm.hpp.

References lower_bound(), and make_range().

Referenced by KMeansPlusPlusInitialization::Cluster().

◆ lower_bound() [2/2]

auto core::v2::lower_bound ( Range &&  rng,
T const &  value,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1524 of file algorithm.hpp.

References make_range().

Referenced by lower_bound().

◆ make_apply()

auto core::v2::make_apply ( F &&  f) -> apply_functor<F>

Definition at line 118 of file functional.hpp.

◆ make_capture() [1/2]

auto core::v2::make_capture ( remove_reference_t< T > &  ref) -> capture<T>

Definition at line 167 of file utility.hpp.

References move().

◆ make_capture() [2/2]

auto core::v2::make_capture ( remove_reference_t< T > &&  ref) -> capture<T>

Definition at line 172 of file utility.hpp.

References move().

◆ make_heap() [1/2]

auto core::v2::make_heap ( Range &&  rng) -> enable_if_t<is_range<Range>::value>

Definition at line 1970 of file algorithm.hpp.

References make_heap(), and make_range().

◆ make_heap() [2/2]

auto core::v2::make_heap ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1978 of file algorithm.hpp.

References make_range().

Referenced by make_heap().

◆ make_move_range() [1/2]

range<::std::move_iterator<Iter> > core::v2::make_move_range ( Iter  start,
Iter  stop 
)

Definition at line 325 of file range.hpp.

References make_range().

Referenced by make_move_range().

◆ make_move_range() [2/2]

range<::std::move_iterator<T*> > core::v2::make_move_range ( T *  ptr,
::std::size_t  n 
)

Definition at line 332 of file range.hpp.

References make_move_range().

◆ make_number_iterator() [1/2]

number_iterator<T> core::v2::make_number_iterator ( value,
step 
)
noexcept

Definition at line 261 of file iterator.hpp.

Referenced by make_number_range().

◆ make_number_iterator() [2/2]

number_iterator<T> core::v2::make_number_iterator ( value)
noexcept

Definition at line 266 of file iterator.hpp.

◆ make_number_range() [1/2]

range<number_iterator<T> > core::v2::make_number_range ( start,
stop,
step 
)
noexcept

Definition at line 337 of file range.hpp.

References make_number_iterator(), and make_range().

◆ make_number_range() [2/2]

range<number_iterator<T> > core::v2::make_number_range ( start,
stop 
)
noexcept

Definition at line 344 of file range.hpp.

References make_number_iterator(), and make_range().

◆ make_ostream_joiner()

ostream_joiner<decay_t<DelimT>, CharT, Traits> core::v2::make_ostream_joiner ( ::std::basic_ostream< CharT, Traits > &  stream,
DelimT &&  delimiter 
)

Definition at line 250 of file iterator.hpp.

◆ make_range() [1/5]

◆ make_range() [2/5]

auto core::v2::make_range ( Iterator  begin,
Iterator  end 
) -> range<Iterator>

Definition at line 293 of file range.hpp.

◆ make_range() [3/5]

auto core::v2::make_range ( Range &&  value) -> range<decltype(begin(value))>

Definition at line 298 of file range.hpp.

References make_range().

◆ make_range() [4/5]

auto core::v2::make_range ( ::std::basic_istream< CharT, Traits > &  stream) -> range< ::std::istream_iterator<T, CharT, Traits> >

Definition at line 309 of file range.hpp.

References make_range().

◆ make_range() [5/5]

auto core::v2::make_range ( ::std::basic_streambuf< CharT, Traits > *  buffer) -> range< ::std::istreambuf_iterator<CharT, Traits> >

Definition at line 317 of file range.hpp.

References make_range().

◆ make_reverse_iterator()

::std::reverse_iterator<Iterator> core::v2::make_reverse_iterator ( Iterator  iter)

Definition at line 136 of file iterator.hpp.

◆ make_scope_guard()

auto core::v2::make_scope_guard ( Callable &&  callable) -> scope_guard<decay_t<Callable>>

Definition at line 98 of file utility.hpp.

◆ max() [1/2]

◆ max() [2/2]

constexpr T const& core::v2::max ( T const &  lhs,
T const &  rhs,
Compare  compare 
)

Definition at line 84 of file algorithm.hpp.

◆ max_element() [1/2]

auto core::v2::max_element ( Range &&  rng) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 2059 of file algorithm.hpp.

References make_range(), and max_element().

◆ max_element() [2/2]

auto core::v2::max_element ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 2070 of file algorithm.hpp.

References make_range().

Referenced by max_element().

◆ merge() [1/2]

auto core::v2::merge ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1622 of file algorithm.hpp.

References make_range(), and merge().

◆ merge() [2/2]

auto core::v2::merge ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it,
Compare &&  cmp 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1642 of file algorithm.hpp.

References make_range().

Referenced by merge().

◆ min() [1/2]

◆ min() [2/2]

constexpr T const& core::v2::min ( T const &  lhs,
T const &  rhs,
Compare  compare 
)

Definition at line 74 of file algorithm.hpp.

◆ min_element() [1/2]

auto core::v2::min_element ( Range &&  rng) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 2085 of file algorithm.hpp.

References make_range(), and min_element().

◆ min_element() [2/2]

auto core::v2::min_element ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 2096 of file algorithm.hpp.

References make_range().

Referenced by min_element().

◆ minmax_element() [1/2]

auto core::v2::minmax_element ( Range &&  rng) -> enable_if_t< is_range<Range>::value, ::std::pair< decltype(::std::begin(::core::forward<Range>(rng))), decltype(::std::end(::core::forward<Range>(rng))) > >

Definition at line 2111 of file algorithm.hpp.

References make_range(), and minmax_element().

◆ minmax_element() [2/2]

auto core::v2::minmax_element ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, ::std::pair< range<decltype(::std::begin(::core::forward<Range>(rng)))>, range<decltype(::std::end(::core::forward<Range>(rng)))> > >

Definition at line 2125 of file algorithm.hpp.

References make_range().

Referenced by minmax_element().

◆ mismatch() [1/5]

::std::pair<InputIt1, InputIt2> core::v2::mismatch ( InputIt1  first1,
InputIt1  last1,
InputIt2  first2,
InputIt2  last2,
BinaryPredicate  predicate 
)

Definition at line 263 of file algorithm.hpp.

References make_range().

Referenced by mismatch().

◆ mismatch() [2/5]

::std::pair<InputIt1, InputIt2> core::v2::mismatch ( InputIt1  first1,
InputIt1  last1,
InputIt2  first2,
InputIt2  last2 
)

Definition at line 281 of file algorithm.hpp.

References mismatch().

◆ mismatch() [3/5]

auto core::v2::mismatch ( Range1 &&  r1,
Range2 &&  r2,
BinaryPred &&  bp 
) -> ::std::pair< decltype(::std::begin(::core::forward<Range1>(r1))), decltype(::std::begin(::core::forward<Range2>(r2))) >

Definition at line 295 of file algorithm.hpp.

References make_range(), and mismatch().

◆ mismatch() [4/5]

auto core::v2::mismatch ( Range &&  rng,
InputIt &&  it 
) -> ::std::pair< decltype(make_range(::core::forward<Range>(rng)).begin()), decay_t<InputIt> >

Definition at line 318 of file algorithm.hpp.

References make_range(), and mismatch().

◆ mismatch() [5/5]

auto core::v2::mismatch ( Range &&  r,
InputIt &&  it,
BinaryPredicate &&  bp 
) -> ::std::pair< decltype(core::make_range(::core::forward<Range>(r).begin())), decay_t<InputIt> >

Definition at line 339 of file algorithm.hpp.

References make_range().

Referenced by mismatch().

◆ move() [1/2]

constexpr auto core::v2::move ( T &&  t) -> decltype( static_cast<remove_reference_t<T>&&>(t) )
noexcept

◆ move() [2/2]

auto core::v2::move ( Range &&  rng,
OutputIt &&  it 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

◆ move_backward()

auto core::v2::move_backward ( Range &&  rng,
BidirIt &&  it 
) -> enable_if_t< is_range<Range>::value, decay_t<BidirIt> >

Definition at line 751 of file algorithm.hpp.

References make_range().

◆ next_permutation() [1/2]

auto core::v2::next_permutation ( Range &&  rng) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 2227 of file algorithm.hpp.

References make_range(), and next_permutation().

◆ next_permutation() [2/2]

auto core::v2::next_permutation ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 2238 of file algorithm.hpp.

References make_range().

Referenced by next_permutation().

◆ none_of()

auto core::v2::none_of ( Range &&  rng,
UnaryPredicate &&  p 
) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 149 of file algorithm.hpp.

References make_range().

◆ not_fn()

not_fn_functor<decay_t<F> > core::v2::not_fn ( F &&  f)

Definition at line 143 of file functional.hpp.

◆ nth_element() [1/2]

auto core::v2::nth_element ( Range &&  rng,
RandomIt &&  it 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1483 of file algorithm.hpp.

References make_range(), and nth_element().

◆ nth_element() [2/2]

auto core::v2::nth_element ( Range &&  rng,
RandomIt &&  it,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1497 of file algorithm.hpp.

References make_range().

Referenced by nth_element().

◆ operator!=() [1/5]

bool core::v2::operator!= ( basic_string_view< CharT, Traits >  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 550 of file string_view.hpp.

References basic_string_view< CharT, Traits >::size().

Referenced by type_of().

◆ operator!=() [2/5]

bool core::v2::operator!= ( basic_string_view< CharT, Traits >  lhs,
::std::basic_string< CharT, Traits, Allocator > const &  rhs 
)
noexcept

Definition at line 587 of file string_view.hpp.

◆ operator!=() [3/5]

bool core::v2::operator!= ( ::std::basic_string< CharT, Traits, Allocator > const &  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 624 of file string_view.hpp.

◆ operator!=() [4/5]

bool core::v2::operator!= ( basic_string_view< CharT, Traits >  lhs,
CharT const *  rhs 
)
noexcept

Definition at line 661 of file string_view.hpp.

◆ operator!=() [5/5]

bool core::v2::operator!= ( CharT const *  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 698 of file string_view.hpp.

◆ operator<() [1/5]

bool core::v2::operator< ( basic_string_view< CharT, Traits >  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

◆ operator<() [2/5]

bool core::v2::operator< ( basic_string_view< CharT, Traits >  lhs,
::std::basic_string< CharT, Traits, Allocator > const &  rhs 
)
noexcept

Definition at line 611 of file string_view.hpp.

◆ operator<() [3/5]

bool core::v2::operator< ( ::std::basic_string< CharT, Traits, Allocator > const &  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 648 of file string_view.hpp.

◆ operator<() [4/5]

bool core::v2::operator< ( basic_string_view< CharT, Traits >  lhs,
CharT const *  rhs 
)
noexcept

Definition at line 685 of file string_view.hpp.

◆ operator<() [5/5]

bool core::v2::operator< ( CharT const *  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 722 of file string_view.hpp.

◆ operator<<()

::std::basic_ostream<CharT, Traits>& core::v2::operator<< ( ::std::basic_ostream< CharT, Traits > &  os,
basic_string_view< CharT, Traits > const &  str 
)

Definition at line 728 of file string_view.hpp.

References basic_string_view< CharT, Traits >::to_string().

◆ operator<=() [1/5]

bool core::v2::operator<= ( basic_string_view< CharT, Traits >  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 562 of file string_view.hpp.

References basic_string_view< CharT, Traits >::compare().

◆ operator<=() [2/5]

bool core::v2::operator<= ( basic_string_view< CharT, Traits >  lhs,
::std::basic_string< CharT, Traits, Allocator > const &  rhs 
)
noexcept

Definition at line 599 of file string_view.hpp.

◆ operator<=() [3/5]

bool core::v2::operator<= ( ::std::basic_string< CharT, Traits, Allocator > const &  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 636 of file string_view.hpp.

◆ operator<=() [4/5]

bool core::v2::operator<= ( basic_string_view< CharT, Traits >  lhs,
CharT const *  rhs 
)
noexcept

Definition at line 673 of file string_view.hpp.

◆ operator<=() [5/5]

bool core::v2::operator<= ( CharT const *  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 710 of file string_view.hpp.

◆ operator==() [1/5]

bool core::v2::operator== ( basic_string_view< CharT, Traits >  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 544 of file string_view.hpp.

References basic_string_view< CharT, Traits >::size().

Referenced by type_of().

◆ operator==() [2/5]

bool core::v2::operator== ( basic_string_view< CharT, Traits >  lhs,
::std::basic_string< CharT, Traits, Allocator > const &  rhs 
)
noexcept

Definition at line 581 of file string_view.hpp.

◆ operator==() [3/5]

bool core::v2::operator== ( ::std::basic_string< CharT, Traits, Allocator > const &  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 618 of file string_view.hpp.

◆ operator==() [4/5]

bool core::v2::operator== ( basic_string_view< CharT, Traits >  lhs,
CharT const *  rhs 
)
noexcept

Definition at line 655 of file string_view.hpp.

◆ operator==() [5/5]

bool core::v2::operator== ( CharT const *  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 692 of file string_view.hpp.

◆ operator>() [1/5]

bool core::v2::operator> ( basic_string_view< CharT, Traits >  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 568 of file string_view.hpp.

References basic_string_view< CharT, Traits >::compare().

◆ operator>() [2/5]

bool core::v2::operator> ( basic_string_view< CharT, Traits >  lhs,
::std::basic_string< CharT, Traits, Allocator > const &  rhs 
)
noexcept

Definition at line 605 of file string_view.hpp.

◆ operator>() [3/5]

bool core::v2::operator> ( ::std::basic_string< CharT, Traits, Allocator > const &  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 642 of file string_view.hpp.

◆ operator>() [4/5]

bool core::v2::operator> ( basic_string_view< CharT, Traits >  lhs,
CharT const *  rhs 
)
noexcept

Definition at line 679 of file string_view.hpp.

◆ operator>() [5/5]

bool core::v2::operator> ( CharT const *  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 716 of file string_view.hpp.

◆ operator>=() [1/5]

bool core::v2::operator>= ( basic_string_view< CharT, Traits >  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 556 of file string_view.hpp.

References basic_string_view< CharT, Traits >::compare().

◆ operator>=() [2/5]

bool core::v2::operator>= ( basic_string_view< CharT, Traits >  lhs,
::std::basic_string< CharT, Traits, Allocator > const &  rhs 
)
noexcept

Definition at line 593 of file string_view.hpp.

◆ operator>=() [3/5]

bool core::v2::operator>= ( ::std::basic_string< CharT, Traits, Allocator > const &  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 630 of file string_view.hpp.

◆ operator>=() [4/5]

bool core::v2::operator>= ( basic_string_view< CharT, Traits >  lhs,
CharT const *  rhs 
)
noexcept

Definition at line 667 of file string_view.hpp.

◆ operator>=() [5/5]

bool core::v2::operator>= ( CharT const *  lhs,
basic_string_view< CharT, Traits >  rhs 
)
noexcept

Definition at line 704 of file string_view.hpp.

◆ partial_sort() [1/2]

auto core::v2::partial_sort ( Range &&  rng,
RandomIt &&  it 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1389 of file algorithm.hpp.

References make_range(), and partial_sort().

◆ partial_sort() [2/2]

auto core::v2::partial_sort ( Range &&  rng,
RandomIt &&  it,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1403 of file algorithm.hpp.

References make_range().

Referenced by partial_sort().

◆ partial_sort_copy() [1/2]

auto core::v2::partial_sort_copy ( IRange &&  irng,
RRange &&  rrng 
) -> meta::when< meta::all_of<meta::list<IRange, RRange>, is_range>(), decltype(::std::begin(::core::forward<RRange>(rrng))) >

Definition at line 1418 of file algorithm.hpp.

References make_range(), and partial_sort_copy().

◆ partial_sort_copy() [2/2]

auto core::v2::partial_sort_copy ( IRange &&  irng,
RRange &&  rrng,
Compare &&  cmp 
) -> meta::when< meta::all_of<meta::list<IRange, RRange>, is_range>(), decltype(::std::begin(::core::forward<RRange>(rrng))) >

Definition at line 1437 of file algorithm.hpp.

References make_range().

Referenced by partial_sort_copy().

◆ partition()

auto core::v2::partition ( Range &&  rng,
UnaryPredicate &&  up 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1251 of file algorithm.hpp.

References make_range().

◆ partition_copy()

auto core::v2::partition_copy ( Range &&  rng,
OutputTrue &&  ot,
OutputFalse &&  of,
UnaryPred &&  up 
) -> enable_if_t< is_range<Range>::value, ::std::pair<decay_t<OutputTrue>, decay_t<OutputFalse>> >

Definition at line 1266 of file algorithm.hpp.

References make_range().

◆ partition_point()

auto core::v2::partition_point ( Range &&  rng,
UnaryPredicate &&  up 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1303 of file algorithm.hpp.

References make_range().

◆ pop_heap() [1/2]

auto core::v2::pop_heap ( Range &&  rng) -> enable_if_t<is_range<Range>::value>

Definition at line 2014 of file algorithm.hpp.

References make_range(), and pop_heap().

◆ pop_heap() [2/2]

auto core::v2::pop_heap ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value >

Definition at line 2022 of file algorithm.hpp.

References make_range().

Referenced by pop_heap().

◆ prev_permutation() [1/2]

auto core::v2::prev_permutation ( Range &&  rng) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 2253 of file algorithm.hpp.

References make_range(), and prev_permutation().

◆ prev_permutation() [2/2]

auto core::v2::prev_permutation ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, bool >

Definition at line 2264 of file algorithm.hpp.

References make_range().

Referenced by prev_permutation().

◆ push_heap() [1/2]

auto core::v2::push_heap ( Range &&  rng) -> enable_if_t<is_range<Range>::value>

Definition at line 1992 of file algorithm.hpp.

References make_range(), and push_heap().

◆ push_heap() [2/2]

auto core::v2::push_heap ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value >

Definition at line 2000 of file algorithm.hpp.

References make_range().

Referenced by push_heap().

◆ rbegin() [1/2]

auto core::v2::rbegin ( Container const &  container) -> decltype(container.rbegin())

◆ rbegin() [2/2]

auto core::v2::rbegin ( Container &  container) -> decltype(container.rbegin())

Definition at line 111 of file iterator.hpp.

◆ remove()

auto core::v2::remove ( Range &&  rng,
T const &  value 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 941 of file algorithm.hpp.

References make_range().

◆ remove_copy()

auto core::v2::remove_copy ( Range &&  rng,
OutputIt &&  it,
T const &  value 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 967 of file algorithm.hpp.

References make_range().

◆ remove_copy_if()

auto core::v2::remove_copy_if ( Range &&  rng,
OutputIt &&  it,
UnaryPred &&  up 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 983 of file algorithm.hpp.

References make_range().

◆ remove_erase()

auto core::v2::remove_erase ( Range &&  rng,
T const &  val 
) -> enable_if_t< is_range<Range>::value >

Definition at line 999 of file algorithm.hpp.

◆ remove_erase_if()

auto core::v2::remove_erase_if ( Range &&  rng,
UnaryPred &&  up 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1009 of file algorithm.hpp.

References remove_if().

◆ remove_if()

auto core::v2::remove_if ( Range &&  rng,
UnaryPredicate &&  up 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 952 of file algorithm.hpp.

References make_range().

Referenced by remove_erase_if().

◆ rend() [1/2]

auto core::v2::rend ( Container const &  container) -> decltype(container.rend())

◆ rend() [2/2]

auto core::v2::rend ( Container &  container) -> decltype(container.rend())

Definition at line 126 of file iterator.hpp.

◆ replace()

auto core::v2::replace ( Range &&  rng,
T const &  old,
T const &  value 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1022 of file algorithm.hpp.

References make_range().

Referenced by ReadData(), and mlpack::util::StripType().

◆ replace_copy()

auto core::v2::replace_copy ( Range &&  rng,
OutputIt &&  it,
T const &  old,
T const &  value 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 1052 of file algorithm.hpp.

References make_range().

◆ replace_copy_if()

auto core::v2::replace_copy_if ( Range &&  rng,
OutputIt &&  it,
UnaryPred &&  up,
T const &  value 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 1074 of file algorithm.hpp.

References make_range().

◆ replace_if()

auto core::v2::replace_if ( Range &&  rng,
UnaryPred &&  up,
T const &  value 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1037 of file algorithm.hpp.

References make_range().

◆ reverse()

auto core::v2::reverse ( Range &&  rng) -> enable_if_t<is_range<Range>::value>

Definition at line 1111 of file algorithm.hpp.

References make_range().

◆ reverse_copy()

auto core::v2::reverse_copy ( Range &&  rng,
OutputIt &&  it 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 1119 of file algorithm.hpp.

References make_range().

◆ rotate()

auto core::v2::rotate ( Range &&  rng,
ForwardIt &&  it 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1134 of file algorithm.hpp.

References make_range().

◆ rotate_copy()

auto core::v2::rotate_copy ( Range &&  rng,
ForwardIt &&  it,
OutputIt &&  ot 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 1148 of file algorithm.hpp.

References make_range().

◆ search() [1/2]

auto core::v2::search ( Range1 &&  rng1,
Range2 &&  rng2 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), decltype(::std::begin(::core::forward<Range1>(rng1))) >

◆ search() [2/2]

auto core::v2::search ( Range1 &&  rng1,
Range2 &&  rng2,
BinaryPred &&  bp 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), decltype(::std::begin(::core::forward<Range1>(rng1))) >

Definition at line 618 of file algorithm.hpp.

References make_range().

Referenced by search().

◆ search_n() [1/2]

auto core::v2::search_n ( Range &&  rng,
Size &&  count,
T const &  value 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 638 of file algorithm.hpp.

References count(), make_range(), and search_n().

◆ search_n() [2/2]

auto core::v2::search_n ( Range &&  rng,
Size &&  count,
T const &  value,
BinaryPred &&  bp 
) -> meta::when< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 654 of file algorithm.hpp.

References count(), and make_range().

Referenced by search_n().

◆ set_difference() [1/2]

auto core::v2::set_difference ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1736 of file algorithm.hpp.

References make_range(), and set_difference().

◆ set_difference() [2/2]

auto core::v2::set_difference ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it,
Compare &&  cmp 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1756 of file algorithm.hpp.

References make_range().

Referenced by set_difference().

◆ set_intersection() [1/2]

auto core::v2::set_intersection ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1782 of file algorithm.hpp.

References make_range(), and set_intersection().

◆ set_intersection() [2/2]

auto core::v2::set_intersection ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it,
Compare &&  cmp 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1802 of file algorithm.hpp.

References make_range().

Referenced by set_intersection().

◆ set_symmetric_difference() [1/2]

auto core::v2::set_symmetric_difference ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1828 of file algorithm.hpp.

References make_range(), and set_symmetric_difference().

◆ set_symmetric_difference() [2/2]

auto core::v2::set_symmetric_difference ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it,
Compare &&  cmp 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1848 of file algorithm.hpp.

References make_range().

Referenced by set_symmetric_difference().

◆ set_union() [1/2]

auto core::v2::set_union ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1874 of file algorithm.hpp.

References make_range(), and set_union().

◆ set_union() [2/2]

auto core::v2::set_union ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it,
Compare &&  cmp 
) -> enable_if_t< meta::all_of<meta::list<Range1, Range2>, is_range>(), decay_t<OutputIt> >

Definition at line 1894 of file algorithm.hpp.

References make_range().

Referenced by set_union().

◆ shuffle()

auto core::v2::shuffle ( Range &&  rng,
URNG &&  g 
) -> enable_if_t< is_range<Range>::value >

◆ size() [1/2]

constexpr auto core::v2::size ( Container const &  container) -> decltype( container.size() )
noexcept

Definition at line 29 of file iterator.hpp.

Referenced by StringEncodingDictionary< Token >::AddToken(), StringEncodingDictionary< STRING_VIEW >::AddToken(), StringEncodingDictionary< int >::AddToken(), basic_string_view< CharT, Traits >::at(), basic_string_view< CharT, Traits >::back(), CategoricalDQN< OutputLayerType, InitType, NetworkType >::Backward(), cereal::CEREAL_LOAD_FUNCTION_NAME(), CheckMatrices(), FastLSTMType< InputType, OutputType >::Clone(), basic_string_view< CharT, Traits >::compare(), basic_string_view< CharT, Traits >::copy(), IdentityFunction::Deriv(), HardSigmoidFunction::Deriv(), RectifierFunction::Deriv(), HardSwishFunction::Deriv(), list< Ts >::empty(), basic_string_view< CharT, Traits >::empty(), basic_string_view< CharT, Traits >::end(), basic_string_view< CharT, Traits >::ends_with(), basic_string_view< CharT, Traits >::find(), basic_string_view< CharT, Traits >::find_first_not_of(), basic_string_view< CharT, Traits >::find_first_of(), basic_string_view< CharT, Traits >::find_last_not_of(), basic_string_view< CharT, Traits >::find_last_of(), HardSigmoidFunction::Fn(), SwishFunction::Fn(), SoftplusFunction::Fn(), SoftsignFunction::Fn(), HardSwishFunction::Fn(), GlimpseType< InputType, OutputType >::GlimpseSize(), AtrousConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputType, OutputType >::InputShape(), SoftplusFunction::Inv(), SoftsignFunction::Inv(), basic_string_view< CharT, Traits >::length(), basic_string_view< CharT, Traits >::operator::std::basic_string(), GlimpseType< InputType, OutputType >::OutputDimensions(), PearsonSearch::PearsonSearch(), range< Iterator >::pop_back_upto(), range< Iterator >::pop_front_upto(), PrioritizedReplay< EnvironmentType >::PrioritizedReplay(), basic_string_view< CharT, Traits >::remove_prefix(), basic_string_view< CharT, Traits >::remove_suffix(), basic_string_view< CharT, Traits >::rfind(), GreedyPolicy< EnvironmentType >::Sample(), RandomPointSelection::Select(), StringEncodingDictionary< int >::serialize(), StringEncodingDictionary< int >::Size(), range< Iterator >::slice(), basic_string_view< CharT, Traits >::starts_with(), OneStepSarsaWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType >::Step(), basic_string_view< CharT, Traits >::substr(), basic_string_view< CharT, Traits >::to_string(), UnionFind::UnionFind(), and ConvolutionType< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, MatType >::WeightSize().

◆ size() [2/2]

constexpr ::std::size_t core::v2::size ( T   const(&)[N])
noexcept

Definition at line 34 of file iterator.hpp.

◆ sort() [1/2]

auto core::v2::sort ( Range &&  rng) -> enable_if_t<is_range<Range>::value>

Definition at line 1369 of file algorithm.hpp.

References make_range(), and sort().

Referenced by CheckMatrices().

◆ sort() [2/2]

auto core::v2::sort ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t<is_range<Range>::value>

Definition at line 1377 of file algorithm.hpp.

References make_range().

Referenced by sort().

◆ sort_heap() [1/2]

auto core::v2::sort_heap ( Range &&  rng) -> enable_if_t<is_range<Range>::value>

Definition at line 2036 of file algorithm.hpp.

References make_range(), and sort_heap().

◆ sort_heap() [2/2]

auto core::v2::sort_heap ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value >

Definition at line 2044 of file algorithm.hpp.

References make_range().

Referenced by sort_heap().

◆ stable_partition()

auto core::v2::stable_partition ( Range &&  rng,
UnaryPredicate &&  up 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1288 of file algorithm.hpp.

References make_range().

◆ stable_sort() [1/2]

auto core::v2::stable_sort ( Range &&  rng) -> enable_if_t<is_range<Range>::value>

Definition at line 1461 of file algorithm.hpp.

References make_range(), and stable_sort().

◆ stable_sort() [2/2]

auto core::v2::stable_sort ( Range &&  rng,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value >

Definition at line 1469 of file algorithm.hpp.

References make_range().

Referenced by stable_sort().

◆ swap() [1/4]

void core::v2::swap ( number_iterator< T > &  lhs,
number_iterator< T > &  rhs 
)
noexcept

Definition at line 245 of file iterator.hpp.

Referenced by number_iterator< T >::swap().

◆ swap() [2/4]

void core::v2::swap ( any lhs,
any rhs 
)
inlinenoexcept

◆ swap() [3/4]

void core::v2::swap ( range< Iterator > &  lhs,
range< Iterator > &  rhs 
)
noexcept

Definition at line 349 of file range.hpp.

Referenced by range< Iterator >::swap().

◆ swap() [4/4]

void core::v2::swap ( basic_string_view< CharT, Traits > &  lhs,
basic_string_view< CharT, Traits > &  rhs 
)
noexcept

◆ swap_ranges()

auto core::v2::swap_ranges ( Range &&  rng,
ForwardIt &&  it 
) -> enable_if_t< is_range<Range>::value, decay_t<ForwardIt> >

Definition at line 1096 of file algorithm.hpp.

References make_range().

◆ throw_bad_any_cast()

void core::v2::throw_bad_any_cast ( )
inline

Definition at line 152 of file any.hpp.

Referenced by any_cast().

◆ throw_out_of_range()

void core::v2::throw_out_of_range ( char const *  msg)
inline

◆ transform() [1/3]

auto core::v2::transform ( Range &&  rng,
OutputIt &&  it,
UnaryOperation &&  op 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 776 of file algorithm.hpp.

References make_range(), and transform().

Referenced by mlpack::data::Extension(), and mlpack::util::ToLower().

◆ transform() [2/3]

decay_t<OutputIt> core::v2::transform ( Range &&  r,
InputIt &&  in,
OutputIt &&  out,
BinaryOperation &&  op 
)

◆ transform() [3/3]

decay_t<OutputIt> core::v2::transform ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt &&  it,
BinaryOperation &&  op 
)

Definition at line 886 of file algorithm.hpp.

References make_range().

Referenced by transform().

◆ transform_if() [1/2]

auto core::v2::transform_if ( Range &&  rng,
OutputIt  it,
UnaryOperation  op,
UnaryPred  up 
) -> enable_if_t< is_range<Range>::value, OutputIt >

◆ transform_if() [2/2]

auto core::v2::transform_if ( Range1 &&  rng1,
Range2 &&  rng2,
OutputIt  it,
BinaryOperation  op,
BinaryPredicate  bp 
) -> meta::when< meta::all_of<meta::list<Range1, Range2>, is_range>(), OutputIt >

Definition at line 913 of file algorithm.hpp.

References make_range().

◆ transform_n() [1/2]

OutputIt core::v2::transform_n ( InputIt  in,
Size  count,
OutputIt  out,
UnaryOp  op 
)

Definition at line 819 of file algorithm.hpp.

References count(), and invoke().

◆ transform_n() [2/2]

OutputIt core::v2::transform_n ( InputIt1  in1,
InputIt2  in2,
Size  count,
OutputIt  out,
UnaryOp  op 
)

Definition at line 835 of file algorithm.hpp.

References count(), and invoke().

◆ type_of()

type_info const& core::v2::type_of ( )
noexcept

Definition at line 32 of file typeinfo.hpp.

References as_int(), operator!=(), and operator==().

◆ unique() [1/2]

auto core::v2::unique ( Range &&  rng) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1178 of file algorithm.hpp.

References make_range(), and unique().

Referenced by MultipleRandomDimensionSelect::Begin().

◆ unique() [2/2]

auto core::v2::unique ( Range &&  rng,
BinaryPredicate &&  bp 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1189 of file algorithm.hpp.

References make_range().

Referenced by unique().

◆ unique_copy() [1/2]

auto core::v2::unique_copy ( Range &&  rng,
OutputIt &&  it 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 1204 of file algorithm.hpp.

References make_range(), and unique_copy().

◆ unique_copy() [2/2]

auto core::v2::unique_copy ( Range &&  rng,
OutputIt &&  it,
BinaryPred &&  bp 
) -> enable_if_t< is_range<Range>::value, decay_t<OutputIt> >

Definition at line 1219 of file algorithm.hpp.

References make_range().

Referenced by unique_copy().

◆ upper_bound() [1/2]

auto core::v2::upper_bound ( Range &&  rng,
T const &  value 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1540 of file algorithm.hpp.

References make_range(), and upper_bound().

◆ upper_bound() [2/2]

auto core::v2::upper_bound ( Range &&  rng,
T const &  value,
Compare &&  cmp 
) -> enable_if_t< is_range<Range>::value, decltype(::std::begin(::core::forward<Range>(rng))) >

Definition at line 1551 of file algorithm.hpp.

References make_range().

Referenced by upper_bound().

◆ value_at() [1/2]

constexpr auto core::v2::value_at ( T &&  value,
Ts &&  ... 
) -> enable_if_t< N =
pure virtual

◆ value_at() [2/2]

constexpr autodecltype(::core::forward<T>(value)) constexpr auto core::v2::value_at ( T &&  ,
Ts &&...  values 
) -> enable_if_t< N !
pure virtual