MADNESS 0.10.1
Namespaces | Classes | Typedefs | Functions | Variables
madness::detail Namespace Reference

Namespaces

namespace  arg_holder
 

Classes

struct  absinplace
 
struct  absop
 
struct  abssqop
 
struct  abssquareinplace
 
struct  adqtest
 
struct  ArgCount
 
struct  ArgCountHelper
 
struct  ArgCountHelper< void >
 
class  ArgHolder
 A wrapper object for holding task function argument objects. More...
 
struct  callable_enabler
 
struct  callable_enabler< callableT, std::enable_if_t< callable_traits< callableT >::value > >
 
struct  callable_traits
 Function traits in the spirit of boost function traits. More...
 
struct  callable_traits< fnT(argTs...), std::enable_if_t< is_type< std::invoke_result_t< fnT, argTs... > >::value > >
 Function traits in the spirit of boost function traits. More...
 
struct  DefaultInitPtr
 Default pointer to a. object of type T. More...
 
struct  DefaultInitPtr< std::shared_ptr< T > >
 Default shared pointer to an object of type T. More...
 
class  DeferredCleanup
 Deferred cleanup of shared_ptr's. More...
 
class  DistCache
 Distributed caching utility. More...
 
class  ForEachRootTask
 Apply an operation to a range of iterators. More...
 
struct  function_enabler
 
struct  function_enabler_helper
 Behave like a lazy std::enable_if. More...
 
struct  function_enabler_helper< false, returnT >
 Specialization that disables type when B is false. More...
 
struct  function_traits
 Function traits in the spirit of boost function traits. More...
 
struct  function_traits< fnT(argTs...), std::enable_if_t< is_type< std::invoke_result_t< fnT, argTs... > >::value > >
 Function trait specialization for a callable (can be a function, a (generic) lambda, etc.) More...
 
struct  function_traits< resultT(*&)(argTs...), void >
 Function trait specialization for a reference to a free function pointer. More...
 
struct  function_traits< resultT(*)(argTs...), void >
 Function trait specialization for a free function pointer. More...
 
struct  helper
 
struct  helper< T, 0 >
 
struct  helper< T, 1 >
 
struct  imagop
 
struct  info
 
struct  info_base
 
struct  is_arg_holder
 
struct  is_arg_holder< ArgHolder< T > >
 
struct  is_functor
 
struct  is_functor< fnT, typename std::enable_if< is_type< typename fnT::result_type >::value >::type >
 
struct  is_type
 
struct  memfunc_enabler
 
struct  memfunc_enabler< const objT *, memfnT >
 
struct  memfunc_enabler< const objT *const, memfnT >
 
struct  memfunc_enabler< const std::shared_ptr< objT > &, memfnT >
 
struct  memfunc_enabler< const std::shared_ptr< objT >, memfnT >
 
struct  memfunc_enabler< objT *, memfnT >
 
struct  memfunc_enabler< objT *const, memfnT >
 
struct  memfunc_enabler< std::shared_ptr< objT > &, memfnT >
 
struct  memfunc_enabler< std::shared_ptr< objT >, memfnT >
 
struct  memfunc_enabler_base
 
struct  memfunc_enabler_base< objT, resT(baseT::*)(paramT...) const, typename std::enable_if< std::is_base_of< baseT, objT >::value >::type >
 
struct  memfunc_enabler_base< objT, resT(baseT::*)(paramT...), typename std::enable_if< std::is_base_of< baseT, objT >::value >::type >
 
struct  memfunc_traits
 Member function traits in the spirit of boost function traits. More...
 
struct  memfunc_traits< returnT(objT::*)(argTs...) const >
 Member function traits in the spirit of boost function traits. More...
 
struct  memfunc_traits< returnT(objT::*)(argTs...)>
 Member function traits in the spirit of boost function traits. More...
 
class  MemFuncWrapper
 Functor wrapper for object and member function pointers. More...
 
class  MemFuncWrapper< ptrT, memfnT, void >
 Functor wrapper for object and member function pointers. More...
 
struct  noop
 
struct  PendingMsg
 Common base class for pending messages to ensure in-order processing. More...
 
struct  ptr_traits
 
struct  ptr_traits< void >
 Specialization of ptr_traits for type void. More...
 
