folly::for_each_detail Namespace Reference

Namespaces
	adl

Classes
struct	BeginAddTag
struct	IndexingTag
struct	IsMemberGetFound
struct	IsMemberGetFound< EnableIfMemberGetFound< T >, T >
struct	IsRange
struct	IsRange< EnableIfRange< T >, T >
struct	IsTuple
struct	IsTuple< EnableIfTuple< T >, T >
struct	RangeTag
struct	TupleTag

Typedefs
template<typename T >
using	EnableIfMemberGetFound = void_t< decltype(std::declval< T >().template get< 0 >())>
template<typename Type , typename T = typename std::decay<Type>::type>
using	EnableIfTuple = void_t< decltype(get_impl< 0 >(std::declval< T >())), decltype(std::tuple_size< T >::value)>
template<typename Type , typename T = typename std::decay<Type>::type>
using	EnableIfRange = void_t< decltype(adl::adl_begin(std::declval< T >())), decltype(adl::adl_end(std::declval< T >()))>
template<typename Sequence >
using	SequenceTag = std::conditional_t< IsRange< void, Sequence >::value, RangeTag, TupleTag >
template<typename Func , typename Item , typename Iter >
using	ForEachImplTag = std::conditional_t< is_invocable< Func, Item, index_constant< 0 >, Iter >::value, index_constant< 3 >, std::conditional_t< is_invocable< Func, Item, index_constant< 0 >>::value, index_constant< 2 >, std::conditional_t< is_invocable< Func, Item >::value, index_constant< 1 >, void >>>

Enumerations
enum	LoopControl : bool { LoopControl::BREAK, LoopControl::CONTINUE }

Functions
template<std::size_t Index, typename Type , std::enable_if_t<!IsMemberGetFound< void, Type >::value, int > = 0>
auto	get_impl (Type &&instance) -> decltype(adl::adl_get< Index >(static_cast< Type && >(instance)))
template<typename Func , typename... Args, std::enable_if_t< is_invocable_r< LoopControl, Func, Args... >::value, int > = 0>
LoopControl	invoke_returning_loop_control (Func &&f, Args &&...a)
template<typename Sequence , typename Func >
void	for_each_range_impl (index_constant< 3 >, Sequence &&range, Func &func)
template<typename Sequence , typename Func >
void	for_each_range_impl (index_constant< 2 >, Sequence &&range, Func &func)
template<typename Sequence , typename Func >
void	for_each_range_impl (index_constant< 1 >, Sequence &&range, Func &func)
template<typename Sequence , typename Func , std::size_t... Indices>
void	for_each_tuple_impl (index_sequence< Indices... >, Sequence &&seq, Func &func)
template<typename Sequence , typename Func >
void	for_each_tuple_impl (index_constant< 2 >, Sequence &&seq, Func &func)
template<typename Sequence , typename Func >
void	for_each_tuple_impl (index_constant< 1 >, Sequence &&seq, Func &func)
template<typename Sequence , typename Func >
static void	for_each_impl (TupleTag, Sequence &&range, Func &func)
template<typename Sequence , typename Func >
static void	for_each_impl (RangeTag, Sequence &&range, Func &func)
template<typename Sequence , typename Index >
decltype(auto)	fetch_impl (IndexingTag, Sequence &&sequence, Index &&index)
template<typename Sequence , typename Index >
decltype(auto)	fetch_impl (BeginAddTag, Sequence &&sequence, Index index)
template<typename Sequence , typename Index >
decltype(auto)	fetch_impl (TupleTag, Sequence &&sequence, Index index)
template<typename Sequence , typename Index >
decltype(auto)	fetch_impl (RangeTag, Sequence &&sequence, Index &&index)

Detailed Description

The user should return loop_break and loop_continue if they want to iterate in such a way that they can preemptively stop the loop and break out when certain conditions are met.

Typedef Documentation

template<typename T >

using folly::for_each_detail::EnableIfMemberGetFound = typedef void_t<decltype(std::declval<T>().template get<0>())>

Enable if the tuple supports fetching via a member get<>()

Definition at line 69 of file Foreach-inl.h.

template<typename Type , typename T = typename std::decay<Type>::type>

using folly::for_each_detail::EnableIfRange = typedef void_t< decltype(adl::adl_begin(std::declval<T>())), decltype(adl::adl_end(std::declval<T>()))>

Check if the sequence is a range

Definition at line 115 of file Foreach-inl.h.

template<typename Type , typename T = typename std::decay<Type>::type>

using folly::for_each_detail::EnableIfTuple = typedef void_t< decltype(get_impl<0>(std::declval<T>())), decltype(std::tuple_size<T>::value)>

Check if the sequence is a tuple

Definition at line 103 of file Foreach-inl.h.

template<typename Func , typename Item , typename Iter >

using folly::for_each_detail::ForEachImplTag = typedef std::conditional_t< is_invocable<Func, Item, index_constant<0>, Iter>::value, index_constant<3>, std::conditional_t< is_invocable<Func, Item, index_constant<0>>::value, index_constant<2>, std::conditional_t< is_invocable<Func, Item>::value, index_constant<1>, void>>>

Definition at line 144 of file Foreach-inl.h.

template<typename Sequence >

using folly::for_each_detail::SequenceTag = typedef std::conditional_t<IsRange<void, Sequence>::value, RangeTag, TupleTag>

Should ideally check if it is a tuple and if not return void, but msvc fails

Definition at line 129 of file Foreach-inl.h.

Enumeration Type Documentation

enum folly::for_each_detail::LoopControl : bool

strong

Enumerator
BREAK
CONTINUE

Definition at line 94 of file Foreach.h.

: bool { BREAK, CONTINUE };

Function Documentation

template<typename Sequence , typename Index >

decltype(auto) folly::for_each_detail::fetch_impl	(	IndexingTag	,
		Sequence &&	sequence,
		Index &&	index
	)

Definition at line 286 of file Foreach-inl.h.

Referenced by folly::fetch(), and fetch_impl().

                                                                           {
  return std::forward<Sequence>(sequence)[std::forward<Index>(index)];
}

template<typename Sequence , typename Index >

decltype(auto) folly::for_each_detail::fetch_impl	(	BeginAddTag	,
		Sequence &&	sequence,
		Index	index
	)

Definition at line 290 of file Foreach-inl.h.

References folly::for_each_detail::adl::adl_begin().

                                                                         {
  return *(adl::adl_begin(std::forward<Sequence>(sequence)) + index);
}

template<typename Sequence , typename Index >

decltype(auto) folly::for_each_detail::fetch_impl	(	TupleTag	,
		Sequence &&	sequence,
		Index	index
	)

Definition at line 295 of file Foreach-inl.h.

                                                                      {
  return get_impl<index>(std::forward<Sequence>(sequence));
}

template<typename Sequence , typename Index >

decltype(auto) folly::for_each_detail::fetch_impl	(	RangeTag	,
		Sequence &&	sequence,
		Index &&	index
	)

Definition at line 299 of file Foreach-inl.h.

References folly::for_each_detail::adl::adl_begin(), fetch_impl(), and value.

                                                                        {
  using iter = decltype(adl::adl_begin(std::declval<Sequence>()));
  using iter_traits = std::iterator_traits<remove_cvref_t<iter>>;
  using iter_cat = typename iter_traits::iterator_category;
  using tag = std::conditional_t<
      std::is_same<iter_cat, std::random_access_iterator_tag>::value,
      BeginAddTag,
      IndexingTag>;
  return fetch_impl(
      tag{}, std::forward<Sequence>(sequence), std::forward<Index>(index));
}

template<typename Sequence , typename Func >

static void folly::for_each_detail::for_each_impl ( TupleTag  , Sequence &&  range, Func &  func  )

static

Top level handlers for the for_each loop, with one overload for tuples and one overload for ranges

This implies that if type is both a range and a tuple, it is treated as a range rather than as a tuple

Definition at line 270 of file Foreach-inl.h.

References for_each_tuple_impl(), folly::range(), type, and value.

                                                                  {
  using type = decltype(get_impl<0>(std::declval<Sequence>()));
  using tag = ForEachImplTag<Func, type, void>;
  static_assert(!std::is_same<tag, void>::value, "unknown invocability");
  for_each_tuple_impl(tag{}, std::forward<Sequence>(range), func);
}

template<typename Sequence , typename Func >

static void folly::for_each_detail::for_each_impl ( RangeTag  , Sequence &&  range, Func &  func  )

static

Definition at line 277 of file Foreach-inl.h.

References folly::for_each_detail::adl::adl_begin(), for_each_range_impl(), folly::range(), type, and value.

Referenced by folly::for_each().

                                                                  {
  using iter = decltype(adl::adl_begin(std::declval<Sequence>()));
  using type = decltype(*std::declval<iter>());
  using tag = ForEachImplTag<Func, type, iter>;
  static_assert(!std::is_same<tag, void>::value, "unknown invocability");
  for_each_range_impl(tag{}, std::forward<Sequence>(range), func);
}

template<typename Sequence , typename Func >

void folly::for_each_detail::for_each_range_impl	(	index_constant< 3 >	,
		Sequence &&	range,
		Func &	func
	)

Implementations for the runtime function

Definition at line 170 of file Foreach-inl.h.

References folly::for_each_detail::adl::adl_begin(), folly::for_each_detail::adl::adl_end(), folly::gen::first, invoke_returning_loop_control(), folly::loop_break, cpp.ast::next(), and folly::range().

Referenced by for_each_impl(), and for_each_range_impl().

                                                                          {
  auto first = adl::adl_begin(range);
  auto last = adl::adl_end(range);
  for (auto index = std::size_t{0}; first != last; ++index) {
    auto next = std::next(first);
    auto control = invoke_returning_loop_control(func, *first, index, first);
    if (loop_break == control) {
      break;
    }
    first = next;
  }
}

template<typename Sequence , typename Func >

void folly::for_each_detail::for_each_range_impl	(	index_constant< 2 >	,
		Sequence &&	range,
		Func &	func
	)

Definition at line 183 of file Foreach-inl.h.

References for_each_range_impl(), and folly::range().

                                                                          {
  // make a three arg adaptor for the function passed in so that the main
  // implementation function can be used
  auto three_arg_adaptor = [&func](
                               auto&& ele, auto index, auto) -> decltype(auto) {
    return func(std::forward<decltype(ele)>(ele), index);
  };
  for_each_range_impl(
      index_constant<3>{}, std::forward<Sequence>(range), three_arg_adaptor);
}

template<typename Sequence , typename Func >

void folly::for_each_detail::for_each_range_impl	(	index_constant< 1 >	,
		Sequence &&	range,
		Func &	func
	)

Definition at line 195 of file Foreach-inl.h.

References for_each_range_impl(), and folly::range().

                                                                          {
  // make a three argument adaptor for the function passed in that just ignores
  // the second and third argument
  auto three_arg_adaptor = [&func](auto&& ele, auto, auto) -> decltype(auto) {
    return func(std::forward<decltype(ele)>(ele));
  };
  for_each_range_impl(
      index_constant<3>{}, std::forward<Sequence>(range), three_arg_adaptor);
}

template<typename Sequence , typename Func , std::size_t... Indices>

void folly::for_each_detail::for_each_tuple_impl	(	index_sequence< Indices... >	,
		Sequence &&	seq,
		Func &	func
	)

Handlers for iteration

Definition at line 209 of file Foreach-inl.h.

References testing::_, invoke_returning_loop_control(), folly::loop_continue, and folly::gen::seq().

Referenced by for_each_impl(), and for_each_tuple_impl().

                {
  using _ = int[];

  // unroll the loop in an initializer list construction parameter expansion
  // pack
  auto control = loop_continue;

  // cast to void to ignore the result; use the int[] initialization to do the
  // loop execution, the ternary conditional will decide whether or not to
  // evaluate the result
  //
  // if func does not return loop-control, expect the optimizer to see through
  // invoke_returning_loop_control always returning loop_continue
  void(
      _{(((control == loop_continue)
              ? (control = invoke_returning_loop_control(
                     func,
                     get_impl<Indices>(std::forward<Sequence>(seq)),
                     index_constant<Indices>{}))
              : (loop_continue)),
         0)...});
}

template<typename Sequence , typename Func >

void folly::for_each_detail::for_each_tuple_impl	(	index_constant< 2 >	,
		Sequence &&	seq,
		Func &	func
	)

The two top level compile time loop iteration functions handle the dispatch based on the number of arguments the passed in function can be passed, if 2 arguments can be passed then the implementation dispatches work further to the implementation classes above. If not then an adaptor is constructed which is passed on to the 2 argument specialization, which then in turn forwards implementation to the implementation classes above

Definition at line 244 of file Foreach-inl.h.

References for_each_tuple_impl(), folly::gen::seq(), folly::size(), and type.

                                                                        {
  // pass the length as an index sequence to the implementation as an
  // optimization over manual template "tail recursion" unrolling
  using size = std::tuple_size<typename std::decay<Sequence>::type>;
  for_each_tuple_impl(
      make_index_sequence<size::value>{}, std::forward<Sequence>(seq), func);
}

template<typename Sequence , typename Func >

void folly::for_each_detail::for_each_tuple_impl	(	index_constant< 1 >	,
		Sequence &&	seq,
		Func &	func
	)

Definition at line 252 of file Foreach-inl.h.

References for_each_tuple_impl(), and folly::gen::seq().

                                                                        {
  // make an adaptor for the function passed in, in case it can only be passed
  // on argument
  auto two_arg_adaptor = [&func](auto&& ele, auto) -> decltype(auto) {
    return func(std::forward<decltype(ele)>(ele));
  };
  for_each_tuple_impl(
      index_constant<2>{}, std::forward<Sequence>(seq), two_arg_adaptor);
}

template<std::size_t Index, typename Type , std::enable_if_t<!IsMemberGetFound< void, Type >::value, int > = 0>

auto folly::for_each_detail::get_impl

(

Type &&

instance

)

-> decltype(adl::adl_get<Index>(static_cast<Type&&>(instance)))

A get that tries member get<> first and if that is not found tries ADL get<>. This mechanism is as found in the structured bindings proposal here 11.5.3. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4659.pdf

Definition at line 84 of file Foreach-inl.h.

References type, and value.

                                                                  {
  return adl::adl_get<Index>(static_cast<Type&&>(instance));
}

template<typename Func , typename... Args, std::enable_if_t< is_invocable_r< LoopControl, Func, Args... >::value, int > = 0>

LoopControl folly::for_each_detail::invoke_returning_loop_control	(	Func &&	f,
		Args &&...	a
	)

Definition at line 151 of file Foreach-inl.h.

References a, testing::Args(), f, folly::loop_continue, and folly::value().

Referenced by for_each_range_impl(), and for_each_tuple_impl().

                                                                 {
  return static_cast<Func&&>(f)(static_cast<Args&&>(a)...);
}