conduit

namespace heph

namespace conduit

namespace heph

namespace conduit

template<typename T, utils::string::StringLiteral InputName>
struct ZenohPublisherNode : public heph::conduit::Node<ZenohPublisherNode<T, InputName>, ZenohPublisherOperator<T>>

Public Members

QueuedInput<T> input = {this, std::string{std::string_view{InputName}}}

Public Static Functions

static inline std::string_view name()

static inline auto trigger(ZenohPublisherNode &self)

static inline void execute(ZenohPublisherNode &self, T value)

template<typename T>
struct ZenohPublisherOperator

Public Members

ipc::zenoh::Publisher<T> publisher

Public Functions

inline ZenohPublisherOperator(ipc::zenoh::SessionPtr session, ipc::TopicConfig topic_config)

template<typename InputT>
class ZenohSubscriberNode

Public Functions

inline ZenohSubscriberNode(ipc::zenoh::SessionPtr session, ipc::TopicConfig topic_config, InputT &input)

namespace heph

namespace conduit

template<typename OperationT, typename OperationDataT = detail::Unused>
class Node : public heph::conduit::detail::NodeBase

Public Functions

inline const OperationDataT &data() const

inline OperationDataT &data()

inline std::chrono::nanoseconds nodePeriod() final

inline void removeOutputConnection(void *node) final

Public Static Attributes

static bool HAS_PERIOD = HAS_PERIOD_CONSTANT || HAS_PERIOD_NULLARY || HAS_PERIOD_ARG

static bool HAS_NAME = HAS_NAME_CONSTANT || HAS_NAME_NULLARY || HAS_NAME_ARG

namespace heph

namespace conduit

class RemoteNodeHandler

struct RegistryEntry

Public Members

std::string type_info

heph::UniqueFunction<void(heph::net::Socket, bool)> factory

Public Functions

RemoteNodeHandler(concurrency::Context &context, const std::vector<heph::net::Endpoint> &endpoints, std::exception_ptr &exception)

~RemoteNodeHandler()

std::vector<heph::net::Endpoint> endpoints() const

void run()

void requestStop()

template<typename Engine, typename Output>
void registerOutput(Engine &engine, Output &output)

template<typename Engine, typename Node>
void registerImplicitOutput(Engine &engine, Node &node)

template<typename Engine, typename InputT>
void registerInput(Engine &engine, InputT *input)

namespace heph

namespace conduit

namespace heph

namespace conduit

template<typename T>
class Output

Public Types

using ResultT = T

Public Functions

template<typename OperationT, typename DataT>
inline explicit Output(Node<OperationT, DataT> *node, std::string name)

inline auto name()

inline auto setValue(NodeEngine &engine, T t)

template<typename Input>
inline void registerInput(Input *input)

namespace heph

namespace conduit

template<typename T>
struct RemoteInputSubscriber : public heph::conduit::Node<RemoteInputSubscriber<T>, RemoteInputSubscriberOperator>

Public Static Functions

static inline auto name(const RemoteInputSubscriber &self)

static inline auto trigger(RemoteInputSubscriber &self)

static inline std::optional<T> execute(RemoteInputSubscriberOperator::MsgT msg)

class RemoteInputSubscriberOperator

Public Types

using MsgT = std::pmr::vector<std::byte>

Public Functions

inline std::string name() const

inline RemoteInputSubscriberOperator(heph::net::Socket socket, const std::string &name, bool reliable)

inline exec::task<MsgT> trigger()

struct RemoteNodeType

Public Members

std::uint8_t type = {INPUT}

bool reliable = {false}

Public Static Attributes

static std::uint8_t INPUT = 0

static std::uint8_t OUTPUT = 1

template<typename T, typename InputPolicyT = InputPolicy<>>
struct RemoteOutputPublisherNode : public heph::conduit::Node<RemoteOutputPublisherNode<T, InputPolicy<>>, RemoteOutputPublisherOperator>

Public Members

QueuedInput<T, InputPolicyT> input = {this, "input"}

Public Static Functions

static inline auto name(const RemoteOutputPublisherNode &self)

static inline auto trigger(RemoteOutputPublisherNode &self)

static inline auto execute(RemoteOutputPublisherNode &self, const T &t)

class RemoteOutputPublisherOperator

Public Functions

inline explicit RemoteOutputPublisherOperator(heph::net::Socket client, const std::string &name, bool reliable)

inline std::string name() const

inline exec::task<void> publish(std::vector<std::byte> msg)

Variables

std::string_view CONNECT_SUCCESS = "success"

namespace heph

namespace conduit

Enums

enum class RetrievalMethod : std::uint8_t

Values:

enumerator BLOCK

enumerator POLL

enum class SetMethod : std::uint8_t

Values:

enumerator BLOCK

enumerator OVERWRITE

enum class InputState : std::uint8_t

Values:

enumerator OK

enumerator OVERFLOW

template<std::size_t DepthV = 1, RetrievalMethod RetrievalMethodV = RetrievalMethod::BLOCK, SetMethod SetMethodV = SetMethod::BLOCK>
struct InputPolicy

Public Static Attributes

static auto DEPTH = DepthV

static auto RETRIEVAL_METHOD = RetrievalMethodV

