Skip to content

Commit 18ac8b3

Browse files
schlangsterschlangster
committed
Streamlined API. Fold is now Iterate, old Iterate has been removed. The case where the old Iterate would be needed is now covered by the overload for token streams. Shuffled some parameters around for consistency.
1 parent 5fad440 commit 18ac8b3

5 files changed

Lines changed: 93 additions & 220 deletions

File tree

‎include/react/Algorithm.h‎

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -34,95 +34,95 @@ class EventSource;
3434
enum class EventToken;
3535

3636
///////////////////////////////////////////////////////////////////////////////////////////////////
37-
/// Fold
37+
/// Iterate
3838
///////////////////////////////////////////////////////////////////////////////////////////////////
3939
template
4040
<
4141
typename D,
42-
typename V,
4342
typename E,
43+
typename V,
4444
typename FIn,
45-
typename S = std::decay<V>::type
45+
typename S = std::decay<V>::type,
46+
class = std::enable_if<
47+
! std::is_same<E,EventToken>::value>::type
4648
>
47-
auto Fold(V&& init, const Events<D,E>& events, FIn&& func)
49+
auto Iterate(const Events<D,E>& events, V&& init, FIn&& func)
4850
-> Signal<D,S>
4951
{
50-
using REACT_IMPL::FoldNode;
52+
using REACT_IMPL::IterateNode;
5153

5254
using F = std::decay<FIn>::type;
5355

5456
return Signal<D,S>(
55-
std::make_shared<FoldNode<D,S,E,F>>(
57+
std::make_shared<IterateNode<D,S,E,F>>(
5658
std::forward<V>(init), events.NodePtr(), std::forward<FIn>(func)));
5759
}
5860

59-
///////////////////////////////////////////////////////////////////////////////////////////////////
60-
/// FoldByRef - Pass current value as reference
61-
///////////////////////////////////////////////////////////////////////////////////////////////////
61+
// Token stream version
6262
template
6363
<
6464
typename D,
6565
typename V,
66-
typename E,
6766
typename FIn,
6867
typename S = std::decay<V>::type
6968
>
70-
auto FoldByRef(V&& init, const Events<D,E>& events, FIn&& func)
69+
auto Iterate(const Events<D,EventToken>& events, V&& init, FIn&& func)
7170
-> Signal<D,S>
7271
{
73-
using REACT_IMPL::FoldByRefNode;
72+
using REACT_IMPL::IterateNode;
73+
using REACT_IMPL::AddDummyArgWrapper;
7474

7575
using F = std::decay<FIn>::type;
76+
using WrapperT = AddDummyArgWrapper<EventToken,F,S,S>;
7677

7778
return Signal<D,S>(
78-
std::make_shared<FoldByRefNode<D,S,E,F>>(
79-
std::forward<V>(init), events.NodePtr(), std::forward<FIn>(func)));
79+
std::make_shared<IterateNode<D,S,EventToken,WrapperT>>(
80+
std::forward<V>(init), events.NodePtr(), WrapperT{ 0, std::forward<FIn>(func) }));
8081
}
8182

8283
///////////////////////////////////////////////////////////////////////////////////////////////////
83-
/// Iterate
84+
/// IterateByRef - Pass current value as reference
8485
///////////////////////////////////////////////////////////////////////////////////////////////////
8586
template
8687
<
8788
typename D,
88-
typename V,
8989
typename E,
90+
typename V,
9091
typename FIn,
9192
typename S = std::decay<V>::type
9293
>
93-
auto Iterate(V&& init, const Events<D,E>& events, FIn&& func)
94+
auto IterateByRef(const Events<D,E>& events, V&& init, FIn&& func)
9495
-> Signal<D,S>
9596
{
96-
using REACT_IMPL::IterateNode;
97+
using REACT_IMPL::IterateByRefNode;
9798

9899
using F = std::decay<FIn>::type;
99100

100101
return Signal<D,S>(
101-
std::make_shared<IterateNode<D,S,E,F>>(
102+
std::make_shared<IterateByRefNode<D,S,E,F>>(
102103
std::forward<V>(init), events.NodePtr(), std::forward<FIn>(func)));
103104
}
104105

105-
///////////////////////////////////////////////////////////////////////////////////////////////////
106-
/// IterateByRef
107-
///////////////////////////////////////////////////////////////////////////////////////////////////
106+
// Token stream version
108107
template
109108
<
110109
typename D,
111110
typename V,
112-
typename E,
113111
typename FIn,
114112
typename S = std::decay<V>::type
115113
>
116-
auto IterateByRef(V&& init, const Events<D,E>& events, FIn&& func)
114+
auto IterateByRef(const Events<D,EventToken>& events, V&& init, FIn&& func)
117115
-> Signal<D,S>
118116
{
119117
using REACT_IMPL::IterateByRefNode;
118+
using REACT_IMPL::AddDummyArgWrapper;
120119

121120
using F = std::decay<FIn>::type;
121+
using WrapperT = AddDummyArgWrapper<EventToken,F,void,S>;
122122

123123
return Signal<D,S>(
124-
std::make_shared<IterateByRefNode<D,S,E,F>>(
125-
std::forward<V>(init), events.NodePtr(), std::forward<FIn>(func)));
124+
std::make_shared<IterateByRefNode<D,S,EventToken,WrapperT>>(
125+
std::forward<V>(init), events.NodePtr(), WrapperT{ 0, std::forward<FIn>(func) }));
126126
}
127127

