MADNESS  version 0.9
Public Types | Public Member Functions | Friends | List of all members
madness::WorldContainer< keyT, valueT, hashfunT > Class Template Reference

Makes a distributed container with specified attributes. More...

#include <worlddc.h>

Inheritance diagram for madness::WorldContainer< keyT, valueT, hashfunT >:
Inheritance graph
[legend]
Collaboration diagram for madness::WorldContainer< keyT, valueT, hashfunT >:
Collaboration graph
[legend]

Public Types

typedef WorldContainer< keyT,
valueT, hashfunT > 
containerT
 
typedef WorldContainerImpl
< keyT, valueT, hashfunT > 
implT
 
typedef implT::pairT pairT
 
typedef implT::iterator iterator
 
typedef implT::const_iterator const_iterator
 
typedef implT::accessor accessor
 
typedef implT::const_accessor const_accessor
 
typedef Future< iteratorfutureT
 
typedef Future< const_iteratorconst_futureT
 

Public Member Functions

 WorldContainer ()
 Makes an uninitialized container (no communication) More...
 
 WorldContainer (World &world, bool do_pending=true, const hashfunT &hf=hashfunT())
 Makes an initialized, empty container with default data distribution (no communication) More...
 
 WorldContainer (World &world, const std::shared_ptr< WorldDCPmapInterface< keyT > > &pmap, bool do_pending=true, const hashfunT &hf=hashfunT())
 Makes an initialized, empty container (no communication) More...
 
 WorldContainer (const WorldContainer &other)
 Copy constructor is shallow (no communication) More...
 
containerToperator= (const containerT &other)
 Assignment is shallow (no communication) More...
 
Worldget_world () const
 Returns the world associated with this container. More...
 
void replace (const pairT &datum)
 Inserts/replaces key+value pair (non-blocking communication if key not local) More...
 
void replace (const keyT &key, const valueT &value)
 Inserts/replaces key+value pair (non-blocking communication if key not local) More...
 
bool find (accessor &acc, const keyT &key)
 Write access to LOCAL value by key. Returns true if found, false otherwise (always false for remote). More...
 
bool find (const_accessor &acc, const keyT &key) const
 Read access to LOCAL value by key. Returns true if found, false otherwise (always false for remote). More...
 
bool insert (accessor &acc, const keyT &key)
 Write access to LOCAL value by key. Returns true if inserted, false if already exists (throws if remote) More...
 
bool insert (const_accessor &acc, const keyT &key)
 Read access to LOCAL value by key. Returns true if inserted, false if already exists (throws if remote) More...
 
template<typename input_iterator >
void replace (input_iterator &start, input_iterator &end)
 Inserts pairs (non-blocking communication if key(s) not local) More...
 
bool probe (const keyT &key) const
 Returns true if local data is immediately available (no communication) More...
 
ProcessID owner (const keyT &key) const
 Returns processor that logically owns key (no communication) More...
 
bool is_local (const keyT &key) const
 Returns true if the key maps to the local processor (no communication) More...
 
Future< iteratorfind (const keyT &key)
 Returns a future iterator (non-blocking communication if key not local) More...
 
Future< const_iteratorfind (const keyT &key) const
 Returns a future iterator (non-blocking communication if key not local) More...
 
iterator begin ()
 Returns an iterator to the beginning of the local data (no communication) More...
 
const_iterator begin () const
 Returns an iterator to the beginning of the local data (no communication) More...
 
iterator end ()
 Returns an iterator past the end of the local data (no communication) More...
 
const_iterator end () const
 Returns an iterator past the end of the local data (no communication) More...
 
void erase (const keyT &key)
 Erases entry from container (non-blocking comm if remote) More...
 
void erase (const iterator &it)
 Erases entry corresponding to local iterator (no communication) More...
 
void erase (const iterator &start, const iterator &finish)
 Erases range defined by local iterators (no communication) More...
 
void clear ()
 Clears all local data (no communication) More...
 
std::size_t size () const
 Returns the number of local entries (no communication) More...
 
const std::shared_ptr
< WorldDCPmapInterface< keyT > > & 
get_pmap () const
 Returns shared pointer to the process mapping. More...
 
hashfunT & get_hash () const
 Returns a reference to the hashing functor. More...
 
void process_pending ()
 Process pending messages. More...
 
template<typename memfunT >
Future< MEMFUN_RETURNT(memfunT) > send (const keyT &key, memfunT memfun)
 Sends message "resultT memfun()" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, const memfunT &memfun, const arg1T &arg1)
 Sends message "resultT memfun(arg1T)" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2)
 Sends message "resultT memfun(arg1T,arg2T)" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3)
 Sends message "resultT memfun(arg1T,arg2T,arg3T)" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4)
 Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T)" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5)
 Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T)" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6)
 Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T)" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const arg7T &arg7)
 Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T)" to item (non-blocking comm if remote) More...
 
