fit

Summary

Typedefs
callback using
callback_impl< internal::RoundUpToWord(inline_target_size), false, T, Allocator >
closure using
function< void()>
default_callable_allocator using
std::allocator< std::byte >
deferred_callback using
detected_or using
typename::fit::internal::detector< Default, void, Op, Args...>
detected_or_t using
typename detected_or< Default, Op, Args...>::type
detected_t using
typename::fit::internal::detector< nonesuch, void, Op, Args...>::type
function using
function_impl< internal::RoundUpToWord(inline_target_size), false, T, Allocator >
function_traits using
inline_callback using
callback_impl< internal::RoundUpToWord(inline_target_size), true, T, default_callable_allocator >
inline_function using
function_impl< internal::RoundUpToWord(inline_target_size), true, T, default_callable_allocator >
is_detected using
typename::fit::internal::detector< nonesuch, void, Op, Args...>::value_t
is_detected_convertible using
std::is_convertible< detected_t< Op, Args...>, To >
is_detected_exact using
std::is_same< Expected, detected_t< Op, Args...>>

Functions
FIT_CAPABILITY("mutex") thread_checker final
class
__attribute__((__warn_unused_result__))
as_error(E && error_value)
constexpr error< std::decay_t< E > >
bind_member(T *instance, R(T::*)(Args...) fn)
auto
bind_member(T *instance)
auto
error(T) -> error< T >
is_null(T && value)
constexpr bool
ok(T && value)
constexpr success< std::decay_t< T > >
ok()
constexpr success
operator!=(const deferred_action< T > & action, decltype(nullptr))
bool
operator!=(decltype(nullptr), const deferred_action< T > & action)
bool
operator!=(const function_impl< inline_target_size, require_inline, FunctionType, Allocator > & f, decltype(nullptr))
bool
operator!=(decltype(nullptr), const function_impl< inline_target_size, require_inline, FunctionType, Allocator > & f)
bool
operator!=(const callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & f, decltype(nullptr))
bool
operator!=(decltype(nullptr), const callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & f)
bool
operator!=(const nullable< T > & lhs, decltype(nullptr))
constexpr bool
operator!=(decltype(nullptr), const nullable< T > & rhs)
constexpr bool
operator!=(const nullable< T > & lhs, const nullable< U > & rhs)
constexpr bool
operator!=(const nullable< T > & lhs, const U & rhs)
constexpr bool
operator!=(const T & lhs, const nullable< U > & rhs)
constexpr bool
operator!=(const result< E, Ts...> & lhs, const success<> &)
constexpr bool
operator!=(const success<> &, const result< E, Ts...> & rhs)
constexpr bool
operator!=(const result< E, Ts...> & lhs, failed)
constexpr bool
operator!=(failed, const result< E, Ts...> & rhs)
constexpr bool
operator!=(const result< E, T > & lhs, const result< F, U > & rhs)
constexpr bool
operator!=(const result< E, T > & lhs, const U & rhs)
constexpr bool
operator!=(const T & lhs, const result< F, U > & rhs)
constexpr bool
operator<(const result< E, T > & lhs, const result< F, U > & rhs)
constexpr bool
operator<(const result< E, T > & lhs, const U & rhs)
constexpr bool
operator<(const T & lhs, const result< F, U > & rhs)
constexpr bool
operator<<(std::ostream & out, const std::optional< std::string > & str)
std::ostream &
operator<=(const result< E, T > & lhs, const result< F, U > & rhs)
constexpr bool
operator<=(const result< E, T > & lhs, const U & rhs)
constexpr bool
operator<=(const T & lhs, const result< F, U > & rhs)
constexpr bool
operator==(const deferred_action< T > & action, decltype(nullptr))
bool
operator==(decltype(nullptr), const deferred_action< T > & action)
bool
operator==(const function_impl< inline_target_size, require_inline, FunctionType, Allocator > & f, decltype(nullptr))
bool
operator==(decltype(nullptr), const function_impl< inline_target_size, require_inline, FunctionType, Allocator > & f)
bool
operator==(const callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & f, decltype(nullptr))
bool
operator==(decltype(nullptr), const callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & f)
bool
operator==(const nullable< T > & lhs, decltype(nullptr))
constexpr bool
operator==(decltype(nullptr), const nullable< T > & rhs)
constexpr bool
operator==(const nullable< T > & lhs, const nullable< U > & rhs)
constexpr bool
operator==(const nullable< T > & lhs, const U & rhs)
constexpr bool
operator==(const T & lhs, const nullable< U > & rhs)
constexpr bool
operator==(const result< E, Ts...> & lhs, const success<> &)
constexpr bool
operator==(const success<> &, const result< E, Ts...> & rhs)
constexpr bool
operator==(const result< E, Ts...> & lhs, failed)
constexpr bool
operator==(failed, const result< E, Ts...> & rhs)
constexpr bool
operator==(const result< E, T > & lhs, const result< F, U > & rhs)
constexpr bool
operator==(const result< E, T > & lhs, const U & rhs)
constexpr bool
operator==(const T & lhs, const result< F, U > & rhs)
constexpr bool
operator>(const result< E, T > & lhs, const result< F, U > & rhs)
constexpr bool
operator>(const result< E, T > & lhs, const U & rhs)
constexpr bool
operator>(const T & lhs, const result< F, U > & rhs)
constexpr bool
operator>=(const result< E, T > & lhs, const result< F, U > & rhs)
constexpr bool
operator>=(const result< E, T > & lhs, const U & rhs)
constexpr bool
operator>=(const T & lhs, const result< F, U > & rhs)
constexpr bool
result(typename Tag::__allow_ctad...) -> result< Tag...>
success() -> success<>
success(T) -> success< T >
swap(function_impl< inline_target_size, require_inline, FunctionType, Allocator > & a, function_impl< inline_target_size, require_inline, FunctionType, Allocator > & b)
void
swap(callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & a, callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & b)
void
swap(nullable< T > & a, nullable< T > & b)
void
swap(result< E, Ts...> & r, result< E, Ts...> & s)
constexpr void