128128
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -134,7 +134,7 @@ template
134134
typename V,
135135
typename T = std::decay<V>::type
136136
>
137-
auto Hold(V&& init, const Events<D,T>& events)
137+
auto Hold(const Events<D,T>& events, V&& init)
138138
-> Signal<D,T>
139139
{
140140
using REACT_IMPL::HoldNode;

‎include/react/detail/graph/AlgorithmNodes.h‎

Lines changed: 23 additions & 150 deletions
Original file line numberDiff line numberDiff line change
@@ -16,57 +16,7 @@
1616
/***************************************/ REACT_IMPL_BEGIN /**************************************/
1717

1818
///////////////////////////////////////////////////////////////////////////////////////////////////
19-
/// FoldBaseNode
20-
///////////////////////////////////////////////////////////////////////////////////////////////////
21-
template
22-
<
23-
typename D,
24-
typename S,
25-
typename E
26-
>
27-
class FoldBaseNode : public SignalNode<D,S>
28-
{
29-
public:
30-
template <typename T>
31-
FoldBaseNode(T&& init, const SharedPtrT<EventStreamNode<D,E>>& events) :
32-
SignalNode(std::forward<T>(init)),
33-
events_{ events }
34-
{}
35-
36-
virtual void Tick(void* turnPtr) override
37-
{
38-
using TurnT = typename D::Engine::TurnT;
39-
TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
40-
41-
REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
42-
GetObjectId(*this), turn.Id()));
43-
44-
S newValue = calcNewValue();
45-
46-
REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
47-
GetObjectId(*this), turn.Id()));
48-
49-
if (! impl::Equals(newValue, value_))
50-
{
51-
value_ = newValue;
52-
Engine::OnNodePulse(*this, turn);
53-
}
54-
else
55-
{
56-
Engine::OnNodeIdlePulse(*this, turn);
57-
}
58-
}
59-
60-
virtual int DependencyCount() const override { return 1; }
61-
62-
protected:
63-
SharedPtrT<EventStreamNode<D,E>> events_;
64-
65-
virtual S calcNewValue() const = 0;
66-
};
67-
68-
///////////////////////////////////////////////////////////////////////////////////////////////////
69-
/// FoldNode
19+
/// IterateNode
7020
///////////////////////////////////////////////////////////////////////////////////////////////////
7121
template
7222
<
@@ -75,63 +25,20 @@ template
7525
typename E,
7626
typename TFunc
7727
>
78-
class FoldNode : public FoldBaseNode<D,S,E>
28+
class IterateNode : public SignalNode<D,S>
7929
{
8030
public:
8131
template <typename T, typename F>
82-
FoldNode(T&& init, const SharedPtrT<EventStreamNode<D,E>>& events, F&& func) :
83-
FoldBaseNode(std::forward<T>(init), events),
32+
IterateNode(T&& init, const std::shared_ptr<EventStreamNode<D,E>>& events, F&& func) :
33+
SignalNode{ std::forward<T>(init) },
34+
events_{ events },
8435
func_{ std::forward<F>(func) }
8536
{
8637
Engine::OnNodeCreate(*this);
8738
Engine::OnNodeAttach(*this, *events);
8839
}
8940

90-
~FoldNode()
91-
{
92-
Engine::OnNodeDetach(*this, *events_);
93-
Engine::OnNodeDestroy(*this);
94-
}
95-
96-
virtual const char* GetNodeType() const override { return "FoldNode"; }
97-
98-
protected:
99-
TFunc func_;
100-
101-
virtual S calcNewValue() const override
102-
{
103-
S newValue = value_;
104-
for (const auto& e : events_->Events())
105-
newValue = func_(newValue,e);
106-
107-
return newValue;
108-
}
109-
};
110-
111-
///////////////////////////////////////////////////////////////////////////////////////////////////
112-
/// FoldByRefNode
113-
///////////////////////////////////////////////////////////////////////////////////////////////////
114-
template
115-
<
116-
typename D,
117-
typename S,
118-
typename E,
119-
typename TFunc
120-
>
121-
class FoldByRefNode : public SignalNode<D,S>
122-
{
123-
public:
124-
template <typename T, typename F>
125-
FoldByRefNode(T&& init, const SharedPtrT<EventStreamNode<D,E>>& events, F&& func) :
126-
SignalNode(std::forward<T>(init)),
127-
func_{ std::forward<F>(func) },
128-
events_{ events }
129-
{
130-
Engine::OnNodeCreate(*this);
131-
Engine::OnNodeAttach(*this, *events);
132-
}
133-
134-
~FoldByRefNode()
41+
~IterateNode()
13542
{
13643
Engine::OnNodeDetach(*this, *events_);
13744
Engine::OnNodeDestroy(*this);
@@ -145,65 +52,31 @@ class FoldByRefNode : public SignalNode<D,S>
14552
REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
14653
GetObjectId(*this), turn.Id()));
14754