template<typename memfunT >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun) const
 Sends message "resultT memfun() const" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1) const
 Sends message "resultT memfun(arg1T) const" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2) const
 Sends message "resultT memfun(arg1T,arg2T) const" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3) const
 Sends message "resultT memfun(arg1T,arg2T,arg3T) const" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4) const
 Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T) const" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5) const
 Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T) const" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6) const
 Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T) const" to item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const arg7T &arg7) const
 Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T) const" to item (non-blocking comm if remote) More...
 
template<typename memfunT >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const TaskAttributes &attr=TaskAttributes())
 Adds task "resultT memfun()" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const TaskAttributes &attr=TaskAttributes())
 Adds task "resultT memfun(arg1T)" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const TaskAttributes &attr=TaskAttributes())
 Adds task "resultT memfun(arg1T,arg2T)" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const TaskAttributes &attr=TaskAttributes())
 Adds task "resultT memfun(arg1T,arg2T,arg3T)" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const TaskAttributes &attr=TaskAttributes())
 Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T)" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const TaskAttributes &attr=TaskAttributes())
 Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T)" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const TaskAttributes &attr=TaskAttributes())
 Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T)" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const arg7T &arg7, const TaskAttributes &attr=TaskAttributes())
 Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T)" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const TaskAttributes &attr=TaskAttributes()) const
 Adds task "resultT memfun() const" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const TaskAttributes &attr=TaskAttributes()) const
 Adds task "resultT memfun(arg1T) const" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const TaskAttributes &attr=TaskAttributes()) const
 Adds task "resultT memfun(arg1T,arg2T) const" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const TaskAttributes &attr=TaskAttributes()) const
 Adds task "resultT memfun(arg1T,arg2T,arg3T) const" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const TaskAttributes &attr=TaskAttributes()) const
 Adds task "resultT memfun(arg1T,arg2T,arg3T, arg4T) const" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const TaskAttributes &attr=TaskAttributes()) const
 Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T) const" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const TaskAttributes &attr=TaskAttributes()) const
 Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T) const" in process owning item (non-blocking comm if remote) More...
 
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const arg7T &arg7, const TaskAttributes &attr=TaskAttributes()) const
 Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T) const" in process owning item (non-blocking comm if remote) More...
 
template<typename Archive >
void serialize (const Archive &ar)
 (de)Serialize — Local data only to/from anything except Buffer*Archive and Parallel*Archive More...
 
void serialize (const archive::BufferOutputArchive &ar)
 (de)Serialize — !! ONLY for purpose of interprocess communication More...
 
void serialize (const archive::BufferInputArchive &ar)
 (de)Serialize — !! ONLY for purpose of interprocess communication More...
 
const uniqueidTid () const
 Returns the associated unique id ... must be initialized. More...
 
virtual ~WorldContainer ()
 Destructor passes ownership of implementation to world for deferred cleanup. More...
 

Friends

void swap (WorldContainer &, WorldContainer &)
 Swaps the content of two WorldContainer objects. It should be called on all nodes. More...
 

Detailed Description

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
class madness::WorldContainer< keyT, valueT, hashfunT >

Makes a distributed container with specified attributes.

There is no communication or syncronization associated with making a new container, but every process must invoke the constructor for each container in the same order. This is so that we can assign each container a unique ID without any communication. Since remotely invoked operations may start happening before local construction, messages on not yet constructed containers are buffered pending construction.

Similarly, when a container is destroyed, the actual destruction is deferred until a synchronization point (world.gop.fence()) in order to eliminate the need to fence before destroying every container.

The distribution of data between processes is controlled by the process map (Pmap) class. The default is uniform hashing based upon a strong (Bob Jenkins, lookup3) bytewise hash of the key.

All operations, including constructors and destructors, are non-blocking and return immediately. If communication occurs it is asynchronous, otherwise operations are local.

Member Typedef Documentation

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
typedef implT::accessor madness::WorldContainer< keyT, valueT, hashfunT >::accessor
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
typedef implT::const_accessor madness::WorldContainer< keyT, valueT, hashfunT >::const_accessor
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
typedef Future<const_iterator> madness::WorldContainer< keyT, valueT, hashfunT >::const_futureT
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
typedef implT::const_iterator madness::WorldContainer< keyT, valueT, hashfunT >::const_iterator
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
typedef WorldContainer<keyT,valueT,hashfunT> madness::WorldContainer< keyT, valueT, hashfunT >::containerT
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
typedef Future<iterator> madness::WorldContainer< keyT, valueT, hashfunT >::futureT
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
typedef WorldContainerImpl<keyT,valueT,hashfunT> madness::WorldContainer< keyT, valueT, hashfunT >::implT
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
typedef implT::iterator madness::WorldContainer< keyT, valueT, hashfunT >::iterator
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
typedef implT::pairT madness::WorldContainer< keyT, valueT, hashfunT >::pairT

