LambdaStage.h File

Function-based stage executor wrapper. More...

Included Headers

#include "graph/StageExecutor.h" #include "graph/nodes/StageNode.h" #include <functional> #include <memory> #include <string> #include <utility> #include <vector>

Namespaces Index

namespace	simaai
namespace	neat
namespace	graph
namespace	nodes

Classes Index

class	LambdaStage

Description

Function-based stage executor wrapper.

File Listing

The file content with the documentation metadata removed is:

1

6#pragma once

7

8#include "graph/StageExecutor.h"

9#include "graph/nodes/StageNode.h"

10

11#include <functional>

12#include <memory>

13#include <string>

14#include <utility>

15#include <vector>

16

17namespace simaai::neat::graph::nodes {

18

19using LambdaOnInput = std::function<void(StageMsg&&, std::vector<StageOutMsg>&, const StagePorts&)>;

20using LambdaOnTick =

21 std::function<void(std::int64_t, std::vector<StageOutMsg>&, const StagePorts&)>;

22

23class LambdaStage final : public simaai::neat::graph::StageExecutor {

24public:

25 LambdaStage(LambdaOnInput on_input, LambdaOnTick on_tick = {})

26 : on_input_(std::move(on_input)), on_tick_(std::move(on_tick)) {

27 if (!on_input_) {

28 throw std::invalid_argument("LambdaStage: on_input function is required");

29 }

30 }

31

32 void set_ports(const StagePorts& ports) override {

33 ports_ = ports;

34 }

35

36 void on_input(StageMsg&& msg, std::vector<StageOutMsg>& out) override {

37 on_input_(std::move(msg), out, ports_);

38 }

39

40 void on_tick(std::int64_t now_ns, std::vector<StageOutMsg>& out) override {

41 if (on_tick_)

42 on_tick_(now_ns, out, ports_);

43 }

44

45private:

46 StagePorts ports_;

47 LambdaOnInput on_input_;

48 LambdaOnTick on_tick_;

49};

50

51// Convenience: wrap a LambdaStage in a StageNode.

52inline std::shared_ptr<simaai::neat::graph::Node>

53LambdaStageNode(std::string kind, std::vector<std::string> inputs, std::vector<std::string> outputs,

54 LambdaOnInput on_input, std::string label = {}, StageNodeOptions options = {},

55 StageNode::OutputSpecFn out_fn = {}, LambdaOnTick on_tick = {}) {

56 LambdaOnInput fn = std::move(on_input);

57 LambdaOnTick tick = std::move(on_tick);

58 StageNode::StageExecutorFactory factory = [fn, tick]() mutable {

59 return std::make_unique<LambdaStage>(fn, tick);

60 };

61

62 std::vector<PortDesc> in_ports;

63 in_ports.reserve(inputs.size());

64 for (auto& name : inputs) {

65 in_ports.push_back(PortDesc{.name = std::move(name), .spec = OutputSpec{}});

66 }

67

68 std::vector<PortDesc> out_ports;

69 out_ports.reserve(outputs.size());

70 for (auto& name : outputs) {

71 out_ports.push_back(PortDesc{.name = std::move(name), .spec = OutputSpec{}});

72 }

73

74 return std::make_shared<StageNode>(std::move(kind), std::move(factory), std::move(in_ports),

75 std::move(out_ports), std::move(label), std::move(out_fn),

76 std::move(options));

77}

78

79} // namespace simaai::neat::graph::nodes

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.1.