Skip to content

Commit d7c2e2d

Browse files
schlangsterschlangster
committed
wip refactoring
1 parent 1116f3a commit d7c2e2d

11 files changed

Lines changed: 476 additions & 637 deletions

File tree

‎include/react/Algorithm.h‎

Lines changed: 13 additions & 134 deletions
Original file line numberDiff line numberDiff line change
@@ -30,30 +30,12 @@ template <typename T, typename E>
3030
auto Hold(const Group& group, T&& initialValue, const Event<E>& evnt) -> Signal<E>
3131
{
3232
using REACT_IMPL::HoldNode;
33-
using REACT_IMPL::PrivateEventLinkNodeInterface;
34-
using REACT_IMPL::PrivateGroupInterface;
35-
using REACT_IMPL::PrivateNodeInterface;
36-
using REACT_IMPL::CtorTag;
37-
38-
const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
39-
40-
return PrivateNodeInterface::CreateNodeHelper<Signal<E>, HoldNode<E>>(
41-
graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
33+
return Signal<E>::CreateWithNode<HoldNode<E>>(group, std::forward<T>(initialValue), SameGroupOrLink(group, evnt));
4234
}
4335

4436
template <typename T, typename E>
4537
auto Hold(T&& initialValue, const Event<E>& evnt) -> Signal<E>
46-
{
47-
using REACT_IMPL::HoldNode;
48-
using REACT_IMPL::PrivateEventLinkNodeInterface;
49-
using REACT_IMPL::PrivateNodeInterface;
50-
using REACT_IMPL::CtorTag;
51-
52-
const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
53-
54-
return PrivateNodeInterface::CreateNodeHelper<Signal<E>, HoldNode<E>>(
55-
graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
56-
}
38+
{ return Hold(evnt.GetGroup(), std::forward<T>(initialValue), evnt); }
5739

5840
///////////////////////////////////////////////////////////////////////////////////////////////////
5941
/// Monitor - Emits value changes of target signal
@@ -62,28 +44,12 @@ template <typename S>
6244
auto Monitor(const Group& group, const Signal<S>& signal) -> Event<S>
6345
{
6446
using REACT_IMPL::MonitorNode;
65-
using REACT_IMPL::PrivateSignalLinkNodeInterface;
66-
using REACT_IMPL::PrivateGroupInterface;
67-
using REACT_IMPL::PrivateNodeInterface;
68-
69-
const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
70-
71-
return PrivateNodeInterface::CreateNodeHelper<Event<S>, MonitorNode<S>>(
72-
graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal));
47+
return Event<S>::CreateWithNode<MonitorNode<S>>(group, SameGroupOrLink(group, signal));
7348
}
7449

7550
template <typename S>
7651
auto Monitor(const Signal<S>& signal) -> Event<S>
77-
{
78-
using REACT_IMPL::MonitorNode;
79-
using REACT_IMPL::PrivateSignalLinkNodeInterface;
80-
using REACT_IMPL::PrivateNodeInterface;
81-
82-
const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
83-
84-
return PrivateNodeInterface::CreateNodeHelper<Event<S>, MonitorNode<S>>(
85-
graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal));
86-
}
52+
{ return Monitor(signal.GetGroup(), signal); }
8753

8854
///////////////////////////////////////////////////////////////////////////////////////////////////
8955
/// Iterate - Iteratively combines signal value with values from event stream (aka Fold)
@@ -94,43 +60,19 @@ auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evn
9460
using REACT_IMPL::IterateNode;
9561
using REACT_IMPL::IterateByRefNode;
9662
using REACT_IMPL::IsCallableWith;
97-
using REACT_IMPL::PrivateEventLinkNodeInterface;
98-
using REACT_IMPL::PrivateGroupInterface;
99-
using REACT_IMPL::PrivateNodeInterface;
10063

10164
using FuncType = typename std::decay<F>::type;
10265
using IterNodeType = typename std::conditional<
10366
IsCallableWith<F,S,EventRange<E>,S>::value,
10467
IterateNode<S, FuncType, E>,
10568
IterateByRefNode<S, FuncType, E>>::type;
10669

107-
const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
108-
109-
return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
110-
graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
70+
return Signal<S>::CreateWithNode<IterNodeType>(group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt));
11171
}
11272

11373
template <typename S, typename T, typename F, typename E>
11474
auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
115-
{
116-
using REACT_IMPL::IterateNode;
117-
using REACT_IMPL::IterateByRefNode;
118-
using REACT_IMPL::IsCallableWith;
119-
using REACT_IMPL::PrivateEventLinkNodeInterface;
120-
using REACT_IMPL::PrivateNodeInterface;
121-
using REACT_IMPL::CtorTag;
122-
123-
using FuncType = typename std::decay<F>::type;
124-
using IterNodeType = typename std::conditional<
125-
IsCallableWith<F,S,EventRange<E>,S>::value,
126-
IterateNode<S, FuncType, E>,
127-
IterateByRefNode<S, FuncType, E>>::type;
128-
129-
const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
130-
131-
return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
132-
graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
133-
}
75+
{ return Iterate<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt); }
13476

