vt::pipe::PipeManagerTL struct
#include <src/vt/pipe/pipe_manager_tl.h>

Base classes

struct PipeManagerBase virtual

Derived classes

struct PipeManager
Core VT component that provides an interface to create type-erased callbacks to many endpoint types.

Public types

template<typename ColT, typename MsgT>
using ColHanType = vrt::collection::ActiveColTypedFnType<MsgT, ColT>
template<typename ColT, typename MsgT>
using ColMemType = vrt::collection::ActiveColMemberTypedFnType<MsgT, ColT>
template<typename ObjT, typename MsgT>
using ObjMemType = objgroup::ActiveObjType<MsgT, ObjT>
template<typename ColT>
using ColProxyType = CollectionProxy<ColT, typename ColT::IndexType>
using CallbackType = callback::cbunion::CallbackRawBaseSingle
template<typename MsgT>
using CallbackMsgType = callback::cbunion::CallbackTyped<MsgT>
template<typename... Args>
using CallbackRetType = callback::cbunion::CallbackTyped<Args...>
template<typename MsgT>
using FnType = ActiveTypedFnType<MsgT>
template<typename MsgT>
using DefType = CallbackMsgType<MsgT>
using V = signal::SigVoidType

Public functions

template<auto f, bool is_bcast>
auto makeCallbackSingle(NodeType node = uninitialized_destination) -> auto
template<typename FunctorT, bool is_bcast>
auto makeCallbackFunctor(NodeType node = uninitialized_destination) -> auto
auto makeCallbackSingleAnonVoid(LifetimeEnum life, FuncVoidType fn) -> auto
template<typename T>
auto makeCallbackSingleAnon(LifetimeEnum life, FuncMsgType<T> fn) -> auto
template<typename T, typename U>
auto makeCallbackSingleAnon(LifetimeEnum life, U* u, FuncMsgCtxType<T, U> fn) -> auto
template<typename U>
auto makeCallbackSingleAnon(LifetimeEnum life, U* u, FuncCtxType<U> fn) -> auto
template<auto f, bool is_bcast, typename ProxyT>
auto makeCallbackProxy(ProxyT proxy) -> auto
template<typename = void>
auto makeCallback() -> CallbackType
template<typename T>
auto makeCallbackTyped() -> CallbackMsgType<T>
template<typename T, ActiveTypedFnType<T>* f, typename CbkT = DefType<T>>
void addListener(CbkT const& cb, NodeType const& node)
template<typename T, ActiveTypedFnType<T>* f, typename CbkT = DefType<T>>
void addListenerBcast(CbkT const& cb)
template<typename FunctorT, typename T = typename util::FunctorExtractor<FunctorT>::MessageType, typename CbkT = DefType<T>>
void addListenerFunctor(CbkT const& cb, NodeType const& node)
template<typename FunctorT, typename CbkT = DefType<V>>
void addListenerFunctorVoid(CbkT const& cb, NodeType const& node)
template<typename FunctorT, typename T = typename util::FunctorExtractor<FunctorT>::MessageType, typename CbkT = DefType<T>>
void addListenerFunctorBcast(CbkT const& cb)
template<typename MsgT, ActiveTypedFnType<MsgT>* f, typename CallbackT>
void addListener(CallbackT const& cb, NodeType const& node)
template<typename MsgT, ActiveTypedFnType<MsgT>* f, typename CallbackT>
void addListenerBcast(CallbackT const& cb)
template<typename FunctorT, typename T, typename CallbackT>
void addListenerFunctor(CallbackT const& cb, NodeType const& node)
template<typename FunctorT, typename CallbackT>
void addListenerFunctorVoid(CallbackT const& cb, NodeType const& node)
template<typename FunctorT, typename T, typename CallbackT>
void addListenerFunctorBcast(CallbackT const& cb)
template<auto f, bool is_bcast>
auto makeCallbackSingle(] NodeType node) -> auto
template<typename FunctorT, bool is_bcast>
auto makeCallbackFunctor(] NodeType node) -> auto
template<typename C>
auto makeCallbackSingleAnon(LifetimeEnum life, C* ctx, FuncCtxType<C> fn) -> auto
template<typename MsgT, typename C>
auto makeCallbackSingleAnon(LifetimeEnum life, C* ctx, FuncMsgCtxType<MsgT, C> fn) -> auto
template<typename MsgT>
auto makeCallbackSingleAnon(LifetimeEnum life, FuncMsgType<MsgT> fn) -> auto

Function documentation

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename MsgT, ActiveTypedFnType<MsgT>* f, typename CallbackT>
void vt::pipe::PipeManagerTL::addListener(CallbackT const& cb, NodeType const& node)

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename MsgT, ActiveTypedFnType<MsgT>* f, typename CallbackT>
void vt::pipe::PipeManagerTL::addListenerBcast(CallbackT const& cb)

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename FunctorT, typename T, typename CallbackT>
void vt::pipe::PipeManagerTL::addListenerFunctor(CallbackT const& cb, NodeType const& node)

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename FunctorT, typename CallbackT>
void vt::pipe::PipeManagerTL::addListenerFunctorVoid(CallbackT const& cb, NodeType const& node)

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename FunctorT, typename T, typename CallbackT>
void vt::pipe::PipeManagerTL::addListenerFunctorBcast(CallbackT const& cb)

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<auto f, bool is_bcast>
auto vt::pipe::PipeManagerTL::makeCallbackSingle(] NodeType node)

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename FunctorT, bool is_bcast>
auto vt::pipe::PipeManagerTL::makeCallbackFunctor(] NodeType node)

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename C>
auto vt::pipe::PipeManagerTL::makeCallbackSingleAnon(LifetimeEnum life, C* ctx, FuncCtxType<C> fn)

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename MsgT, typename C>
auto vt::pipe::PipeManagerTL::makeCallbackSingleAnon(LifetimeEnum life, C* ctx, FuncMsgCtxType<MsgT, C> fn)

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename MsgT>
auto vt::pipe::PipeManagerTL::makeCallbackSingleAnon(LifetimeEnum life, FuncMsgType<MsgT> fn)