Skip to content

Commit a5f3628

Browse files
schlangsterschlangster
committed
Removed special handling of token streams that would allow their value being omitted from client function signatures. Instead, an unnamed parameter of type "Token" can be declared.
This makes it easier to identify token streams, the extra boilerplate is minimal and the API is simplified.
1 parent 18ac8b3 commit a5f3628

9 files changed

Lines changed: 38 additions & 254 deletions

File tree

‎include/react/Algorithm.h‎

Lines changed: 6 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ class Events;
3131
template <typename D, typename E>
3232
class EventSource;
3333

34-
enum class EventToken;
34+
enum class Token;
3535

3636
///////////////////////////////////////////////////////////////////////////////////////////////////
3737
/// Iterate
@@ -42,9 +42,7 @@ template
4242
typename E,
4343
typename V,
4444
typename FIn,
45-
typename S = std::decay<V>::type,
46-
class = std::enable_if<
47-
! std::is_same<E,EventToken>::value>::type
45+
typename S = std::decay<V>::type
4846
>
4947
auto Iterate(const Events<D,E>& events, V&& init, FIn&& func)
5048
-> Signal<D,S>
@@ -58,28 +56,6 @@ auto Iterate(const Events<D,E>& events, V&& init, FIn&& func)
5856
std::forward<V>(init), events.NodePtr(), std::forward<FIn>(func)));
5957
}
6058

61-
// Token stream version
62-
template
63-
<
64-
typename D,
65-
typename V,
66-
typename FIn,
67-
typename S = std::decay<V>::type
68-
>
69-
auto Iterate(const Events<D,EventToken>& events, V&& init, FIn&& func)
70-
-> Signal<D,S>
71-
{
72-
using REACT_IMPL::IterateNode;
73-
using REACT_IMPL::AddDummyArgWrapper;
74-
75-
using F = std::decay<FIn>::type;
76-
using WrapperT = AddDummyArgWrapper<EventToken,F,S,S>;
77-
78-
return Signal<D,S>(
79-
std::make_shared<IterateNode<D,S,EventToken,WrapperT>>(
80-
std::forward<V>(init), events.NodePtr(), WrapperT{ 0, std::forward<FIn>(func) }));
81-
}
82-
8359
///////////////////////////////////////////////////////////////////////////////////////////////////
8460
/// IterateByRef - Pass current value as reference
8561
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -103,28 +79,6 @@ auto IterateByRef(const Events<D,E>& events, V&& init, FIn&& func)
10379
std::forward<V>(init), events.NodePtr(), std::forward<FIn>(func)));
10480
}
10581

106-
// Token stream version
107-
template
108-
<
109-
typename D,
110-
typename V,
111-
typename FIn,
112-
typename S = std::decay<V>::type
113-
>
114-
auto IterateByRef(const Events<D,EventToken>& events, V&& init, FIn&& func)
115-
-> Signal<D,S>
116-
{
117-
using REACT_IMPL::IterateByRefNode;
118-
using REACT_IMPL::AddDummyArgWrapper;
119-
120-
using F = std::decay<FIn>::type;
121-
using WrapperT = AddDummyArgWrapper<EventToken,F,void,S>;
122-
123-
return Signal<D,S>(
124-
std::make_shared<IterateByRefNode<D,S,EventToken,WrapperT>>(
125-
std::forward<V>(init), events.NodePtr(), WrapperT{ 0, std::forward<FIn>(func) }));
126-
}
127-
12882
///////////////////////////////////////////////////////////////////////////////////////////////////
12983
/// Hold
13084
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -209,10 +163,10 @@ template
209163
typename S
210164
>
211165
auto Changed(const Signal<D,S>& target)
212-
-> Events<D,EventToken>
166+
-> Events<D,Token>
213167
{
214168
return Monitor(target)
215-
.Transform([] (const S& v) { return EventToken::token; });
169+
.Transform([] (const S& v) { return Token::token; });
216170
}
217171

218172
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -225,12 +179,12 @@ template
225179
typename S = std::decay<V>::type
226180
>
227181
auto ChangedTo(const Signal<D,S>& target, V&& value)
228-
-> Events<D,EventToken>
182+
-> Events<D,Token>
229183
{
230184
return Monitor(target)
231185
.Transform([=] (const S& v) { return v == value; })
232186
.Filter([] (bool v) { return v == true; })
233-
.Transform([=] (const S& v) { return EventToken::token; })
187+
.Transform([=] (const S& v) { return Token::token; })
234188
}
235189

