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
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 cpp17::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...>
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, cpp17::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
)

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 cpp17::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...>

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
)