LeechCraft  0.6.70-15082-g543737046d
Modular cross-platform feature rich live environment.
prelude.h File Reference
#include <functional>
#include <type_traits>
#include <iterator>
#include <QPair>
#include <QStringList>
+ Include dependency graph for prelude.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  boost::iterator_range< typename >
 
struct  LC::Util::WrapType< T >
 
struct  LC::Util::WrapType< QList< QString > >
 
struct  LC::Util::detail::CountArgs< typename >
 
struct  LC::Util::detail::CountArgs< Container< Args... > >
 
struct  LC::Util::detail::Replace< Container, T >
 
struct  LC::Util::detail::Replace< Container< U >, T >
 
struct  LC::Util::detail::IsNotBrokenSFINAE< typename >
 
struct  LC::Util::detail::IsNotBrokenSFINAE< boost::iterator_range< T > >
 

Namespaces

 boost
 
 LC
 
 LC::Util
 
 LC::Util::detail
 

Typedefs

template<typename T >
using LC::Util::WrapType_t = typename WrapType< T >::type
 

Functions

template<template< typename U > class Container, typename T1 , typename T2 , typename F >
auto LC::Util::ZipWith (const Container< T1 > &c1, const Container< T2 > &c2, F f) -> WrapType_t< Container< std::decay_t< std::result_of_t< F(T1, T2)>>>>
 
template<typename T1 , typename T2 , template< typename U > class Container, template< typename U1, typename U2 > class Pair = QPair>
auto LC::Util::Zip (const Container< T1 > &c1, const Container< T2 > &c2) -> Container< Pair< T1, T2 >>
 
template<typename Res , typename T >
void LC::Util::detail::Append (Res &result, T &&val) noexcept
 
template<typename C >
constexpr bool LC::Util::detail::IsSimpleContainer ()
 
template<template< typename... > class Fallback, bool ForceFallback, typename Container , typename F >
auto LC::Util::detail::MapImpl (Container &&c, F f)
 
template<typename Container , typename F >
auto LC::Util::Map (Container &&c, F &&f) noexcept(noexcept(std::is_nothrow_invocable_v< F, decltype(*c.begin())>))
 
template<template< typename... > class Fallback, typename Container , typename F >
auto LC::Util::MapAs (Container &&c, F &&f) noexcept(noexcept(std::is_nothrow_invocable_v< F, decltype(*c.begin())>))
 
template<typename T , template< typename U > class Container, typename F >
Container< T > LC::Util::Filter (const Container< T > &c, F f)
 
template<template< typename > class Container, typename T >
Container< T > LC::Util::Concat (const Container< Container< T >> &containers)
 
template<template< typename... > class Container, typename... ContArgs>
auto LC::Util::Concat (const Container< ContArgs... > &containers) -> std::decay_t< decltype(*containers.begin())>
 
template<typename Cont , typename F >
auto LC::Util::ConcatMap (Cont &&c, F &&f)
 
template<template< typename > class Container, typename T >
Container< Container< T > > LC::Util::SplitInto (size_t numChunks, const Container< T > &container)
 
template<typename Cont >
decltype(auto) LC::Util::Sorted (Cont &&cont)
 
template<typename R >
auto LC::Util::ComparingBy (R r)
 
template<typename R >
auto LC::Util::EqualityBy (R r)
 
template<typename F >
auto LC::Util::First (F &&f)
 
template<typename F >
auto LC::Util::Second (F &&f)
 

Variables

template<typename T >
constexpr bool LC::Util::detail::IsNotBrokenSFINAE_v = IsNotBrokenSFINAE<T> {}
 
constexpr auto LC::Util::Id = [] (auto&& t) -> decltype (auto) { return std::forward<decltype (t)> (t); }
 
constexpr auto LC::Util::Apply = [] (const auto& t) { return t (); }
 
constexpr auto LC::Util::Fst = [] (const auto& pair) { return pair.first; }
 
constexpr auto LC::Util::Snd = [] (const auto& pair) { return pair.second; }