236190
/******************************************/ REACT_END /******************************************/

‎include/react/Domain.h‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ class EventSource;
5252
template <typename D, typename E, typename TOp>
5353
class TempEvents;
5454

55-
enum class EventToken;
55+
enum class Token;
5656

5757
using REACT_IMPL::TurnFlagsT;
5858

@@ -79,10 +79,10 @@ class DomainBase
7979
template <typename S>
8080
using VarSignalT = VarSignal<D,S>;
8181

82-
template <typename E = EventToken>
82+
template <typename E = Token>
8383
using EventsT = Events<D,E>;
8484

85-
template <typename E = EventToken>
85+
template <typename E = Token>
8686
using EventSourceT = EventSource<D,E>;
8787

8888
using ObserverT = Observer<D>;
@@ -152,7 +152,7 @@ class DomainBase
152152
}
153153

154154
static auto MakeEventSource()
155-
-> EventSourceT<EventToken>
155+
-> EventSourceT<Token>
156156
{
157157
return REACT::MakeEventSource<D>();
158158
}

‎include/react/Event.h‎

Lines changed: 11 additions & 98 deletions
Original file line numberDiff line numberDiff line change
@@ -29,17 +29,17 @@ template <typename D, typename ... TValues>
2929
class SignalPack;
3030

3131
///////////////////////////////////////////////////////////////////////////////////////////////////
32-
/// EventToken
32+
/// Token
3333
///////////////////////////////////////////////////////////////////////////////////////////////////
34-
enum class EventToken { token };
34+
enum class Token { value };
3535

3636
///////////////////////////////////////////////////////////////////////////////////////////////////
3737
/// Events
3838
///////////////////////////////////////////////////////////////////////////////////////////////////
3939
template
4040
<
4141
typename D,
42-
typename E = EventToken
42+
typename E = Token
4343
>
4444
class Events : public REACT_IMPL::EventStreamBase<D,E>
4545
{
@@ -175,7 +175,7 @@ class Events<D,E&> : public REACT_IMPL::EventStreamBase<D,std::reference_wrapper
175175
template
176176
<
177177
typename D,
178-
typename E = EventToken
178+
typename E = Token
179179
>
180180
class EventSource : public Events<D,E>
181181
{
@@ -205,10 +205,10 @@ class EventSource : public Events<D,E>
205205
BaseT::emit(std::move(e));
206206
}
207207

208-
template <class = std::enable_if<std::is_same<E,EventToken>::value>::type>
208+
template <class = std::enable_if<std::is_same<E,Token>::value>::type>
209209
void Emit() const
210210
{
211-
BaseT::emit(EventToken::token);
211+
BaseT::emit(Token::value);
212212
}
213213

214214
const EventSource& operator<<(const E& e) const
@@ -343,12 +343,12 @@ auto MakeEventSource()
343343

344344
template <typename D>
345345
auto MakeEventSource()
346-
-> EventSource<D,EventToken>
346+
-> EventSource<D,Token>
347347
{
348348
using REACT_IMPL::EventSourceNode;
349349

350-
return EventSource<D,EventToken>(
351-
std::make_shared<EventSourceNode<D,EventToken>>());
350+
return EventSource<D,Token>(
351+
std::make_shared<EventSourceNode<D,Token>>());
352352
}
353353

354354
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -537,9 +537,7 @@ template
537537
typename D,
538538
typename E,
539539
typename FIn,
540-
typename ... TDepValues,
541-
class = std::enable_if<
542-
! std::is_same<E,EventToken>::value>::type
540+
typename ... TDepValues
543541
>
544542
auto Filter(const Events<D,E>& source, SignalPack<D,TDepValues...> depPack, FIn&& func)
545543
-> Events<D,E>
@@ -572,46 +570,6 @@ auto Filter(const Events<D,E>& source, SignalPack<D,TDepValues...> depPack, FIn&
572570
depPack.Data);
573571
}
574572

