fc::detail Namespace Reference

Classes
struct	actor_member
struct	actor_vtable_visitor
struct	add
struct	add_eq
class	any_api
class	appender_factory_impl
class	average_rate_meter
class	buffered_istream_impl
class	buffered_ostream_impl
class	callback_functor
class	callback_functor< void(Args...)>
struct	extract_op
class	gntp_icon_impl
class	gntp_notifier_impl
struct	insert_op
struct	is_operation_shorter
class	log_context_impl
class	log_message_impl
class	mmap_struct_base
class	ntp_impl
class	path_wrapper
class	pke_impl
class	rate_limited_operation
class	rate_limited_tcp_read_operation
class	rate_limited_tcp_write_operation
class	rate_limiting_group_impl
struct	sub
struct	sub_eq
struct	supports_allocator
class	url_impl

Typedefs
using	unique_file = std::unique_ptr<FILE, decltype( &fclose )>

Functions
template<template< typename... > class Set, typename T , typename... U>
void	to_variant_from_set (const Set< T, U... > &s, fc::variant &vo)
template<template< typename... > class Set, typename T , typename... U>
void	from_variant_to_set (const fc::variant &v, Set< T, U... > &s)
template<template< typename... > class Set, typename T , typename... U>
void	from_variant_to_flat_set (const fc::variant &v, Set< T, U... > &s)
template<template< typename... > class Map, typename K , typename V , typename... U>
void	to_variant_from_map (const Map< K, V, U... > &m, fc::variant &vo)
template<template< typename... > class Map, typename K , typename V , typename... U>
void	from_variant_to_map (const variant &v, Map< K, V, U... > &m)
template<template< typename... > class Map, typename K , typename V , typename... U>
void	from_variant_to_flat_map (const variant &v, Map< K, V, U... > &m)
NO_RETURN void	throw_datastream_range_error (const char *file, size_t len, int64_t over)
template<typename R , typename Arg0 , typename ... Args>
std::function< R(Args...)>	bind_first_arg (const std::function< R(Arg0, Args...)> &f, Arg0 a0)
template<typename R >
R	call_generic (const std::function< R()> &f, variants::const_iterator a0, variants::const_iterator e)
template<typename R , typename Arg0 , typename ... Args>
R	call_generic (const std::function< R(Arg0, Args...)> &f, variants::const_iterator a0, variants::const_iterator e)
template<typename R , typename ... Args>
std::function< variant(const fc::variants &)>	to_generic (const std::function< R(Args...)> &f)
template<typename ... Args>
std::function< variant(const fc::variants &)>	to_generic (const std::function< void(Args...)> &f)
template<typename T >
fc::true_type	is_class_helper (void(T::*)())
template<typename T , typename A , typename... Args>
auto	construct_maybe_with_allocator (A &&allocator, Args &&... args) -> std::enable_if_t< supports_allocator< T, A >::value &&supports_allocator< T, A >::leading_allocator, T >
template<typename T , typename A , typename... Args>
auto	maybe_augment_constructor_arguments_with_allocator (A &&allocator, std::tuple< Args &&... > args, std::enable_if_t< supports_allocator< T, A >::value &&supports_allocator< T, A >::leading_allocator, int >=0)
template<typename T , typename A , typename... Args>
auto	maybe_augment_constructor_arguments_with_allocator (A &&allocator, std::tuple<>, std::enable_if_t< supports_allocator< T, A >::value &&supports_allocator< T, A >::leading_allocator, int >=0)
template<typename T , typename A , typename... Args>
auto	maybe_augment_constructor_arguments_with_allocator (A &&allocator, std::tuple< Args &&... > args, std::enable_if_t< supports_allocator< T, A >::value &&!supports_allocator< T, A >::leading_allocator, int >=0)
template<typename T , typename A , typename... Args>
auto	maybe_augment_constructor_arguments_with_allocator (A &&allocator, std::tuple<>, std::enable_if_t< supports_allocator< T, A >::value &&!supports_allocator< T, A >::leading_allocator, int >=0)
template<typename T , typename A , typename... Args>
auto	maybe_augment_constructor_arguments_with_allocator (A &&, std::tuple< Args &&... > args, std::enable_if_t<!supports_allocator< T, A >::value, int >=0)
template<typename T1 , typename T2 , typename A >
std::pair< T1, T2 >	default_construct_pair_maybe_with_allocator (A &&allocator)
void	shift_l (const char *in, char *out, std::size_t n, unsigned int i)
void	shift_r (const char *in, char *out, std::size_t n, unsigned int i)
boost::asio::ip::udp::endpoint	to_asio_ep (const fc::ip::endpoint &e)