static auto SET_METHOD = SetMethodV

namespace heph

namespace conduit

template<typename T, typename InputPolicy = InputPolicy<>>
class AccumulatedInput : public heph::conduit::AccumulatedTransformInputBase<T, std::vector<T>, decltype(&internal::accumulator<T>), InputPolicy<>>

Public Functions

template<typename OperationT, typename DataT>
inline explicit AccumulatedInput(Node<OperationT, DataT> *node, std::string name, std::vector<T> initial_value = std::vector<T>{})

template<typename T, typename R, typename F, typename InputPolicy = InputPolicy<>>
class AccumulatedTransformInputBase : public heph::conduit::detail::InputBase<AccumulatedTransformInputBase<T, R, F, InputPolicy<>>, T, InputPolicy<>::DEPTH>

Public Types

using ValueT = T

using InputPolicyT = InputPolicy

template<typename Receiver, bool Peek>
using Awaiter = detail::Awaiter<AccumulatedTransformInputBase, std::decay_t<Receiver>, Peek>

Public Functions

template<typename OperationT, typename DataT>
inline explicit AccumulatedTransformInputBase(Node<OperationT, DataT> *node, F f, std::string name, R initial_value = R{})

inline std::optional<R> peekValue()

inline std::optional<R> getValue()

Typedefs

template<typename T, typename R, typename InputPolicy = InputPolicy<>>
using AccumulatedTransformInput = AccumulatedTransformInputBase<T, R, std::function<R(T, R&)>, InputPolicy>

namespace heph

namespace concurrency

namespace conduit

namespace heph

namespace conduit

template<typename T, typename InputPolicyT = InputPolicy<>>
class RemoteInputPublisher

Public Functions

inline explicit RemoteInputPublisher(NodeEngine &engine, heph::net::Endpoint endpoint, std::string name, bool reliable = true)

template<typename Output>
inline void connectTo(Output &output)

inline auto &onComplete()

namespace heph

namespace conduit

class NodeEngine

struct ConnectionSpecification

Public Members

detail::InputSpecification input

detail::OutputSpecification output

Public Functions

explicit NodeEngine(const NodeEngineConfig &config)

void run()

void requestStop()

inline auto getStopToken()

inline auto scheduler()

inline bool isCurrent()

inline auto poolScheduler()

inline auto elapsed()

inline std::string prefix() const

std::vector<heph::net::Endpoint> endpoints() const

template<typename OperatorT, typename ...Ts>
inline NodeHandle<OperatorT> createNode(Ts&&... ts)

template<typename Output>
inline void registerOutput(Output &output)

template<typename Node>
inline void registerImplicitOutput(Node &node)

template<typename InputT>
inline void registerInput(InputT *input)

void addConnectionSpecification()

std::string getDotGraph() const

struct NodeEngineConfig

Public Members

heph::concurrency::ContextConfig context_config

std::string prefix

std::uint32_t number_of_threads = {1}

std::vector<heph::net::Endpoint> endpoints

namespace heph

namespace conduit

namespace heph

namespace conduit

template<typename InputT>
class InputSubscriber

struct Node : public heph::conduit::Node<Node, InputSubscriber*>

Public Static Functions

static inline auto name(const Node &self)

static inline auto trigger(Node &self)

static inline auto execute(auto value)

Public Functions

inline InputSubscriber(NodeEngine &engine, InputT &input)

inline NodeHandle<Node> &output()

inline auto name()

namespace heph

namespace conduit

template<typename T>
struct RemoteOutputSubscriber : public heph::conduit::Node<RemoteOutputSubscriber<T>, internal::RemoteSubscriberOperator>

Public Members

std::string type_info = heph::serdes::getSerializedTypeInfo<T>().toJson()

Public Static Functions

static inline auto name(const RemoteOutputSubscriber &self)

static inline auto trigger(RemoteOutputSubscriber *self)

static inline std::optional<T> execute(internal::RemoteSubscriberOperator::MsgT msg)

namespace heph

namespace conduit

template<typename NodeT>
class NodeHandle

Public Functions

inline explicit NodeHandle(NodeT *node)

~NodeHandle() = default

NodeHandle(const NodeHandle&) = default

NodeHandle &=default operator= (const NodeHandle &)

NodeHandle(NodeHandle&&) = default

NodeHandle &=default operator= (NodeHandle &&)

inline NodeT &operator*()

inline NodeT *operator->()

inline NodeT &get()

inline const NodeT &get() const

namespace heph

namespace conduit

Functions

concurrency::Context::Scheduler scheduler(NodeEngine &engine)

namespace heph

namespace conduit

template<typename T, typename InputPolicy = InputPolicy<>>
class QueuedInput : public heph::conduit::detail::InputBase<QueuedInput<T, InputPolicy<>>, T, InputPolicy<>::DEPTH>

Public Types

using ValueT = T

using InputPolicyT = InputPolicy

template<typename Receiver, bool Peek>
using Awaiter = detail::Awaiter<QueuedInput, std::decay_t<Receiver>, Peek>

Public Functions

template<typename OperationT, typename DataT>
inline explicit QueuedInput(Node<OperationT, DataT> *node, std::string name)

inline std::optional<T> peekValue()

inline std::optional<T> getValue()