uTL
micro Template library
Classes | Namespaces | Typedefs | Variables
stl.h File Reference

STL's Concepts. More...

#include <utl/core/impl.h>
#include <utl/meta/meta.h>
#include <utl/utility/invoke.h>
#include <utl/concepts/defines.h>

Go to the source code of this file.

Classes

struct  utl::common_impl::__copy_cv_< From >
 
struct  utl::common_impl::__copy_cv_< const From >
 
struct  utl::common_impl::__copy_cv_< volatile From >
 
struct  utl::common_impl::__copy_cv_< const volatile From >
 
struct  utl::common_impl::__common_ref_< T, U, class >
 
struct  utl::common_impl::__common_ref_< T &, U &, meta::void_t< __lref_res< T, U >, meta::when< std::is_reference< __lref_res< T, U > >::value > > >
 
struct  utl::common_impl::__common_ref_< T &&, U &&, meta::void_t< __common_ref< T &, U & >, meta::when< ConvertibleTo< T &&, __rref_res< T, U > > >, meta::when< ConvertibleTo< U &&, __rref_res< T, U > > > > >
 
struct  utl::common_impl::__common_ref_< T &&, U &, meta::void_t< __common_ref< const T &, U & >, meta::when< ConvertibleTo< T &&, __common_ref< const T &, U & > > > > >
 
struct  utl::common_impl::__common_ref_< T &, U &&, meta::void_t< __common_ref< T &, const U & >, meta::when< ConvertibleTo< U &&, __common_ref< T &, const U & > > > > >
 
struct  utl::common_impl::__xref< class >
 
struct  utl::common_impl::__xref< const T >
 
struct  utl::common_impl::__xref< volatile T >
 
struct  utl::common_impl::__xref< const volatile T >
 
struct  utl::common_impl::__xref< T & >
 
struct  utl::common_impl::__xref< T && >
 
struct  utl::common_impl::basic_common_reference< class, class, class, class >
 
struct  utl::common_impl::common_reference<... >
 
struct  utl::common_impl::common_reference< T >
 
struct  utl::common_impl::__common_reference3< T, U,... >
 
struct  utl::common_impl::__common_reference3< T, U, meta::void_t< __cond_res< T, U > > >
 
struct  utl::common_impl::__common_reference2< T, U,... >
 
struct  utl::common_impl::__common_reference2< T, U, meta::void_t< __basic_common_reference_t< T, U > > >
 
struct  utl::common_impl::__common_reference< T, U,... >
 
struct  utl::common_impl::__common_reference< T, U, meta::when< std::is_reference< T >::value &&std::is_reference< U >::value > >
 
struct  utl::common_impl::common_reference< T, U >
 
struct  utl::common_impl::common_reference< T, U, V, W... >
 
struct  utl::details::is_boolean_< B, typename >
 
struct  utl::details::is_boolean_< B, meta::void_t< meta::use_if_same_t< bool, decltype(!std::declval< cref_< B >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< B >>()==std::declval< cref_< B >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< B >>() !=std::declval< cref_< B >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< B >>() &&std::declval< cref_< B >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< B >>()||std::declval< cref_< B >>())> > >
 
struct  utl::details::is_weakly_equality_comparable_with_< T, U, typename >
 
struct  utl::details::is_weakly_equality_comparable_with_< T, U, meta::void_t< meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>()==std::declval< cref_< U >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>() !=std::declval< cref_< U >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< U >>()==std::declval< cref_< T >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< U >>() !=std::declval< cref_< T >>())> > >
 
struct  utl::details::is_strict_totally_ordered_< T, typename >
 
struct  utl::details::is_strict_totally_ordered_< T, meta::void_t< meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>()< std::declval< cref_< T >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>() > std::declval< cref_< T >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>()<=std::declval< cref_< T >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>() >=std::declval< cref_< T >>())> > >
 
struct  utl::details::is_strict_totally_ordered_with_< T, U, typename >
 
struct  utl::details::is_strict_totally_ordered_with_< T, U, meta::void_t< meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>()< std::declval< cref_< U >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>() > std::declval< cref_< U >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>()<=std::declval< cref_< U >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< T >>() >=std::declval< cref_< U >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< U >>()< std::declval< cref_< T >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< U >>() > std::declval< cref_< T >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< U >>()<=std::declval< cref_< T >>())>, meta::use_if_same_t< bool, decltype(std::declval< cref_< U >>() >=std::declval< cref_< T >>())> > >
 

Namespaces

 utl
 STL's core language concepts.
 
 utl::common_impl
 
 utl::details
 

Typedefs

template<typename T >
using utl::remove_cvref_t = std::remove_cv_t< std::remove_reference_t< T > >
 
template<typename T >
using utl::cref_ = const std::remove_reference_t< T > &
 
template<typename T >
using utl::_ref_t = std::add_lvalue_reference_t< T >
 
template<typename _T1 , typename _T2 , typename _Ret = _T1>
using utl::use_if_same_t = meta::eval< meta::enable_if< meta::same_< _T1, _T2 >::value, _Ret > >
 
