19#ifndef HEDGEHOG_CX_NODE_H_
20#define HEDGEHOG_CX_NODE_H_
26#include "../tools/concepts.h"
27#include "../tools/meta_functions.h"
29#include "../behavior/abstract_node.h"
43 typename HedgehogDynamicNodeType::inputs_t> &&...)
44class Node :
public hh_cx::behavior::AbstractNode {
46 std::vector<std::string>
50 constInputTypesAsName_{};
53 using ro_type_t = std::tuple<InputTypesRO...>;
54 using dynamic_node_t = HedgehogDynamicNodeType;
55 using inputs_t =
typename HedgehogDynamicNodeType::inputs_t;
56 using outputs_t =
typename HedgehogDynamicNodeType::outputs_t;
60 constexpr explicit Node(std::string
const &name) : AbstractNode(name) {
61 using OutputIndices = std::make_index_sequence<std::tuple_size_v<outputs_t>>;
62 using ROIndices = std::make_index_sequence<std::tuple_size_v<ro_type_t>>;
63 using InputIndices = std::make_index_sequence<std::tuple_size_v<ro_type_t>>;
64 registerInputType(InputIndices{});
65 registerROInputType(ROIndices{});
66 registerOutputType(OutputIndices{});
70 constexpr ~Node()
override =
default;
74 [[nodiscard]]
constexpr bool isCanTerminateOverloaded() const final {
75 if constexpr (std::is_base_of_v<hh::behavior::CanTerminate, HedgehogDynamicNodeType>) {
77 hh_cx::tool::AbstractTask_t<
78 std::tuple_size_v<inputs_t>,
79 hh_cx::tool::CatTuples_t<inputs_t, outputs_t>
82 using stateManager_t =
83 hh_cx::tool::StateManager_t<
84 std::tuple_size_v<inputs_t>,
85 hh_cx::tool::CatTuples_t<inputs_t, outputs_t>
88 if constexpr (std::is_base_of_v<task_t, HedgehogDynamicNodeType>) {
89 return !std::is_same_v<
decltype(&task_t::canTerminate),
decltype(&dynamic_node_t::canTerminate)>;
90 }
else if constexpr (std::is_base_of_v<stateManager_t, HedgehogDynamicNodeType>) {
91 return !std::is_same_v<
decltype(&stateManager_t::canTerminate),
decltype(&dynamic_node_t::canTerminate)>;
93 throw std::runtime_error(
"The overload detection can not detect the tested type");
102 [[nodiscard]]
constexpr bool isTypeAnROType(std::string
const &typeName)
const final {
104 roTypesAsName_.cbegin(), roTypesAsName_.cend(),
105 [&typeName](
auto const &type) { return type == typeName; });
111 [[nodiscard]]
constexpr bool isTypeAConstType(std::string
const &typeName)
const final {
113 constInputTypesAsName_.cbegin(), constInputTypesAsName_.cend(),
114 [&typeName](
auto const &type) { return type == typeName; });
120 template<
size_t ...Indices>
121 constexpr void registerInputType(std::index_sequence<Indices...>) {
122 (inputTypesAsName_.push_back(
hh::tool::typeToStr<std::tuple_element_t<Indices, inputs_t>>()), ...);
123 (testAndRegisterConstInputType<std::tuple_element_t<Indices, inputs_t>>(), ...);
129 constexpr void testAndRegisterConstInputType() {
130 if (std::is_const_v<T>) { constInputTypesAsName_.push_back(hh::tool::typeToStr<T>()); }
135 template<
size_t ...Indices>
136 constexpr void registerOutputType(std::index_sequence<Indices...>) {
137 (outputTypesAsName_.push_back(
hh::tool::typeToStr<std::tuple_element_t<Indices, outputs_t>>()), ...);
142 template<
size_t ...Indices>
143 constexpr void registerROInputType(std::index_sequence<Indices...>) {
144 (roTypesAsName_.push_back(
hh::tool::typeToStr<std::tuple_element_t<Indices, ro_type_t>>()), ...);
constexpr auto typeToStr()
Create a string containing the type name.
Concept verifying that a type is in a tuple.