55+
S newValue = value_;
14856
for (const auto& e : events_->Events())
149-
func_(value_,e);
57+
newValue = func_(e, newValue);
15058

15159
REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
15260
GetObjectId(*this), turn.Id()));
15361

154-
// Always assume change
155-
Engine::OnNodePulse(*this, turn);
156-
}
157-
158-
virtual const char* GetNodeType() const override { return "FoldByRefNode"; }
159-
virtual int DependencyCount() const override { return 1; }
160-
161-
protected:
162-
TFunc func_;
163-
164-
SharedPtrT<EventStreamNode<D,E>> events_;
165-
};
166-
167-
///////////////////////////////////////////////////////////////////////////////////////////////////
168-
/// IterateNode
169-
///////////////////////////////////////////////////////////////////////////////////////////////////
170-
template
171-
<
172-
typename D,
173-
typename S,
174-
typename E,
175-
typename TFunc
176-
>
177-
class IterateNode : public FoldBaseNode<D,S,E>
178-
{
179-
public:
180-
template <typename T, typename F>
181-
IterateNode(T&& init, const SharedPtrT<EventStreamNode<D,E>>& events, F&& func) :
182-
FoldBaseNode(std::forward<T>(init), events),
183-
func_{ std::forward<F>(func) }
184-
{
185-
Engine::OnNodeCreate(*this);
186-
Engine::OnNodeAttach(*this, *events);
187-
}
188-
189-
~IterateNode()
190-
{
191-
Engine::OnNodeDetach(*this, *events_);
192-
Engine::OnNodeDestroy(*this);
62+
if (! impl::Equals(newValue, value_))
63+
{
64+
value_ = std::move(newValue);
65+
Engine::OnNodePulse(*this, turn);
66+
}
67+
else
68+
{
69+
Engine::OnNodeIdlePulse(*this, turn);
70+
}
19371
}
19472

19573
virtual const char* GetNodeType() const override { return "IterateNode"; }
74+
virtual int DependencyCount() const override { return 1; }
19675

197-
protected:
76+
private:
77+
SharedPtrT<EventStreamNode<D,E>> events_;
78+
19879
TFunc func_;
199-
200-
virtual S calcNewValue() const override
201-
{
202-
S newValue = value_;
203-
for (const auto& e : events_->Events())
204-
newValue = func_(newValue);
205-
return newValue;
206-
}
20780
};
20881

20982
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -221,7 +94,7 @@ class IterateByRefNode : public SignalNode<D,S>
22194
public:
22295
template <typename T, typename F>
22396
IterateByRefNode(T&& init, const SharedPtrT<EventStreamNode<D,E>>& events, F&& func) :
224-
SignalNode(std::forward<T>(init)),
97+
SignalNode{ std::forward<T>(init) },
22598
func_{ std::forward<F>(func) },
22699
events_{ events }
227100
{
@@ -244,7 +117,7 @@ class IterateByRefNode : public SignalNode<D,S>
244117
GetObjectId(*this), turn.Id()));
245118

246119
for (const auto& e : events_->Events())
247-
func_(value_);
120+
func_(e, value_);
248121

249122
REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
250123
GetObjectId(*this), turn.Id()));

0 commit comments

Comments
 (0)