13577
///////////////////////////////////////////////////////////////////////////////////////////////////
13678
/// Iterate - Synced
@@ -141,46 +83,20 @@ auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evn
14183
using REACT_IMPL::SyncedIterateNode;
14284
using REACT_IMPL::SyncedIterateByRefNode;
14385
using REACT_IMPL::IsCallableWith;
144-
using REACT_IMPL::PrivateSignalLinkNodeInterface;
145-
using REACT_IMPL::PrivateEventLinkNodeInterface;
146-
using REACT_IMPL::PrivateGroupInterface;
147-
using REACT_IMPL::PrivateNodeInterface;
14886

14987
using FuncType = typename std::decay<F>::type;
15088
using IterNodeType = typename std::conditional<
15189
IsCallableWith<F, S, EventRange<E>, S, Us ...>::value,
15290
SyncedIterateNode<S, FuncType, E, Us ...>,
15391
SyncedIterateByRefNode<S, FuncType, E, Us ...>>::type;
15492

155-
const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
156-
157-
return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
158-
graphPtr, std::forward<T>(initialValue), std::forward<F>(func),
159-
PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...);
93+
return Signal<S>::CreateWithNode<IterNodeType>(
94+
group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt), SameGroupOrLink(group, signals) ...);
16095
}
16196

16297
template <typename S, typename T, typename F, typename E, typename ... Us>
16398
auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
164-
{
165-
using REACT_IMPL::SyncedIterateNode;
166-
using REACT_IMPL::SyncedIterateByRefNode;
167-
using REACT_IMPL::IsCallableWith;
168-
using REACT_IMPL::PrivateSignalLinkNodeInterface;
169-
using REACT_IMPL::PrivateEventLinkNodeInterface;;
170-
using REACT_IMPL::PrivateNodeInterface;
171-
172-
using FuncType = typename std::decay<F>::type;
173-
using IterNodeType = typename std::conditional<
174-
IsCallableWith<F, S, EventRange<E>, S, Us ...>::value,
175-
SyncedIterateNode<S, FuncType, E, Us ...>,
176-
SyncedIterateByRefNode<S, FuncType, E, Us ...>>::type;
177-
178-
const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
179-
180-
return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
181-
graphPtr, std::forward<T>(initialValue), std::forward<F>(func),
182-
PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...);
183-
}
99+
{ return Iterate<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt, signals ...); }
184100

185101
///////////////////////////////////////////////////////////////////////////////////////////////////
186102
/// Snapshot - Sets signal value to value of other signal when event is received
@@ -189,30 +105,12 @@ template <typename S, typename E>
189105
auto Snapshot(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
190106
{
191107
using REACT_IMPL::SnapshotNode;
192-
using REACT_IMPL::PrivateSignalLinkNodeInterface;
193-
using REACT_IMPL::PrivateEventLinkNodeInterface;;
194-
using REACT_IMPL::PrivateGroupInterface;
195-
using REACT_IMPL::PrivateNodeInterface;
196-
197-
const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
198-
199-
return PrivateNodeInterface::CreateNodeHelper<Signal<S>, SnapshotNode<S, E>>(
200-
graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
108+
return Signal<S>::CreateWithNode<SnapshotNode<S, E>>(group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
201109
}
202110

203111
template <typename S, typename E>
204112
auto Snapshot(const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
205-
{
206-
using REACT_IMPL::SnapshotNode;
207-
using REACT_IMPL::PrivateSignalLinkNodeInterface;
208-
using REACT_IMPL::PrivateEventLinkNodeInterface;;
209-
using REACT_IMPL::PrivateNodeInterface;
210-
211-
const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
212-
213-
return PrivateNodeInterface::CreateNodeHelper<Signal<S>, SnapshotNode<S, E>>(
214-
graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
215-
}
113+
{ return Snapshot(signal.GetGroup(), signal, evnt); }
216114

217115
///////////////////////////////////////////////////////////////////////////////////////////////////
218116
/// Pulse - Emits value of target signal when event is received
@@ -221,31 +119,12 @@ template <typename S, typename E>
221119
auto Pulse(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
222120
{
223121
using REACT_IMPL::PulseNode;
224-
using REACT_IMPL::PrivateSignalLinkNodeInterface;
225-
using REACT_IMPL::PrivateEventLinkNodeInterface;;
226-
using REACT_IMPL::PrivateGroupInterface;
227-
using REACT_IMPL::PrivateNodeInterface;
228-
229-
const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
230-
231-
return PrivateNodeInterface::CreateNodeHelper<Event<S>, PulseNode<S, E>>(
232-
graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
122+
return Event<S>::CreateWithNode<PulseNode<S, E>>(group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
233123
}
234124

235125
template <typename S, typename E>
236126
auto Pulse(const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
237-
{
238-
using REACT_IMPL::PulseNode;
239-
using REACT_IMPL::PrivateSignalLinkNodeInterface;
240-
using REACT_IMPL::PrivateEventLinkNodeInterface;;
241-
using REACT_IMPL::PrivateNodeInterface;
242-
using REACT_IMPL::CtorTag;
243-
244-
const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
245-
246-
return PrivateNodeInterface::CreateNodeHelper<Event<S>, PulseNode<S, E>>(
247-
graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
248-
}
127+
{ return Pulse(signal.GetGroup(), signal, evnt); }
249128

250129
/******************************************/ REACT_END /******************************************/
251130

0 commit comments

Comments
 (0)