Constructor & Destructor Documentation

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer ( )
inline

Makes an uninitialized container (no communication)

The container is useless until assigned to from a fully constructed container. There is no need to worry about default constructors being executed in order.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer ( World world,
bool  do_pending = true,
const hashfunT &  hf = hashfunT() 
)
inline

Makes an initialized, empty container with default data distribution (no communication)

A unique ID is associated with every distributed container within a world. In order to avoid synchronization when making a container, we have to assume that all processes execute this constructor in the same order (does not apply to the non-initializing, default constructor).

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer ( World world,
const std::shared_ptr< WorldDCPmapInterface< keyT > > &  pmap,
bool  do_pending = true,
const hashfunT &  hf = hashfunT() 
)
inline

Makes an initialized, empty container (no communication)

A unique ID is associated with every distributed container within a world. In order to avoid synchronization when making a container, we have to assume that all processes execute this constructor in the same order (does not apply to the non-initializing, default constructor).

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer ( const WorldContainer< keyT, valueT, hashfunT > &  other)
inline

Copy constructor is shallow (no communication)

The copy refers to exactly the same container as other which must be initialized.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
virtual madness::WorldContainer< keyT, valueT, hashfunT >::~WorldContainer ( )
inlinevirtual

Destructor passes ownership of implementation to world for deferred cleanup.

Member Function Documentation

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
iterator madness::WorldContainer< keyT, valueT, hashfunT >::begin ( )
inline
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
const_iterator madness::WorldContainer< keyT, valueT, hashfunT >::begin ( ) const
inline

Returns an iterator to the beginning of the local data (no communication)

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void madness::WorldContainer< keyT, valueT, hashfunT >::clear ( )
inline

Clears all local data (no communication)

Invalidates all iterators

Referenced by madness::FunctionImpl< Q, NDIM >::make_Vphi().

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
iterator madness::WorldContainer< keyT, valueT, hashfunT >::end ( )
inline
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
const_iterator madness::WorldContainer< keyT, valueT, hashfunT >::end ( ) const
inline

Returns an iterator past the end of the local data (no communication)

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void madness::WorldContainer< keyT, valueT, hashfunT >::erase ( const keyT &  key)
inline

Erases entry from container (non-blocking comm if remote)

Missing keys are quietly ignored.

Note that erasing an entry may invalidate iterators on the remote end. This is just the same as what happens when using STL iterators on an STL container in a sequential algorithm.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void madness::WorldContainer< keyT, valueT, hashfunT >::erase ( const iterator it)
inline

Erases entry corresponding to local iterator (no communication)

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void madness::WorldContainer< keyT, valueT, hashfunT >::erase ( const iterator start,
const iterator finish 
)
inline

Erases range defined by local iterators (no communication)

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
bool madness::WorldContainer< keyT, valueT, hashfunT >::find ( accessor acc,
const keyT &  key 
)
inline
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
bool madness::WorldContainer< keyT, valueT, hashfunT >::find ( const_accessor acc,
const keyT &  key 
) const
inline

Read access to LOCAL value by key. Returns true if found, false otherwise (always false for remote).

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
Future<iterator> madness::WorldContainer< keyT, valueT, hashfunT >::find ( const keyT &  key)
inline

Returns a future iterator (non-blocking communication if key not local)

Like an std::map an iterator "points" to an std::pair<const keyT,valueT>.

Refer to Future for info on how to avoid blocking.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
Future<const_iterator> madness::WorldContainer< keyT, valueT, hashfunT >::find ( const keyT &  key) const
inline

Returns a future iterator (non-blocking communication if key not local)

Like an std::map an iterator "points" to an std::pair<const keyT,valueT>.

Refer to Future for info on how to avoid blocking.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
hashfunT& madness::WorldContainer< keyT, valueT, hashfunT >::get_hash ( ) const
inline

Returns a reference to the hashing functor.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
const std::shared_ptr< WorldDCPmapInterface<keyT> >& madness::WorldContainer< keyT, valueT, hashfunT >::get_pmap ( ) const
inline

Returns shared pointer to the process mapping.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
World& madness::WorldContainer< keyT, valueT, hashfunT >::get_world ( ) const
inline

