vt::pipe namespace

Namespaces

namespace callback
namespace interface
namespace signal

Classes

struct CallbackMsg
template<typename T, typename ConsT, typename U, ActiveTypedFnType<U>*... f>
struct ConstructCallbacks
template<std::size_t cur, typename T, typename ConsT, typename U, std::size_t N, ActiveTypedFnType<U>*... f>
struct ConstructCallbacksImpl
template<std::size_t cur, typename T, typename ConsT, typename U, std::size_t N, ActiveTypedFnType<U>* fcur, ActiveTypedFnType<U>*... f>
struct ConstructCallbacksImpl<cur, T, ConsT, U, N, fcur, f...>
template<typename T, typename ConsT, typename U, std::size_t N>
struct ConstructCallbacksImpl<N, T, ConsT, U, N>
struct PipeIDBuilder
struct PipeManager
Core VT component that provides an interface to create type-erased callbacks to many endpoint types.
struct PipeManagerBase
struct PipeManagerTL
struct PipeManagerTyped
struct PipeState
template<std::size_t N, typename ValueT>
struct RepeatNImpl
template<typename ValueT>
struct RepeatNImpl<0, ValueT>

Enums

enum ePipeIDBits { Sendback = 0, Persist = ePipeIDBits::Sendback + pipe_send_back_num_bits, Node = ePipeIDBits::Persist + pipe_persist_num_bits, ID = ePipeIDBits::Node + pipe_node_num_bits }
enum class LifetimeEnum: int8_t { Once, Indefinite }
Set the default lifetime for a callback. Once implies a callback can only be invoked once before it is deallocated. Indefinite means the callback can be used until the creator deletes it.

Typedefs

using PipeIDType = uint32_t
using PipeRemoteOpType = uint64_t
template<typename U>
using hasIdx_t = typename U::IndexType

Functions

void triggerPipe(PipeType const& pipe)
void triggerCallbackHan(CallbackMsg* msg)
template<typename MsgT>
void triggerSendBack(PipeType const& pipe, MsgT* data)
template<typename MsgT>
void triggerPipeTyped(PipeType const& pipe, MsgT* msg)
template<typename MsgT>
void triggerPipeUnknown(PipeType const& pipe, MsgT* msg)
template<typename MsgT>
void triggerCallbackMsgHan(MsgT* msg)
template<typename T, typename Tuple, size_t... I>
static auto build(HandlerType han, Tuple t, std::index_sequence<I...>) -> T&&
template<std::size_t size, typename T, typename... Args>
static auto build(HandlerType han, std::tuple<Args...> t) -> T&&

Variables

static const BitCountType pipe_send_back_num_bits constexpr
static const BitCountType pipe_persist_num_bits constexpr
static const BitCountType pipe_node_num_bits constexpr
static const BitCountType pipe_id_num_bits constexpr
static const PipeIDType initial_pipe_id constexpr
static const PipeIDType no_pipe_id constexpr
static const PipeRemoteOpType initial_pipe_op constexpr
static const PipeRemoteOpType no_pipe_op constexpr

Enum documentation

enum vt::pipe::ePipeIDBits
#include <src/vt/pipe/id/pipe_id.h>

enum class vt::pipe::LifetimeEnum: int8_t
#include <src/vt/pipe/pipe_lifetime.h>

Set the default lifetime for a callback. Once implies a callback can only be invoked once before it is deallocated. Indefinite means the callback can be used until the creator deletes it.

Typedef documentation

using vt::pipe::PipeIDType = uint32_t
#include <src/vt/pipe/pipe_common.h>

using vt::pipe::PipeRemoteOpType = uint64_t
#include <src/vt/pipe/pipe_common.h>

#include <src/vt/pipe/pipe_manager_tl.impl.h>
template<typename U>
using vt::pipe::hasIdx_t = typename U::IndexType

Function documentation

void vt::pipe::triggerPipe(PipeType const& pipe)
#include <src/vt/pipe/pipe_manager.fwd.h>

#include <src/vt/pipe/pipe_manager.fwd.h>
template<typename MsgT>
void vt::pipe::triggerSendBack(PipeType const& pipe, MsgT* data)

#include <src/vt/pipe/pipe_manager.fwd.h>
template<typename MsgT>
void vt::pipe::triggerPipeTyped(PipeType const& pipe, MsgT* msg)

#include <src/vt/pipe/pipe_manager.fwd.h>
template<typename MsgT>
void vt::pipe::triggerPipeUnknown(PipeType const& pipe, MsgT* msg)

#include <src/vt/pipe/pipe_manager.fwd.h>
template<typename MsgT>
void vt::pipe::triggerCallbackMsgHan(MsgT* msg)

#include <src/vt/pipe/pipe_manager_construct.h>
template<typename T, typename Tuple, size_t... I>
static T&& vt::pipe::build(HandlerType han, Tuple t, std::index_sequence<I...>)

#include <src/vt/pipe/pipe_manager_construct.h>
template<std::size_t size, typename T, typename... Args>
static T&& vt::pipe::build(HandlerType han, std::tuple<Args...> t)

Variable documentation

static const BitCountType vt::pipe::pipe_send_back_num_bits constexpr
#include <src/vt/pipe/id/pipe_id.h>

static const BitCountType vt::pipe::pipe_persist_num_bits constexpr
#include <src/vt/pipe/id/pipe_id.h>

static const BitCountType vt::pipe::pipe_node_num_bits constexpr
#include <src/vt/pipe/id/pipe_id.h>

static const BitCountType vt::pipe::pipe_id_num_bits constexpr
#include <src/vt/pipe/id/pipe_id.h>

static const PipeIDType vt::pipe::initial_pipe_id constexpr
#include <src/vt/pipe/pipe_common.h>

static const PipeIDType vt::pipe::no_pipe_id constexpr
#include <src/vt/pipe/pipe_common.h>

static const PipeRemoteOpType vt::pipe::initial_pipe_op constexpr
#include <src/vt/pipe/pipe_common.h>

static const PipeRemoteOpType vt::pipe::no_pipe_op constexpr
#include <src/vt/pipe/pipe_common.h>