Classes
fit::callback_impl
fit::callback_impl< inline_target_size, require_inline, Result(Args...), Allocator >
fit::deferred_action
fit::function_impl
fit::function_impl< inline_target_size, require_inline, Result(Args...), Allocator >
fit::inline_any
fit::nullable
fit::nullable< T, true >
fit::pinned_inline_any
fit::result< E >
fit::result< E, T >
fit::success< T >
fit::success<>

Structs
fit::callable_traits
fit::callable_traits< ReturnType(*)(ArgTypes...)>
fit::callable_traits< ReturnType(ArgTypes...)>
fit::callable_traits< ReturnType(FunctorType::*)(ArgTypes...) const >
fit::callable_traits< ReturnType(FunctorType::*)(ArgTypes...)>
fit::failed
fit::is_callable
fit::is_callable< ReturnType(*)(ArgTypes...)>
fit::is_callable< ReturnType(FunctorType::*)(ArgTypes...)>
fit::is_callable< T, std::void_t< decltype(&T::operator())> >
fit::is_comparable_with_null
fit::is_comparable_with_null< T, decltype(std::declval< const T & >()==nullptr)>
fit::is_nullable
fit::is_nullable< void >
fit::nonesuch
fit::parameter_pack

Typedefs

callback

callback_impl< internal::RoundUpToWord(inline_target_size), false, T, Allocator > callback

closure

function< void()> closure

default_callable_allocator

std::allocator< std::byte > default_callable_allocator

deferred_callback

deferred_action< fit::callback< void()>> deferred_callback

detected_or

typename::fit::internal::detector< Default, void, Op, Args...> detected_or

detected_or_t

typename detected_or< Default, Op, Args...>::type detected_or_t

detected_t

typename::fit::internal::detector< nonesuch, void, Op, Args...>::type detected_t

function

function_impl< internal::RoundUpToWord(inline_target_size), false, T, Allocator > function

function_traits

callable_traits< T > function_traits

inline_callback

callback_impl< internal::RoundUpToWord(inline_target_size), true, T, default_callable_allocator > inline_callback

inline_function

function_impl< internal::RoundUpToWord(inline_target_size), true, T, default_callable_allocator > inline_function

is_detected

typename::fit::internal::detector< nonesuch, void, Op, Args...>::value_t is_detected

is_detected_convertible

std::is_convertible< detected_t< Op, Args...>, To > is_detected_convertible

is_detected_exact

std::is_same< Expected, detected_t< Op, Args...>> is_detected_exact

Functions

FIT_CAPABILITY

class FIT_CAPABILITY(  "mutex" ) thread_checker final

__attribute__

 __attribute__(  (__warn_unused_result__) )

as_error

constexpr error< std::decay_t< E > > as_error(  E && error_value )

bind_member

auto bind_member(  T *instance,  R(T::*)(Args...) fn )

bind_member

auto bind_member(  T *instance )

error

 error(  T ) -> error< T >

is_null

constexpr bool is_null(  T && value )

ok

constexpr success< std::decay_t< T > > ok(  T && value )

ok

constexpr success ok()

operator!=

bool operator!=(  const deferred_action< T > & action,  decltype(nullptr) )

operator!=

bool operator!=(  decltype(nullptr),  const deferred_action< T > & action )

operator!=

bool operator!=(  const function_impl< inline_target_size, require_inline, FunctionType, Allocator > & f,  decltype(nullptr) )

operator!=

bool operator!=(  decltype(nullptr),  const function_impl< inline_target_size, require_inline, FunctionType, Allocator > & f )

operator!=

bool operator!=(  const callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & f,  decltype(nullptr) )

