{

using REACT_IMPL::EventProcessingNode;

using REACT_IMPL::SameGroupOrLink;

return std::make_shared<EventProcessingNode<E, T, typename std::decay<F>::type>>(

group, std::forward<F>(func), SameGroupOrLink(group, dep));

{

using REACT_IMPL::SyncedEventProcessingNode;

using REACT_IMPL::SameGroupOrLink;

return std::make_shared<SyncedEventProcessingNode<E, T, typename std::decay<F>::type, Us ...>>(

group, std::forward<F>(func), SameGroupOrLink(group, dep), SameGroupOrLink(group, syncs) ...);

{

// Construct event source

static EventSource Create(const Group& group)

{ return CreateSourceNode(group); }

EventSource() = default;

EventSource(const EventSource&) = default;

EventSource& operator=(const EventSource&) = default;

EventSource(EventSource&& other) = default;

EventSource& operator=(EventSource&& other) = default;

void Emit(const E& value)

{ EmitValue(value); }

void Emit(E&& value)

{ EmitValue(std::move(value)); }

template <typename T = E, typename = std::enable_if_t<std::is_same_v<T, Token>>>

void Emit()

{ EmitValue(Token::value); }

EventSource& operator<<(const E& value)

{ EmitValue(value); return *this; }

EventSource& operator<<(E&& value)

{ EmitValue(std::move(value)); return *this; }

EventSource(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :

EventSource::Event( std::move(nodePtr) )

{ }

static auto CreateSourceNode(const Group& group) -> decltype(auto)

{

using REACT_IMPL::EventSourceNode;

return std::make_shared<EventSourceNode<E>>(group);

}

template <typename T>

void EmitValue(T&& value)

{

using REACT_IMPL::NodeId;

using REACT_IMPL::ReactGraph;

using REACT_IMPL::EventSourceNode;

auto* castedPtr = static_cast<EventSourceNode<E>*>(this->GetNodePtr().get());

NodeId nodeId = castedPtr->GetNodeId();

auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();

graphPtr->PushInput(nodeId, [castedPtr, &value] { castedPtr->EmitValue(std::forward<T>(value)); });

}

{

// Construct emtpy slot

static EventSlot Create(const Group& group)

{ return CreateSlotNode(group); }

EventSlot() = default;

EventSlot(const EventSlot&) = default;

EventSlot& operator=(const EventSlot&) = default;

EventSlot(EventSlot&&) = default;

EventSlot& operator=(EventSlot&&) = default;

void Add(const Event<E>& input)

{ AddSlotInput(input); }

void Remove(const Event<E>& input)

{ RemoveSlotInput(input); }

void RemoveAll()

{ RemoveAllSlotInputs(); }

EventSlot(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :

EventSlot::Event( std::move(nodePtr) )

{ }

static auto CreateSlotNode(const Group& group) -> decltype(auto)

{

using REACT_IMPL::EventSlotNode;

return std::make_shared<EventSlotNode<E>>(group);

}

void AddSlotInput(const Event<E>& input)

{

using REACT_IMPL::NodeId;

using SlotNodeType = REACT_IMPL::EventSlotNode<E>;

SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->GetNodePtr().get());

NodeId nodeId = castedPtr->GetInputNodeId();

auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();

graphPtr->PushInput(nodeId, [this, castedPtr, &input] { castedPtr->AddSlotInput(SameGroupOrLink(GetGroup(), input)); });

}

void RemoveSlotInput(const Event<E>& input)

{

using REACT_IMPL::NodeId;

using SlotNodeType = REACT_IMPL::EventSlotNode<E>;

SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->GetNodePtr().get());

NodeId nodeId = castedPtr->GetInputNodeId();

auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();

graphPtr->PushInput(nodeId, [this, castedPtr, &input] { castedPtr->RemoveSlotInput(SameGroupOrLink(GetGroup(), input)); });

}

void RemoveAllSlotInputs()

{

using REACT_IMPL::NodeId;

using SlotNodeType = REACT_IMPL::EventSlotNode<E>;

SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->GetNodePtr().get());

NodeId nodeId = castedPtr->GetInputNodeId();

auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();

graphPtr->PushInput(nodeId, [castedPtr] { castedPtr->RemoveAllSlotInputs(); });

}

{

// Construct with group

static EventLink Create(const Group& group, const Event<E>& input)

{ return GetOrCreateLinkNode(group, input); }

EventLink() = default;

EventLink(const EventLink&) = default;

EventLink& operator=(const EventLink&) = default;

EventLink(EventLink&&) = default;

EventLink& operator=(EventLink&&) = default;

EventLink(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :

EventLink::Event( std::move(nodePtr) )

{ }

static auto GetOrCreateLinkNode(const Group& group, const Event<E>& input) -> decltype(auto)

{

using REACT_IMPL::EventLinkNode;

using REACT_IMPL::IReactNode;

using REACT_IMPL::ReactGraph;

IReactNode* k = GetInternals(input).GetNodePtr().get();

ReactGraph::LinkCache& linkCache = GetInternals(group).GetGraphPtr()->GetLinkCache();

std::shared_ptr<IReactNode> nodePtr = linkCache.LookupOrCreate(k, [&]

{

auto nodePtr = std::make_shared<EventLinkNode<E>>(group, input);

nodePtr->SetWeakSelfPtr(std::weak_ptr<EventLinkNode<E>>{ nodePtr });

return std::static_pointer_cast<IReactNode>(nodePtr);

});

return std::static_pointer_cast<EventLinkNode<E>>(nodePtr);

}

{

using REACT_IMPL::EventMergeNode;

using REACT_IMPL::SameGroupOrLink;

using REACT_IMPL::CreateWrappedNode;

return CreateWrappedNode<Event<E>, EventMergeNode<E, E, Us ...>>(

group, SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);

{

auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& events, EventValueSink<E> out)

{ std::copy_if(events.begin(), events.end(), out, capturedPred); };

return Event<E>::Create(group, std::move(filterFunc), dep);

{

auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& evts, EventValueSink<E> out, const Ts& ... values)

{

for (const auto& v : evts)

if (capturedPred(v, values ...))

*out++ = v;

};

return Event<E>::Create(group, std::move(filterFunc), dep, states ...);

{

auto transformFunc = [capturedOp = std::forward<F>(op)] (const EventValueList<T>& evts, EventValueSink<E> out)

{ std::transform(evts.begin(), evts.end(), out, capturedOp); };

return Event<E>::Create(group, std::move(transformFunc), dep);

{

auto transformFunc = [capturedOp = std::forward<F>(op)] (const EventValueList<T>& evts, EventValueSink<E> out, const Us& ... values)

{

for (const auto& v : evts)

*out++ = capturedOp(v, values ...);

};

return Event<E>::Create(group, std::move(transformFunc), dep, states ...);

{

using REACT_IMPL::EventJoinNode;

using REACT_IMPL::SameGroupOrLink;

using REACT_IMPL::CreateWrappedNode;

static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");

return CreateWrappedNode<Event<std::tuple<U1, Us ...>>, EventJoinNode<U1, Us ...>>(

group, SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);

{

if (dep.GetGroup() == targetGroup)

return dep;

else

return EventLink<E>::Create(targetGroup, dep);