struct  real_type
 
struct  real_type< std::complex< T > >
 
struct  realop
 
class  RemoteCounter
 Remote reference counter. More...
 
class  RemoteCounterBase
 Base class for remote counter implementation objects. More...
 
class  RemoteCounterImpl
 Remote counter implementation object. More...
 
struct  result_of
 
struct  result_of< fnT, typename std::enable_if< function_traits< fnT >::value >::type >
 
struct  result_of< fnT, typename std::enable_if< is_type< decltype(&fnT::operator())>::value >::type >
 
struct  result_of< fnT, typename std::enable_if< memfunc_traits< fnT >::value >::type >
 
struct  scaleinplace
 
struct  squareinplace
 
class  StackBase
 Base class for Stack which implements basic memory operations for non-POD objects. More...
 
class  StackBase< T, true >
 Base class for Stack which implements basic memory operations for POD objects. More...
 
struct  task_arg
 
struct  task_arg< Future< T > * >
 
struct  task_arg< Future< T > >
 
struct  task_arg< Future< void > >
 
struct  task_arg< void >
 
struct  task_result_type
 
struct  TaskHandlerInfo
 Serialization container for sending tasks to remote nodes. More...
 
class  WorldMpi
 MPI singleton that manages MPI setup and teardown for MADNESS. More...
 
class  WorldMpiRuntime
 MPI runtime reference counter. More...
 
struct  WorldObjectTaskHelper
 
struct  WorldObjectTaskHelper< objT, memfnT, typename std::enable_if< std::is_base_of< std::enable_shared_from_this< objT >, objT >::value >::type >
 
class  WorldPtr
 A global pointer address, valid anywhere in the world. More...
 

Typedefs

typedef Future< void > voidT
 

Functions

void combine_hash (hashT &seed, hashT hash)
 Internal use only.
 
void compare_fn_addresses (void *addresses_in, void *addresses_inout, int *len, MPI_Datatype *type)
 
template<typename objT >
void deferred_cleanup (World &world, const std::shared_ptr< objT > &p, bool assume_p_is_unique)
 Defer the cleanup of a shared pointer to the end of the next fence.
 
template<typename ptrT , typename memfnT , typename resT >
memfnT get_mem_func_ptr (const MemFuncWrapper< ptrT, memfnT, resT > &wrapper)
 Returns the member function pointer from a wrapper.
 
unsigned short htons_x (unsigned short a)
 
template<typename T = int>
double mynorm (int t)
 
template<typename T >
T mynorm (std::complex< T > t)
 
template<typename T >
T mynorm (T t)
 
template<typename T >
double norm (const T &t)
 
template<typename T >
double norm (const Tensor< T > &t)
 
std::ostream & operator<< (std::ostream &out, const RemoteCounter &counter)
 
template<typename T , typename U >
bool operator<= (const WorldPtr< T > &left, const WorldPtr< U > &right)
 Less-than-equal-to comparison operator.
 
template<typename T , typename U >
bool operator> (const WorldPtr< T > &left, const WorldPtr< U > &right)
 Greater-than comparison operator.
 
template<typename T , typename U >
bool operator>= (const WorldPtr< T > &left, const WorldPtr< U > &right)
 Greater-than-equal-to comparison operator.
 
static const uniqueidTpeek (const AmArg &arg)
 Extract the unique object ID from an incoming active message header.
 
bool & print_meminfo_flag_accessor ()
 
bool & print_meminfo_keepstreamopen_accessor ()
 