Returns the world associated with this container.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
const uniqueidT& madness::WorldContainer< keyT, valueT, hashfunT >::id ( ) const
inline

Returns the associated unique id ... must be initialized.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
bool madness::WorldContainer< keyT, valueT, hashfunT >::insert ( accessor acc,
const keyT &  key 
)
inline

Write access to LOCAL value by key. Returns true if inserted, false if already exists (throws if remote)

Referenced by madness::WorldContainer< keyT, nodeT >::replace(), and madness::FunctionImpl< Q, NDIM >::vtransform_doit().

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
bool madness::WorldContainer< keyT, valueT, hashfunT >::insert ( const_accessor acc,
const keyT &  key 
)
inline

Read access to LOCAL value by key. Returns true if inserted, false if already exists (throws if remote)

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
bool madness::WorldContainer< keyT, valueT, hashfunT >::is_local ( const keyT &  key) const
inline

Returns true if the key maps to the local processor (no communication)

Referenced by madness::FunctionImpl< Q, NDIM >::forward_traverse(), madness::leaf_op< T, NDIM >::operator()(), and madness::FunctionImpl< Q, NDIM >::traverse_tree().

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
containerT& madness::WorldContainer< keyT, valueT, hashfunT >::operator= ( const containerT other)
inline

Assignment is shallow (no communication)

The copy refers to exactly the same container as other which must be initialized.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
ProcessID madness::WorldContainer< keyT, valueT, hashfunT >::owner ( const keyT &  key) const
inline

Returns processor that logically owns key (no communication)

Local remapping may have changed its physical location, but all operations should forward correctly.

Referenced by madness::FunctionImpl< Q, NDIM >::apply(), madness::FunctionImpl< Q, NDIM >::apply_source_driven(), madness::FunctionImpl< Q, NDIM >::binaryXX(), madness::FunctionImpl< Q, NDIM >::binaryXXa(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::continue_recursion(), madness::DerivativeBase< T, NDIM >::find_neighbor(), madness::DerivativeBase< T, NDIM >::forward_do_diff1(), madness::FunctionImpl< Q, NDIM >::FunctionImpl(), madness::FunctionImpl< Q, NDIM >::gaxpy_ext(), madness::FunctionImpl< Q, NDIM >::gaxpy_inplace_reconstructed(), madness::FunctionImpl< Q, NDIM >::hartree_product(), madness::LoadBalanceDeux< NDIM >::load_balance(), madness::FunctionImpl< Q, NDIM >::make_Vphi(), madness::FunctionImpl< Q, NDIM >::multiply(), madness::FunctionImpl< Q, NDIM >::mulXX(), madness::FunctionImpl< Q, NDIM >::mulXXa(), madness::FunctionImpl< Q, NDIM >::mulXXvec(), madness::FunctionImpl< Q, NDIM >::mulXXveca(), madness::FunctionImpl< Q, NDIM >::project_out(), madness::FunctionImpl< Q, NDIM >::project_out2(), madness::FunctionImpl< Q, NDIM >::recursive_apply(), madness::FunctionImpl< Q, NDIM >::refine(), madness::FunctionImpl< Q, NDIM >::refine_spawn(), madness::WorldContainer< keyT, nodeT >::send(), madness::WorldContainer< keyT, nodeT >::task(), madness::FunctionImpl< Q, NDIM >::traverse_tree(), madness::FunctionImpl< Q, NDIM >::unaryXX(), madness::FunctionImpl< Q, NDIM >::unaryXXa(), and madness::FunctionImpl< Q, NDIM >::unaryXXvalues().

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
bool madness::WorldContainer< keyT, valueT, hashfunT >::probe ( const keyT &  key) const
inline
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void madness::WorldContainer< keyT, valueT, hashfunT >::process_pending ( )
inline

Process pending messages.

If the constructor was given do_pending=false then you must invoke this routine in order to process both prior and future messages.

Referenced by madness::FunctionImpl< Q, NDIM >::FunctionImpl().

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void madness::WorldContainer< keyT, valueT, hashfunT >::replace ( const pairT datum)
inline
template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void madness::WorldContainer< keyT, valueT, hashfunT >::replace ( const keyT &  key,
const valueT &  value 
)
inline

Inserts/replaces key+value pair (non-blocking communication if key not local)

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename input_iterator >
void madness::WorldContainer< keyT, valueT, hashfunT >::replace ( input_iterator &  start,
input_iterator &  end 
)
inline

Inserts pairs (non-blocking communication if key(s) not local)

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT >
Future< MEMFUN_RETURNT(memfunT) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun 
)
inline

