Utility.h File Reference

#include <cstdint>
#include <limits>
#include <type_traits>
#include <utility>
#include <folly/CPortability.h>
#include <folly/Traits.h>

Go to the source code of this file.

Classes
struct	folly::utility_detail::make_seq_cat<... >
struct	folly::utility_detail::make_seq_cat< S< T, Ta... >, S< T, Tb... >, S< T, Tc... > >
struct	folly::utility_detail::make_seq< Size >
struct	folly::utility_detail::make_seq< 1 >
struct	folly::utility_detail::make_seq< 0 >
struct	folly::integer_sequence< T, Ints >
struct	folly::in_place_tag
struct	folly::in_place_type_tag< class >
struct	folly::in_place_index_tag< size_t >
struct	folly::initlist_construct_t
struct	folly::presorted_t
struct	folly::unsorted_t
struct	folly::transparent< T >
struct	folly::Identity
class	folly::moveonly_::MoveOnly

Namespaces
	folly
	—— Concurrent Priority Queue Implementation ——
	folly::utility_detail
	folly::moveonly_

Typedefs
template<std::size_t... Ints>
using	folly::index_sequence = integer_sequence< std::size_t, Ints... >
template<typename T , std::size_t Size>
using	folly::make_integer_sequence = typename utility_detail::make_seq< Size >::template apply< integer_sequence< T >, integer_sequence< T, 0 >>
template<std::size_t Size>
using	folly::make_index_sequence = make_integer_sequence< std::size_t, Size >
template<class... T>
using	folly::index_sequence_for = make_index_sequence< sizeof...(T)>
using	folly::in_place_t = in_place_tag(&)(in_place_tag)
template<class T >
using	folly::in_place_type_t = in_place_type_tag< T >(&)(in_place_type_tag< T >)
template<std::size_t I>
using	folly::in_place_index_t = in_place_index_tag< I >(&)(in_place_index_tag< I >)
using	folly::MoveOnly = moveonly_::MoveOnly

Functions
template<typename T >
constexpr std::decay< T >::type	folly::copy (T &&value) noexcept(noexcept(typename std::decay< T >::type(std::forward< T >(value))))
template<class T >
constexpr T const &	folly::as_const (T &t) noexcept
template<class T >
void	folly::as_const (T const &&)=delete
template<typename Src , typename Dst >
constexpr like_t< Src, Dst > &&	folly::forward_like (Dst &&dst) noexcept
template<class T , class U = T>
T	folly::exchange (T &obj, U &&new_value)
in_place_tag	folly::in_place (in_place_tag={})
template<class T >
in_place_type_tag< T >	folly::in_place_type (in_place_type_tag< T >={})
template<std::size_t I>
in_place_index_tag< I >	folly::in_place_index (in_place_index_tag< I >={})
template<typename T >
constexpr auto	folly::to_signed (T const &t) -> typename std::make_signed< T >::type
template<typename T >
constexpr auto	folly::to_unsigned (T const &t) -> typename std::make_unsigned< T >::type

Variables
constexpr initlist_construct_t	folly::initlist_construct {}
constexpr presorted_t	folly::presorted {}
constexpr unsorted_t	folly::unsorted {}