Variant::detail Namespace Reference

Classes
struct	type_identity
	Standard in C++20. More...
struct	VisitHelperReturn
	Help to define Visit() below. More...

Typedefs
template<typename T >
using	deduced_variant = typename decltype(deduce_variant(std::declval< T >()))::type

Functions
template<typename Visitor , typename Variant >
auto	VisitHelperBad (Visitor &&, Variant &&) -> typename VisitHelperReturn< Visitor &&, Variant && >::type
	Help to define Visit() below. More...
template<size_t Index, typename Visitor , typename Variant >
decltype(auto)	VisitHelperFunction (Visitor &&vis, Variant &&var)
	Help to define Visit() below. More...
template<size_t Index, typename Visitor , typename Variant >
auto	TypeCheckedVisitHelperFunction (Visitor &&vis, Variant &&var) -> typename VisitHelperReturn< Visitor &&, Variant && >::type
	Help to define Visit() below. More...
template<size_t... Indices, typename Visitor , typename Variant >
decltype(auto)	VisitHelper (std::index_sequence< Indices... >, Visitor &&vis, Variant &&var)
	Help to define Visit() below. More...
auto	deduce_variant (...) -> void
	Unevaluated. More...
template<typename... Types>
auto	deduce_variant (std::variant< Types... > &v) -> type_identity< std::remove_reference_t< decltype(v)> >
template<typename... Types>
auto	deduce_variant (std::variant< Types... > &&v) -> type_identity< std::remove_reference_t< decltype(v)> >
template<typename... Types>
auto	deduce_variant (const std::variant< Types... > &v) -> type_identity< std::remove_reference_t< decltype(v)> >
template<typename... Types>
auto	deduce_variant (const std::variant< Types... > &&v) -> type_identity< std::remove_reference_t< decltype(v)> >
template<typename ForwardType , typename Variant >
decltype(auto)	forward_variant (Variant &var)
template<typename ForwardType , typename Variant >
decltype(auto)	forward_variant (const Variant &var)

Typedef Documentation

deduced_variant

template<typename T >

using Variant::detail::deduced_variant = typedef typename decltype(deduce_variant(std::declval<T>()))::type

Definition at line 116 of file Variant.h.

Function Documentation

deduce_variant() [1/5]

auto Variant::detail::deduce_variant

(

...

)

-> void

Unevaluated.

deduce_variant() [2/5]

template<typename... Types>

auto Variant::detail::deduce_variant

(

const std::variant< Types... > &&

v

)

-> type_identity< std::remove_reference_t< decltype(v)> >

deduce_variant() [3/5]

template<typename... Types>

auto Variant::detail::deduce_variant

(

const std::variant< Types... > &

v

)

-> type_identity< std::remove_reference_t< decltype(v)> >

deduce_variant() [4/5]

template<typename... Types>

auto Variant::detail::deduce_variant

(

std::variant< Types... > &&

v

)

-> type_identity< std::remove_reference_t< decltype(v)> >

deduce_variant() [5/5]

template<typename... Types>

auto Variant::detail::deduce_variant

(

std::variant< Types... > &

v

)

-> type_identity< std::remove_reference_t< decltype(v)> >

forward_variant() [1/2]

template<typename ForwardType , typename Variant >

decltype(auto) Variant::detail::forward_variant

(

const Variant &

var

)

Definition at line 125 of file Variant.h.

                                                   {
   return std::forward<ForwardType>(var);
}

forward_variant() [2/2]

template<typename ForwardType , typename Variant >

decltype(auto) Variant::detail::forward_variant

(

Variant &

var

)

Definition at line 120 of file Variant.h.

                                             {
   return std::forward<ForwardType>(var);
   
}

TypeCheckedVisitHelperFunction()

template<size_t Index, typename Visitor , typename Variant >

auto Variant::detail::TypeCheckedVisitHelperFunction	(	Visitor &&	vis,
		Variant &&	var
	)		-> typename VisitHelperReturn<Visitor&&, Variant&&>::type

Help to define Visit() below.

Definition at line 68 of file Variant.h.

{
   static_assert(std::is_same_v<
      typename VisitHelperReturn<Visitor&&, Variant&&>::type,
      std::invoke_result_t<
         decltype(VisitHelperFunction<Index, Visitor&&, Variant&&>),
         Visitor &&, Variant &&>
   >,
   "Visitor must return the same type for all alternatives of the Variant.");
   return VisitHelperFunction<Index>(
      std::forward<Visitor>(vis), std::forward<Variant>(var));
}

VisitHelper()

template<size_t... Indices, typename Visitor , typename Variant >

decltype(auto) Variant::detail::VisitHelper	(	std::index_sequence< Indices... >	,
		Visitor &&	vis,
		Variant &&	var
	)

Help to define Visit() below.

Definition at line 85 of file Variant.h.

{
   constexpr auto size = sizeof...(Indices);
   using Return = typename VisitHelperReturn<Visitor&&, Variant&&>::type;
   using Function = Return(*)(Visitor&&, Variant&&);
   static constexpr std::array<Function, size + 1> jumpTable{
      TypeCheckedVisitHelperFunction<Indices>...,
      VisitHelperBad
   };
   auto function = jumpTable[std::min(var.index(), size)];
   return function(std::forward<Visitor>(vis), std::forward<Variant>(var));
}

References min(), size, and VisitHelperBad().

Referenced by Variant::Visit().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitHelperBad()

template<typename Visitor , typename Variant >

auto Variant::detail::VisitHelperBad	(	Visitor &&	,
		Variant &&
	)		-> typename VisitHelperReturn<Visitor&&, Variant&&>::type

Help to define Visit() below.

Definition at line 44 of file Variant.h.

{
   // Fall through here when the variant holds no value
   // Should really throw std::bad_variant_access but that may not be available
   throw std::invalid_argument{"Bad variant"};
}

Referenced by VisitHelper().

Here is the caller graph for this function:

VisitHelperFunction()

template<size_t Index, typename Visitor , typename Variant >

decltype(auto) Variant::detail::VisitHelperFunction	(	Visitor &&	vis,
		Variant &&	var
	)

Help to define Visit() below.

Definition at line 54 of file Variant.h.

{
   // Invoke vis at most once
   const auto pValue = std::get_if<Index>(&var);
   // Trust VisitHelper to dispatch correctly
   assert(pValue);
   if constexpr (std::is_lvalue_reference_v<Variant>)
      return std::invoke(std::forward<Visitor>(vis), (*pValue));
   else
      return std::invoke(std::forward<Visitor>(vis), std::move(*pValue));
}