575-
// Token stream version
576-
template
577-
<
578-
typename D,
579-
typename FIn,
580-
typename ... TDepValues
581-
>
582-
auto Filter(const Events<D,EventToken>& source, SignalPack<D,TDepValues...> depPack, FIn&& func)
583-
-> Events<D,EventToken>
584-
{
585-
using REACT_IMPL::SyncedEventFilterNode;
586-
using REACT_IMPL::AddDummyArgWrapper;
587-
588-
using F = std::decay<FIn>::type;
589-
using WrapperT = AddDummyArgWrapper<EventToken,F,bool,const TDepValues...>;
590-
591-
struct NodeBuilder_
592-
{
593-
NodeBuilder_(const Events<D,EventToken>& source, WrapperT&& wrapper) :
594-
MySource{ source },
595-
MyWrapper{ std::move(wrapper) }
596-
{}
597-
598-
auto operator()(const Signal<D,TDepValues>& ... deps)
599-
-> Events<D,EventToken>
600-
{
601-
return Events<D,EventToken>(
602-
std::make_shared<SyncedEventFilterNode<D,EventToken,WrapperT,TDepValues ...>>(
603-
MySource.NodePtr(), std::move(MyWrapper), deps.NodePtr() ...));
604-
}
605-
606-
const Events<D,EventToken>& MySource;
607-
WrapperT&& MyWrapper;
608-
};
609-
610-
return REACT_IMPL::apply(
611-
NodeBuilder_{ source, WrapperT{ 0, std::forward<FIn>(func) } },
612-
depPack.Data);
613-
}
614-
615573
///////////////////////////////////////////////////////////////////////////////////////////////////
616574
/// Transform
617575
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -664,9 +622,7 @@ template
664622
typename TIn,
665623
typename FIn,
666624
typename ... TDepValues,
667-
typename TOut = std::result_of<FIn(TIn,TDepValues...)>::type,
668-
class = std::enable_if<
669-
! std::is_same<TIn,EventToken>::value>::type
625+
typename TOut = std::result_of<FIn(TIn,TDepValues...)>::type
670626
>
671627
auto Transform(const Events<D,TIn>& source, SignalPack<D,TDepValues...> depPack, FIn&& func)
672628
-> Events<D,TOut>
@@ -699,49 +655,6 @@ auto Transform(const Events<D,TIn>& source, SignalPack<D,TDepValues...> depPack,
699655
depPack.Data);
700656
}
701657

702-
// Token stream version
703-
template
704-
<
705-
typename D,
706-
typename FIn,
707-
typename ... TDepValues,
708-
typename TOut = std::result_of<FIn(TDepValues...)>::type
709-
>
710-
auto Transform(const Events<D,EventToken>& source, SignalPack<D,TDepValues...> depPack, FIn&& func)
711-
-> Events<D,TOut>
712-
{
713-
using REACT_IMPL::SyncedEventTransformNode;
714-
using REACT_IMPL::AddDummyArgWrapper;
715-
716-
using F = std::decay<FIn>::type;
717-
using WrapperT = AddDummyArgWrapper<EventToken,F,TOut,const TDepValues...>;
718-
719-
struct NodeBuilder_
720-
{
721-
NodeBuilder_(const Events<D,EventToken>& source, WrapperT&& wrapper) :
722-
MySource{ source },
723-
MyWrapper{ std::move(wrapper) }
724-
{}
725-
726-
auto operator()(const Signal<D,TDepValues>& ... deps)
727-
-> Events<D,TOut>
728-
{
729-
return Events<D,TOut>(
730-
std::make_shared<
731-
SyncedEventTransformNode<D,EventToken,TOut,WrapperT,TDepValues ...>>(
732-
MySource.NodePtr(), std::move(MyWrapper), deps.NodePtr() ...));
733-
}
734-
735-
const Events<D,EventToken>& MySource;
736-
WrapperT&& MyWrapper;
737-
};
738-
739-
return REACT_IMPL::apply(
740-
NodeBuilder_{
741-
source, WrapperT{ 0, std::forward<FIn>(func) } },
742-
depPack.Data);
743-
}
744-
745658
///////////////////////////////////////////////////////////////////////////////////////////////////
746659
/// Flatten
747660
///////////////////////////////////////////////////////////////////////////////////////////////////

0 commit comments

Comments
 (0)