Variables
template<typename T >
fc::false_type	is_class_helper (...)
bool	have_so_reuseport = true

Typedef Documentation

unique_file

using fc::detail::unique_file = std::unique_ptr<FILE, decltype( &fclose )>

Definition at line 22 of file cfile.hpp.

Function Documentation

bind_first_arg()

template<typename R , typename Arg0 , typename ... Args>

std::function< R(Args...)> fc::detail::bind_first_arg	(	const std::function< R(Arg0, Args...)> &	f,
		Arg0	a0 )

Definition at line 33 of file api_connection.hpp.

      {
         return [=]( Args... args ) { return f( a0, args... ); };
      }

Here is the caller graph for this function:

call_generic() [1/2]

template<typename R >

R fc::detail::call_generic	(	const std::function< R()> &	f,
		variants::const_iterator	a0,
		variants::const_iterator	e )

Definition at line 38 of file api_connection.hpp.

      {
         return f();
      }

Here is the caller graph for this function:

call_generic() [2/2]

template<typename R , typename Arg0 , typename ... Args>

R fc::detail::call_generic	(	const std::function< R(Arg0, Args...)> &	f,
		variants::const_iterator	a0,
		variants::const_iterator	e )

Definition at line 44 of file api_connection.hpp.

      {
         FC_ASSERT( a0 != e );
         return  call_generic<R,Args...>( bind_first_arg<R,Arg0,Args...>( f, a0->as< typename std::decay<Arg0>::type >() ), a0+1, e );
      }

Here is the call graph for this function:

construct_maybe_with_allocator()

template<typename T , typename A , typename... Args>

auto fc::detail::construct_maybe_with_allocator	(	A &&	allocator,
		Args &&...	args ) -> std::enable_if_t<supports_allocator<T, A>::value && supports_allocator<T, A>::leading_allocator, T>

Definition at line 60 of file utility.hpp.

      {
         return T( std::allocator_arg, std::forward<A>(allocator), std::forward<Args>(args)... );
      }

Here is the caller graph for this function:

default_construct_pair_maybe_with_allocator()

template<typename T1 , typename T2 , typename A >

std::pair< T1, T2 > fc::detail::default_construct_pair_maybe_with_allocator

(

A &&

allocator

)

Definition at line 124 of file utility.hpp.

      {
         return std::pair<T1,T2>(
            std::piecewise_construct,
            maybe_augment_constructor_arguments_with_allocator<T1>( allocator, std::make_tuple() ),
            maybe_augment_constructor_arguments_with_allocator<T2>( allocator, std::make_tuple() )
         );
      }

Here is the call graph for this function:

Here is the caller graph for this function:

from_variant_to_flat_map()

template<template< typename... > class Map, typename K , typename V , typename... U>

void fc::detail::from_variant_to_flat_map	(	const variant &	v,
		Map< K, V, U... > &	m )

Definition at line 146 of file container_detail.hpp.

                                                                            {
         const variants& vars = v.get_array();
         FC_ASSERT( vars.size() <= MAX_NUM_ARRAY_ELEMENTS );
         m.clear();
         m.reserve( vars.size() );
         for( const auto& var : vars ) {
            auto item = default_construct_pair_maybe_with_allocator<K, V>( m.get_allocator() );
            var.as< std::pair<K,V> >( item );
            m.insert( m.end(), std::move(item) );
         }
      }

Here is the call graph for this function:

Here is the caller graph for this function:

from_variant_to_flat_set()

template<template< typename... > class Set, typename T , typename... U>

void fc::detail::from_variant_to_flat_set	(	const fc::variant &	v,
		Set< T, U... > &	s )

Definition at line 110 of file container_detail.hpp.

                                                                             {
         const variants& vars = v.get_array();
         FC_ASSERT( vars.size() <= MAX_NUM_ARRAY_ELEMENTS );
         s.clear();
         s.reserve( vars.size() );
         for( const auto& var : vars ) {
            auto item = construct_maybe_with_allocator<T>( s.get_allocator() );
            var.as<T>( item );
            s.insert( s.end(), std::move(item) );
         }
      }

Here is the call graph for this function:

Here is the caller graph for this function:

from_variant_to_map()

template<template< typename... > class Map, typename K , typename V , typename... U>

void fc::detail::from_variant_to_map	(	const variant &	v,
		Map< K, V, U... > &	m )

Definition at line 134 of file container_detail.hpp.

                                                                       {
         const variants& vars = v.get_array();
         FC_ASSERT( vars.size() <= MAX_NUM_ARRAY_ELEMENTS );
         m.clear();
         for( const auto& var : vars ) {
            auto item = default_construct_pair_maybe_with_allocator<K, V>( m.get_allocator() );
            var.as< std::pair<K,V> >( item );
            m.insert( m.end(), std::move(item) );
         }
      }

Here is the call graph for this function:

Here is the caller graph for this function:

from_variant_to_set()

template<template< typename... > class Set, typename T , typename... U>

void fc::detail::from_variant_to_set	(	const fc::variant &	v,
		Set< T, U... > &	s )

Definition at line 98 of file container_detail.hpp.

                                                                        {
         const variants& vars = v.get_array();
         FC_ASSERT( vars.size() <= MAX_NUM_ARRAY_ELEMENTS );
         s.clear();
         for( const auto& var : vars ) {
            auto item = construct_maybe_with_allocator<T>( s.get_allocator() );
            var.as<T>( item );
            s.insert( s.end(), std::move(item) );
         }
      }

Here is the call graph for this function:

Here is the caller graph for this function:

is_class_helper()

template<typename T >

fc::true_type fc::detail::is_class_helper

(

void(T::*

)()

)

maybe_augment_constructor_arguments_with_allocator() [1/5]

template<typename T , typename A , typename... Args>

auto fc::detail::maybe_augment_constructor_arguments_with_allocator	(	A &&	,
		std::tuple< Args &&... >	args,
		std::enable_if_t<!supports_allocator< T, A >::value, int >	= 0 )

Definition at line 116 of file utility.hpp.

        {
         return args;
      }

maybe_augment_constructor_arguments_with_allocator() [2/5]

template<typename T , typename A , typename... Args>

auto fc::detail::maybe_augment_constructor_arguments_with_allocator	(	A &&	allocator,
		std::tuple< Args &&... >	args,
		std::enable_if_t< supports_allocator< T, A >::value &&!supports_allocator< T, A >::leading_allocator, int >	= 0 )

Definition at line 98 of file utility.hpp.

        {
         static_assert( supports_allocator<T, A>::trailing_allocator, "type supposedly supports allocators but cannot be constructed by either the leading- or trailing-allocator convention" );
         return std::tuple_cat( args, std::forward_as_tuple<A>( allocator ) );
      }

maybe_augment_constructor_arguments_with_allocator() [3/5]

template<typename T , typename A , typename... Args>

auto fc::detail::maybe_augment_constructor_arguments_with_allocator	(	A &&	allocator,
		std::tuple< Args &&... >	args,
		std::enable_if_t< supports_allocator< T, A >::value &&supports_allocator< T, A >::leading_allocator, int >	= 0 )

Definition at line 82 of file utility.hpp.

        {
         return std::tuple_cat( std::forward_as_tuple<std::allocator_arg_t, A>( std::allocator_arg, allocator ), args );
      }

Here is the caller graph for this function:

maybe_augment_constructor_arguments_with_allocator() [4/5]

template<typename T , typename A , typename... Args>

auto fc::detail::maybe_augment_constructor_arguments_with_allocator	(	A &&	allocator,
		std::tuple<>	,
		std::enable_if_t< supports_allocator< T, A >::value &&!supports_allocator< T, A >::leading_allocator, int >	= 0 )

Definition at line 107 of file utility.hpp.

        {
         static_assert( supports_allocator<T, A>::trailing_allocator, "type supposedly supports allocators but cannot be constructed by either the leading- or trailing-allocator convention" );
         return std::forward_as_tuple<A>( allocator );
      }

maybe_augment_constructor_arguments_with_allocator() [5/5]

template<typename T , typename A , typename... Args>

auto fc::detail::maybe_augment_constructor_arguments_with_allocator	(	A &&	allocator,
		std::tuple<>	,
		std::enable_if_t< supports_allocator< T, A >::value &&supports_allocator< T, A >::leading_allocator, int >	= 0 )

Definition at line 90 of file utility.hpp.

        {
         return std::forward_as_tuple<std::allocator_arg_t, A>( std::allocator_arg, allocator );
      }

shift_l()

void fc::detail::shift_l	(	const char *	in,
		char *	out,
		std::size_t	n,
		unsigned int	i )

Definition at line 14 of file _digest_common.cpp.

                                                                          {
        const uint8_t* in8 = (uint8_t*) in;
        uint8_t* out8 = (uint8_t*) out;
 
        if (i >= 8) {
            shift_l( in8, out8, n, i / 8 );
            i &= 7;
            in8 = out8;
        }
 
        std::size_t p;
        for( p = 0; p < n-1; ++p )
            out8[p] = (in8[p] << i) | (in8[p+1]>>(8-i));
        out8[p] = in8[p] << i;
    }

shift_r()

void fc::detail::shift_r	(	const char *	in,
		char *	out,
		std::size_t	n,
		unsigned int	i )

Definition at line 38 of file _digest_common.cpp.

                                                                          {
        const uint8_t* in8 = (uint8_t*) in;
        uint8_t* out8 = (uint8_t*) out;
 
        if (i >= 8) {
            shift_r( in8, out8, n, i / 8 );
            i &= 7;
            in8 = out8;
        }
 
        std::size_t p;
        for( p = n-1; p > 0; --p )
            out8[p] = (in8[p] >> i) | (in8[p-1]<<(8-i));
        out8[p] = in8[p] >> i;
    }

throw_datastream_range_error()

NO_RETURN void fc::detail::throw_datastream_range_error	(	const char *	file,
		size_t	len,
		int64_t	over )

Definition at line 4 of file datastream.cpp.

{
  FC_THROW_EXCEPTION( out_of_range_exception, "${method} datastream of length ${len} over by ${over}", ("method",fc::string(method))("len",len)("over",over) );
}

Here is the caller graph for this function:

to_asio_ep()

boost::asio::ip::udp::endpoint fc::detail::to_asio_ep

(

const fc::ip::endpoint &

e

)

Definition at line 23 of file gelf_appender.cpp.

    {
      return boost::asio::ip::udp::endpoint(boost::asio::ip::address_v4(e.get_address()), e.port() );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

to_generic() [1/2]

template<typename R , typename ... Args>

std::function< variant(const fc::variants &)> fc::detail::to_generic

(

const std::function< R(Args...)> &

f

)

Definition at line 51 of file api_connection.hpp.

      {
         return [=]( const variants& args ) { 
            return variant( call_generic( f, args.begin(), args.end() ) ); 
         };
      }

Here is the call graph for this function:

Here is the caller graph for this function:

to_generic() [2/2]

template<typename ... Args>

std::function< variant(const fc::variants &)> fc::detail::to_generic

(

const std::function< void(Args...)> &

f

)

Definition at line 59 of file api_connection.hpp.

      {
         return [=]( const variants& args ) { 
            call_generic( f, args.begin(), args.end() ); 
            return variant();
         };
      }

Here is the call graph for this function:

to_variant_from_map()

template<template< typename... > class Map, typename K , typename V , typename... U>

void fc::detail::to_variant_from_map	(	const Map< K, V, U... > &	m,
		fc::variant &	vo )

Definition at line 123 of file container_detail.hpp.

                                                                            {
         FC_ASSERT( m.size() <= MAX_NUM_ARRAY_ELEMENTS );
         variants vars;
         vars.reserve( m.size() );
         for( const auto& item : m ) {
            vars.emplace_back( item );
         }
         vo = std::move( vars );
      }

Here is the caller graph for this function:

to_variant_from_set()

template<template< typename... > class Set, typename T , typename... U>

void fc::detail::to_variant_from_set	(	const Set< T, U... > &	s,
		fc::variant &	vo )

Definition at line 87 of file container_detail.hpp.

                                                                       {
         FC_ASSERT( s.size() <= MAX_NUM_ARRAY_ELEMENTS );
         variants vars;
         vars.reserve( s.size() );
         for( const auto& item : s ) {
            vars.emplace_back( item );
         }
         vo = std::move( vars );
      }

Here is the caller graph for this function:

Variable Documentation

have_so_reuseport

bool fc::detail::have_so_reuseport = true

Definition at line 19 of file tcp_socket.cpp.

is_class_helper

template<typename T >

fc::false_type fc::detail::is_class_helper(...)

(

...

)