void print_mutex_error (int error_number)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T , typename a9T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, a8T &a8, a9T &a9)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, a8T &a8, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, a1T &a1, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (Future< void > &result, fnT fn, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T , typename a9T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, a8T &a8, a9T &a9)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, a8T &a8, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T , typename a3T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T , typename a2T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT , typename a1T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
template<typename fnT >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type run_function (typename task_result_type< fnT >::futureT &result, fnT fn, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
 
void swap (RemoteCounter &l, RemoteCounter &r)
 
template<typename T >
void swap (WorldPtr< T > &l, WorldPtr< T > &r)
 Swap the content of l with r.
 
ThreadTagthread_tag_accessor ()
 
template<typename Char >
const Char * Vm_cstr ()
 
template<>
const char * Vm_cstr< char > ()
 
template<>
const wchar_t * Vm_cstr< wchar_t > ()
 
template<typename objT , typename memfnT >
MemFuncWrapper< const objT *, memfnT, typename result_of< memfnT >::typewrap_mem_fn (const objT &obj, memfnT memfn)
 Create a member function wrapper (MemFuncWrapper) from a const object and a member function pointer.
 
template<typename objT , typename memfnT >
MemFuncWrapper< const objT *, memfnT, typename result_of< memfnT >::typewrap_mem_fn (const objT *obj, memfnT memfn)
 Create a member function wrapper (MemFuncWrapper) from a const pointer and a member function pointer.
 
template<typename objT , typename memfnT >
MemFuncWrapper< std::shared_ptr< objT >, memfnT, typename result_of< memfnT >::typewrap_mem_fn (const std::shared_ptr< objT > &obj, memfnT memfn)
 Create a member function wrapper (MemFuncWrapper) from a const shared pointer and a member function pointer.
 
template<typename objT , typename memfnT >
MemFuncWrapper< objT *, memfnT, typename result_of< memfnT >::typewrap_mem_fn (objT &obj, memfnT memfn)
 Create a member function wrapper (MemFuncWrapper) from an object and a member function pointer.
 
template<typename objT , typename memfnT >
MemFuncWrapper< objT *, memfnT, typename result_of< memfnT >::typewrap_mem_fn (objT *obj, memfnT memfn)
 Create a member function wrapper (MemFuncWrapper) from a pointer and a member function pointer.
 
template<typename objT , typename memfnT >
MemFuncWrapper< std::shared_ptr< objT >, memfnT, typename result_of< memfnT >::typewrap_mem_fn (std::shared_ptr< objT > &obj, memfnT memfn)
 Create a member function wrapper (MemFuncWrapper) from a shared pointer and a member function pointer.
 

Variables

Mutex printmutex
 

Detailed Description

Todo:
Description needed

Typedef Documentation

◆ voidT

Future<void> is an empty object which is used as a placeholder for unused arguments.

Function Documentation

◆ combine_hash()

void madness::detail::combine_hash ( hashT seed,
hashT  hash 
)
inline

◆ compare_fn_addresses()

void madness::detail::compare_fn_addresses ( void *  addresses_in,
void *  addresses_inout,
int *  len,
MPI_Datatype type 
)

◆ deferred_cleanup()

template<typename objT >
void madness::detail::deferred_cleanup ( World world,
const std::shared_ptr< objT > &  p,
bool  assume_p_is_unique 
)
inline

Defer the cleanup of a shared pointer to the end of the next fence.

Call this function before destroying a shared pointer. If the shared pointer is the last reference to the object, or assume_p_is_unique is true, it is placed in the deferred deletion list. Otherwise, nothing is done with the pointer.

Referenced by madness::WorldContainer< keyT, valueT, hashfunT >::~WorldContainer().

◆ get_mem_func_ptr()

template<typename ptrT , typename memfnT , typename resT >
memfnT madness::detail::get_mem_func_ptr ( const MemFuncWrapper< ptrT, memfnT, resT > &  wrapper)

Returns the member function pointer from a wrapper.

Template Parameters
ptrTPointer type.
memfnTMember function pointer type.
resTMember function return type.
Parameters
wrapperWrapper to the member function.
Returns
The member function pointer.

Referenced by madness::TaskFn< fnT, arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T >::get_func().

◆ htons_x()

unsigned short madness::detail::htons_x ( unsigned short  a)
inline

References a.

Referenced by madness::plotpovray().

◆ mynorm() [1/3]

template<typename T = int>
double madness::detail::mynorm ( int  t)

◆ mynorm() [2/3]

template<typename T >
T madness::detail::mynorm ( std::complex< T t)

◆ mynorm() [3/3]

template<typename T >
T madness::detail::mynorm ( T  t)

◆ norm() [1/2]

template<typename T >
double madness::detail::norm ( const T t)

References std::abs().

Referenced by madness::adq1().

◆ norm() [2/2]

template<typename T >
double madness::detail::norm ( const Tensor< T > &  t)

◆ operator<<()

std::ostream & madness::detail::operator<< ( std::ostream &  out,
const RemoteCounter counter 
)

◆ operator<=()

template<typename T , typename U >
bool madness::detail::operator<= ( const WorldPtr< T > &  left,
const WorldPtr< U > &  right 
)

Less-than-equal-to comparison operator.

This operator does a lexicographical comparison of world ID, rank, and pointer (in that order).

Template Parameters
TOne pointer type.
UAnother pointer type.
Parameters
[in]leftOne pointer.
[in]rightThe other pointer.
Returns
True if the lexicographical comparison of world ID, rank, and pointer is true; false otherwise.

◆ operator>()

template<typename T , typename U >
bool madness::detail::operator> ( const WorldPtr< T > &  left,
const WorldPtr< U > &  right 
)

Greater-than comparison operator.

This operator does a lexicographical comparison of world ID, rank, and pointer (in that order).

Template Parameters
TOne pointer type.
UAnother pointer type.
Parameters
[in]leftOne pointer.
[in]rightThe other pointer.
Returns
True if the lexicographical comparison of world ID, rank, and pointer is true; false otherwise.

◆ operator>=()

template<typename T , typename U >
bool madness::detail::operator>= ( const WorldPtr< T > &  left,
const WorldPtr< U > &  right 
)

Greater-than-equal-to comparison operator.

This operator does a lexicographical comparison of world ID, rank, and pointer (in that order).

Template Parameters
TOne pointer type.
UAnother pointer type.
Parameters
[in]leftOne pointer.
[in]rightThe other pointer.
Returns
True if the lexicographical comparison of world ID, rank, and pointer is true; false otherwise.

◆ peek()

static const uniqueidT & madness::detail::peek ( const AmArg arg)
inlinestatic

Extract the unique object ID from an incoming active message header.

We deserialize the header and all arguments at the same time to simplify the code. However, it is common that when sending a message to an item in a container to include a pointer to the container itself. But this breaks if the container is not initialized since the deserialization throws if the object is not initialized (which seems preferable to a hidden race condition). Hence, we use this routine to extract the unique ID from the very front of the info structure. For efficiency we here rely upon the serialization of info being opaque and the ID being at the front of info.

Todo:
Verify parameter description.
Parameters
[in]argThe active message header.

References madness::arg().

Referenced by madness::WorldObject< Derived >::handler(), and madness::WorldObject< Derived >::spawn_remote_task_handler().

◆ print_meminfo_flag_accessor()

bool & madness::detail::print_meminfo_flag_accessor ( )

◆ print_meminfo_keepstreamopen_accessor()

bool & madness::detail::print_meminfo_keepstreamopen_accessor ( )

◆ print_mutex_error()

void madness::detail::print_mutex_error ( int  error_number)

◆ run_function() [1/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T , typename a9T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
a6T &  a6,
a7T &  a7,
a8T &  a8,
a9T &  a9 
)
inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [2/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
a6T &  a6,
a7T &  a7,
a8T &  a8,
const voidT  
)
inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [3/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
a6T &  a6,
a7T &  a7,
const voidT ,
const voidT  
)
inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [4/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
a6T &  a6,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [5/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [6/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [7/20]

template<typename fnT , typename a1T , typename a2T , typename a3T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [8/20]

template<typename fnT , typename a1T , typename a2T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [9/20]

template<typename fnT , typename a1T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
a1T &  a1,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, and madness::Future< T >::set().

◆ run_function() [10/20]

template<typename fnT >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( Future< void > &  result,
fnT  fn,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

◆ run_function() [11/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T , typename a9T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
a6T &  a6,
a7T &  a7,
a8T &  a8,
a9T &  a9 
)
inline

References a1, and a2.

◆ run_function() [12/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
a6T &  a6,
a7T &  a7,
a8T &  a8,
const voidT  
)
inline

References a1, and a2.

◆ run_function() [13/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
a6T &  a6,
a7T &  a7,
const voidT ,
const voidT  
)
inline

References a1, and a2.

◆ run_function() [14/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
a6T &  a6,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, and a2.

◆ run_function() [15/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
a5T &  a5,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, and a2.

◆ run_function() [16/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
a4T &  a4,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, and a2.

◆ run_function() [17/20]

template<typename fnT , typename a1T , typename a2T , typename a3T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
a3T &  a3,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, and a2.

◆ run_function() [18/20]

template<typename fnT , typename a1T , typename a2T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
a1T &  a1,
a2T &  a2,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1, and a2.

◆ run_function() [19/20]

template<typename fnT , typename a1T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
a1T &  a1,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

References a1.

◆ run_function() [20/20]

template<typename fnT >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function ( typename task_result_type< fnT >::futureT &  result,
fnT  fn,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT ,
const voidT  
)
inline

◆ swap() [1/2]

void madness::detail::swap ( RemoteCounter l,
RemoteCounter r 
)
inline

◆ swap() [2/2]

template<typename T >
void madness::detail::swap ( WorldPtr< T > &  l,
WorldPtr< T > &  r 
)

Swap the content of l with r.

Template Parameters
TThe world pointer type.
Parameters
[in,out]lOne world pointer.
[in,out]rThe other world pointer.

References madness::detail::WorldPtr< T >::swap().

Referenced by madness::detail::RemoteCounter::swap(), and madness::RemoteReference< T >::swap().

◆ thread_tag_accessor()

ThreadTag & madness::detail::thread_tag_accessor ( )
inline

◆ Vm_cstr()

template<typename Char >
const Char * madness::detail::Vm_cstr ( )

◆ Vm_cstr< char >()

template<>
const char * madness::detail::Vm_cstr< char > ( )

Referenced by madness::print_meminfo().

◆ Vm_cstr< wchar_t >()

template<>
const wchar_t * madness::detail::Vm_cstr< wchar_t > ( )

References L.

◆ wrap_mem_fn() [1/6]

template<typename objT , typename memfnT >
MemFuncWrapper< const objT *, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn ( const objT &  obj,
memfnT  memfn 
)

Create a member function wrapper (MemFuncWrapper) from a const object and a member function pointer.

Template Parameters
objTThe object type.
memfnTThe member function pointer type.
Parameters
[in]objThe object.
[in]memfnThe member function pointer.
Returns
A wrapped member function pointer.

◆ wrap_mem_fn() [2/6]

template<typename objT , typename memfnT >
MemFuncWrapper< const objT *, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn ( const objT *  obj,
memfnT  memfn 
)

Create a member function wrapper (MemFuncWrapper) from a const pointer and a member function pointer.

Template Parameters
objTThe object type.
memfnTThe member function pointer type.
Parameters
[in]objPointer to the object.
[in]memfnThe member function pointer.
Returns
A wrapped member function pointer.

◆ wrap_mem_fn() [3/6]

template<typename objT , typename memfnT >
MemFuncWrapper< std::shared_ptr< objT >, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn ( const std::shared_ptr< objT > &  obj,
memfnT  memfn 
)

Create a member function wrapper (MemFuncWrapper) from a const shared pointer and a member function pointer.

Template Parameters
objTThe object type.
memfnTThe member function pointer type.
Parameters
[in]objShared pointer to the object.
[in]memfnThe member function pointer.
Returns
A wrapped member function pointer.

◆ wrap_mem_fn() [4/6]

template<typename objT , typename memfnT >
MemFuncWrapper< objT *, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn ( objT &  obj,
memfnT  memfn 
)

◆ wrap_mem_fn() [5/6]

template<typename objT , typename memfnT >
MemFuncWrapper< objT *, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn ( objT *  obj,
memfnT  memfn 
)

Create a member function wrapper (MemFuncWrapper) from a pointer and a member function pointer.

Template Parameters
objTThe object type.
memfnTThe member function pointer type.
Parameters
[in]objPointer to the object.
[in]memfnThe member function pointer.
Returns
A wrapped member function pointer.

◆ wrap_mem_fn() [6/6]

template<typename objT , typename memfnT >
MemFuncWrapper< std::shared_ptr< objT >, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn ( std::shared_ptr< objT > &  obj,
memfnT  memfn 
)

Create a member function wrapper (MemFuncWrapper) from a shared pointer and a member function pointer.

Template Parameters
objTThe object type.
memfnTThe member function pointer type.
Parameters
[in]objShared pointer to the object.
[in]memfnThe member function pointer.
Returns
A wrapped member function pointer.

Variable Documentation

◆ printmutex

Mutex madness::detail::printmutex