operator!=

bool operator!=(  decltype(nullptr),  const callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & f )

operator!=

constexpr bool operator!=(  const nullable< T > & lhs,  decltype(nullptr) )

operator!=

constexpr bool operator!=(  decltype(nullptr),  const nullable< T > & rhs )

operator!=

constexpr bool operator!=(  const nullable< T > & lhs,  const nullable< U > & rhs )

operator!=

constexpr bool operator!=(  const nullable< T > & lhs,  const U & rhs )

operator!=

constexpr bool operator!=(  const T & lhs,  const nullable< U > & rhs )

operator!=

constexpr bool operator!=(  const result< E, Ts...> & lhs,  const success<> & )

operator!=

constexpr bool operator!=(  const success<> &,  const result< E, Ts...> & rhs )

operator!=

constexpr bool operator!=(  const result< E, Ts...> & lhs,  failed )

operator!=

constexpr bool operator!=(  failed,  const result< E, Ts...> & rhs )

operator!=

constexpr bool operator!=(  const result< E, T > & lhs,  const result< F, U > & rhs )

operator!=

constexpr bool operator!=(  const result< E, T > & lhs,  const U & rhs )

operator!=

constexpr bool operator!=(  const T & lhs,  const result< F, U > & rhs )

operator<

constexpr bool operator<(  const result< E, T > & lhs,  const result< F, U > & rhs )

operator<

constexpr bool operator<(  const result< E, T > & lhs,  const U & rhs )

operator<

constexpr bool operator<(  const T & lhs,  const result< F, U > & rhs )

operator<<

std::ostream & operator<<(  std::ostream & out,  const std::optional< std::string > & str )

operator<=

constexpr bool operator<=(  const result< E, T > & lhs,  const result< F, U > & rhs )

operator<=

constexpr bool operator<=(  const result< E, T > & lhs,  const U & rhs )

operator<=

constexpr bool operator<=(  const T & lhs,  const result< F, U > & rhs )

operator==

bool operator==(  const deferred_action< T > & action,  decltype(nullptr) )

operator==

bool operator==(  decltype(nullptr),  const deferred_action< T > & action )

operator==

bool operator==(  const function_impl< inline_target_size, require_inline, FunctionType, Allocator > & f,  decltype(nullptr) )

operator==

bool operator==(  decltype(nullptr),  const function_impl< inline_target_size, require_inline, FunctionType, Allocator > & f )

operator==

bool operator==(  const callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & f,  decltype(nullptr) )

operator==

bool operator==(  decltype(nullptr),  const callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & f )

operator==

constexpr bool operator==(  const nullable< T > & lhs,  decltype(nullptr) )

operator==

constexpr bool operator==(  decltype(nullptr),  const nullable< T > & rhs )

operator==

constexpr bool operator==(  const nullable< T > & lhs,  const nullable< U > & rhs )

operator==

constexpr bool operator==(  const nullable< T > & lhs,  const U & rhs )

operator==

constexpr bool operator==(  const T & lhs,  const nullable< U > & rhs )

operator==

constexpr bool operator==(  const result< E, Ts...> & lhs,  const success<> & )

operator==

constexpr bool operator==(  const success<> &,  const result< E, Ts...> & rhs )

operator==

constexpr bool operator==(  const result< E, Ts...> & lhs,  failed )

operator==

constexpr bool operator==(  failed,  const result< E, Ts...> & rhs )

operator==

constexpr bool operator==(  const result< E, T > & lhs,  const result< F, U > & rhs )

operator==

constexpr bool operator==(  const result< E, T > & lhs,  const U & rhs )

operator==

constexpr bool operator==(  const T & lhs,  const result< F, U > & rhs )

operator>

constexpr bool operator>(  const result< E, T > & lhs,  const result< F, U > & rhs )

operator>

constexpr bool operator>(  const result< E, T > & lhs,  const U & rhs )

operator>

constexpr bool operator>(  const T & lhs,  const result< F, U > & rhs )

operator>=

constexpr bool operator>=(  const result< E, T > & lhs,  const result< F, U > & rhs )

operator>=

constexpr bool operator>=(  const result< E, T > & lhs,  const U & rhs )

operator>=

constexpr bool operator>=(  const T & lhs,  const result< F, U > & rhs )

result

 result(  typename Tag::__allow_ctad... ) -> result< Tag...>

success

 success() -> success<>

success

 success(  T ) -> success< T >

swap

void swap(  function_impl< inline_target_size, require_inline, FunctionType, Allocator > & a,  function_impl< inline_target_size, require_inline, FunctionType, Allocator > & b )

swap

void swap(  callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & a,  callback_impl< inline_target_size, require_inline, FunctionType, Allocator > & b )

swap

void swap(  nullable< T > & a,  nullable< T > & b )

swap

constexpr void swap(  result< E, Ts...> & r,  result< E, Ts...> & s )