template<class T , class U >
using utl::common_impl::__cond_res = decltype(false ? std::declval< T(&)()>()() :std::declval< U(&)()>()())
 
template<class From , class To >
using utl::common_impl::__copy_cv = meta::invoke< __copy_cv_< From >, To >
 
template<class T >
using utl::common_impl::__cref = std::add_lvalue_reference_t< const std::remove_reference_t< T > >
 
template<class T , class U >
using utl::common_impl::__common_ref = meta::eval< __common_ref_< T, U > >
 
template<class T , class U >
using utl::common_impl::__lref_res = __cond_res< __copy_cv< T, U > &, __copy_cv< U, T > &>
 
template<class T , class U , class R = __common_ref<T&, U&>>
using utl::common_impl::__rref_res = std::remove_reference_t< R > &&
 
template<class T , class U >
using utl::common_impl::__basic_common_reference_t = meta::eval< basic_common_reference< remove_cvref_t< T >, remove_cvref_t< U >, __xref< T >::template apply, __xref< U >::template apply > >
 
template<class... Ts>
using utl::common_impl::common_reference_t = meta::eval< common_reference< Ts... > >
 
template<typename B >
using utl::details::is_boolean_t = meta::eval< is_boolean_< B > >
 
template<typename T , typename U >
using utl::details::is_weakly_equality_comparable_with_t = meta::eval< is_weakly_equality_comparable_with_< T, U > >
 
template<typename T >
using utl::details::is_strict_totally_ordered_t = meta::eval< is_strict_totally_ordered_< T > >
 
template<typename T , typename U >
using utl::details::is_strict_totally_ordered_with_t = meta::eval< is_strict_totally_ordered_with_< T, U > >
 
template<typename... Ts>
using utl::common_reference = common_impl::common_reference< Ts... >
 
template<typename... Ts>
using utl::common_reference_t = meta::eval< common_reference< Ts... > >
 

Variables

template<class T , class U >
_utlConcept utl::Same = meta::same_<T, U>::value
 
template<class Derived , class Base >
_utlConcept utl::DerivedFrom
 
template<class From , class To >
_utlConcept utl::ConvertibleTo = std::is_convertible<From, To>::value
 
template<class T , class U >
_utlConcept utl::CommonReference
 
template<class T , class U >
_utlConcept utl::Common
 
template<class T >
_utlConcept utl::Integral = std::is_integral<T>::value
 
template<class T >
_utlConcept utl::SignedIntegral = Integral<T> && std::is_signed<T>::value
 
template<class T >
_utlConcept utl::UnsignedIntegral = Integral<T> && !std::is_signed<T>::value
 
template<typename T >
_utlConcept utl::MoveAssignable = std::is_move_assignable<T>::value
 
template<typename T >
_utlConcept utl::CopyAssignable = std::is_copy_assignable<T>::value
 
template<class LHS , class RHS >
_utlConcept utl::Assignable
 
template<class T >
_utlConcept utl::Destructible = std::is_nothrow_destructible<T>::value
 
template<class T , class... Args>
_utlConcept utl::Constructible
 
template<class T >
_utlConcept utl::DefaultConstructible = Constructible<T>
 
template<class T >
_utlConcept utl::MoveConstructible
 
template<class T >
_utlConcept utl::CopyConstructible
 
template<class T >
_utlConcept utl::Movable
 
template<class T >
_utlConcept utl::Copyable
 
template<class B >
_utlConcept utl::Boolean
 
template<class T , class U >
_utlConcept utl::WeaklyEqualityComparableWith
 
template<class T >
_utlConcept utl::EqualityComparable = WeaklyEqualityComparableWith<T, T>
 
template<class T , class U >
_utlConcept utl::EqualityComparableWith
 
template<class T >
_utlConcept utl::StrictTotallyOrdered
 
template<class T , class U >
_utlConcept utl::StrictTotallyOrderedWith
 
template<class T >
_utlConcept utl::Semiregular = Copyable<T> && DefaultConstructible<T>
 
template<class T >
_utlConcept utl::Regular = Semiregular<T> && EqualityComparable<T>
 
template<class T >
_utlConcept utl::Scalar
 
template<class T >
_utlConcept utl::Arithmetic
 
template<class T >
_utlConcept utl::FloatingPoint
 
template<class F , class... Args>
_utlConcept utl::Invocable = is_invocable<F, Args...>::value
 
template<class F , class... Args>
_utlConcept utl::RegularInvocable = Invocable<F, Args...>
 
template<class F , class... Args>
_utlConcept utl::Predicate
 
template<class R , class T , class U >
_utlConcept utl::Relation
 
template<class R , class T , class U >
_utlConcept utl::StrictWeakOrder = Relation<R, T, U>
 
using utl::is_swappable = std::is_swappable
 
using utl::is_swappable_with = std::is_swappable_with
 
template<class T , class U >
_utlConcept utl::SwappableWith
 
template<class T >
_utlConcept utl::Swappable = is_swappable_with<T, T>::type::value
 

Detailed Description

STL's Concepts.

Copyright (C) 2018 - 2019 Christos Choutouridis

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file stl.h.