Sends message "resultT memfun()" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

Referenced by madness::FunctionImpl< Q, NDIM >::gaxpy(), madness::LoadBalanceDeux< NDIM >::load_balance(), and madness::WorldContainer< keyT, nodeT >::send().

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
const memfunT &  memfun,
const arg1T &  arg1 
)
inline

Sends message "resultT memfun(arg1T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2 
)
inline

Sends message "resultT memfun(arg1T,arg2T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3 
)
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4 
)
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5 
)
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const arg6T &  arg6 
)
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const arg6T &  arg6,
const arg7T &  arg7 
)
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun 
) const
inline

Sends message "resultT memfun() const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1 
) const
inline

Sends message "resultT memfun(arg1T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2 
) const
inline

Sends message "resultT memfun(arg1T,arg2T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3 
) const
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4 
) const
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5 
) const
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const arg6T &  arg6 
) const
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const arg6T &  arg6,
const arg7T &  arg7 
) const
inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename Archive >
void madness::WorldContainer< keyT, valueT, hashfunT >::serialize ( const Archive &  ar)
inline

(de)Serialize — Local data only to/from anything except Buffer*Archive and Parallel*Archive

Advisable for you to fence before and after this to ensure consistency

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void madness::WorldContainer< keyT, valueT, hashfunT >::serialize ( const archive::BufferOutputArchive ar)
inline

(de)Serialize — !! ONLY for purpose of interprocess communication

This just writes/reads the unique id to/from the Buffer*Archive.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void madness::WorldContainer< keyT, valueT, hashfunT >::serialize ( const archive::BufferInputArchive ar)
inline

(de)Serialize — !! ONLY for purpose of interprocess communication

This just writes/reads the unique id to/from the Buffer*Archive.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
std::size_t madness::WorldContainer< keyT, valueT, hashfunT >::size ( ) const
inline

Returns the number of local entries (no communication)

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const TaskAttributes attr = TaskAttributes() 
)
inline

Adds task "resultT memfun()" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

Referenced by madness::FunctionImpl< Q, NDIM >::apply_1d_realspace_push_op(), madness::FunctionImpl< Q, NDIM >::do_apply(), madness::FunctionImpl< Q, NDIM >::do_apply_kernel(), madness::FunctionImpl< Q, NDIM >::do_apply_kernel2(), madness::FunctionImpl< Q, NDIM >::do_apply_kernel3(), madness::FunctionImpl< Q, NDIM >::do_project_out(), madness::FunctionImpl< T, NDIM >::project_out_op< LDIM >::operator()(), madness::WorldContainer< keyT, nodeT >::task(), and madness::FunctionImpl< Q, NDIM >::vtransform_doit().

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const TaskAttributes attr = TaskAttributes() 
)
inline

Adds task "resultT memfun(arg1T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const TaskAttributes attr = TaskAttributes() 
)
inline

Adds task "resultT memfun(arg1T,arg2T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const TaskAttributes attr = TaskAttributes() 
)
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const TaskAttributes attr = TaskAttributes() 
)
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const TaskAttributes attr = TaskAttributes() 
)
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const arg6T &  arg6,
const TaskAttributes attr = TaskAttributes() 
)
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const arg6T &  arg6,
const arg7T &  arg7,
const TaskAttributes attr = TaskAttributes() 
)
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const TaskAttributes attr = TaskAttributes() 
) const
inline

Adds task "resultT memfun() const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const TaskAttributes attr = TaskAttributes() 
) const
inline

Adds task "resultT memfun(arg1T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const TaskAttributes attr = TaskAttributes() 
) const
inline

Adds task "resultT memfun(arg1T,arg2T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const TaskAttributes attr = TaskAttributes() 
) const
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const TaskAttributes attr = TaskAttributes() 
) const
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T, arg4T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const TaskAttributes attr = TaskAttributes() 
) const
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const arg6T &  arg6,
const TaskAttributes attr = TaskAttributes() 
) const
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT)) > madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key,
memfunT  memfun,
const arg1T &  arg1,
const arg2T &  arg2,
const arg3T &  arg3,
const arg4T &  arg4,
const arg5T &  arg5,
const arg6T &  arg6,
const arg7T &  arg7,
const TaskAttributes attr = TaskAttributes() 
) const
inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

Friends And Related Function Documentation

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
void swap ( WorldContainer< keyT, valueT, hashfunT > &  dc0,
WorldContainer< keyT, valueT, hashfunT > &  dc1 
)
friend

Swaps the content of two WorldContainer objects. It should be called on all nodes.


The documentation for this class was generated from the following file: