-> EventSource<D,E>

{

using REACT_IMPL::EventSourceNode;

return EventSource<D,E>(

std::make_shared<EventSourceNode<D,E>>());

-> TempEvents<D,E,TOp>

{

using REACT_IMPL::EventOpNode;

static_assert(sizeof...(TArgs) > 0,

"Merge: 2+ arguments are required.");

return TempEvents<D,E,TOp>(

std::make_shared<EventOpNode<D,E,TOp>>(

GetNodePtr(arg1), GetNodePtr(args) ...));

-> TempEvents<D,E,TOp>

{

using REACT_IMPL::EventOpNode;

return TempEvents<D,E,TOp>(

std::make_shared<EventOpNode<D,E,TOp>>(

std::forward<FIn>(filter), GetNodePtr(src)));

-> TempEvents<D,E,TOpOut>

{

using REACT_IMPL::EventOpNode;

return TempEvents<D,E,TOpOut>(

std::make_shared<EventOpNode<D,E,TOpOut>>(

std::forward<FIn>(filter), src.StealOp()));

-> Events<D,E>

{

using REACT_IMPL::SyncedEventFilterNode;

using F = typename std::decay<FIn>::type;

struct NodeBuilder_

{

NodeBuilder_(const Events<D,E>& source, FIn&& func) :

MySource( source ),

MyFunc( std::forward<FIn>(func) )

{}

auto operator()(const Signal<D,TDepValues>& ... deps)

-> Events<D,E>

{

return Events<D,E>(

std::make_shared<SyncedEventFilterNode<D,E,F,TDepValues ...>>(

GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));

}

const Events<D,E>& MySource;

FIn MyFunc;

};

return REACT_IMPL::apply(

NodeBuilder_( source, std::forward<FIn>(func) ),

depPack.Data);

-> TempEvents<D,TOut,TOp>

{

using REACT_IMPL::EventOpNode;

return TempEvents<D,TOut,TOp>(

std::make_shared<EventOpNode<D,TOut,TOp>>(

std::forward<FIn>(func), GetNodePtr(src)));

-> TempEvents<D,TOut,TOpOut>

{

using REACT_IMPL::EventOpNode;

return TempEvents<D,TOut,TOpOut>(

std::make_shared<EventOpNode<D,TOut,TOpOut>>(

std::forward<FIn>(func), src.StealOp()));

-> Events<D,TOut>

{

using REACT_IMPL::SyncedEventTransformNode;

using F = typename std::decay<FIn>::type;

struct NodeBuilder_

{

NodeBuilder_(const Events<D,TIn>& source, FIn&& func) :

MySource( source ),

MyFunc( std::forward<FIn>(func) )

{}

auto operator()(const Signal<D,TDepValues>& ... deps)

-> Events<D,TOut>

{

return Events<D,TOut>(

std::make_shared<SyncedEventTransformNode<D,TIn,TOut,F,TDepValues ...>>(

GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));

}

const Events<D,TIn>& MySource;

FIn MyFunc;

};

return REACT_IMPL::apply(

NodeBuilder_( source, std::forward<FIn>(func) ),

depPack.Data);

-> Events<D,TOut>

{

using REACT_IMPL::EventProcessingNode;

return Events<D,TOut>(

std::make_shared<EventProcessingNode<D,TIn,TOut,F>>(

GetNodePtr(src), std::forward<FIn>(func)));

-> Events<D,TOut>

{

using REACT_IMPL::SyncedEventProcessingNode;

using F = typename std::decay<FIn>::type;

struct NodeBuilder_

{

NodeBuilder_(const Events<D,TIn>& source, FIn&& func) :

MySource( source ),

MyFunc( std::forward<FIn>(func) )

{}

auto operator()(const Signal<D,TDepValues>& ... deps)

-> Events<D,TOut>

{

return Events<D,TOut>(

std::make_shared<SyncedEventProcessingNode<D,TIn,TOut,F,TDepValues ...>>(

GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));

}

const Events<D,TIn>& MySource;

FIn MyFunc;

};

return REACT_IMPL::apply(

NodeBuilder_( source, std::forward<FIn>(func) ),

depPack.Data);

-> Events<D,TInnerValue>

{

return Events<D,TInnerValue>(

std::make_shared<REACT_IMPL::EventFlattenNode<D, Events<D,TInnerValue>, TInnerValue>>(

GetNodePtr(outer), GetNodePtr(outer.Value())));

-> Events<D, std::tuple<TArgs ...>>

{

using REACT_IMPL::EventJoinNode;

static_assert(sizeof...(TArgs) > 1,

"Join: 2+ arguments are required.");

return Events<D, std::tuple<TArgs ...>>(

std::make_shared<EventJoinNode<D,TArgs...>>(

GetNodePtr(args) ...));

{

template <typename T>

Token operator()(const T&) const { return Token::value; }

-> decltype(Transform(source, Tokenizer{}))

{

return Transform(source, Tokenizer{});

{

using NodeT = REACT_IMPL::EventStreamNode<D,E>;

using NodePtrT = std::shared_ptr<NodeT>;

using ValueT = E;

// Default ctor

Events() = default;

// Copy ctor

Events(const Events&) = default;

// Move ctor

Events(Events&& other) :

Events::EventStreamBase( std::move(other) )

{}

// Node ctor

explicit Events(NodePtrT&& nodePtr) :

Events::EventStreamBase( std::move(nodePtr) )

{}

// Copy assignment

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

// Move assignment

Events& operator=(Events&& other)

{

Events::EventStreamBase::operator=( std::move(other) );

return *this;

}

bool Equals(const Events& other) const

{

return Events::EventStreamBase::Equals(other);

}

bool IsValid() const

{

return Events::EventStreamBase::IsValid();

}

void SetWeightHint(WeightHint weight)

{

Events::EventStreamBase::SetWeightHint(weight);

}

auto Tokenize() const

-> decltype(REACT::Tokenize(std::declval<Events>()))

{

return REACT::Tokenize(*this);

}

template <typename ... TArgs>

auto Merge(TArgs&& ... args) const

-> decltype(REACT::Merge(std::declval<Events>(), std::forward<TArgs>(args) ...))

{

return REACT::Merge(*this, std::forward<TArgs>(args) ...);

}

template <typename F>

auto Filter(F&& f) const

-> decltype(REACT::Filter(std::declval<Events>(), std::forward<F>(f)))

{

return REACT::Filter(*this, std::forward<F>(f));

}

template <typename F>

auto Transform(F&& f) const

-> decltype(REACT::Transform(std::declval<Events>(), std::forward<F>(f)))

{

return REACT::Transform(*this, std::forward<F>(f));

}

-> decltype(REACT::Tokenize(std::declval<Events>()))

{

return REACT::Tokenize(*this);

-> decltype(REACT::Merge(std::declval<Events>(), std::forward<TArgs>(args) ...))

{

return REACT::Merge(*this, std::forward<TArgs>(args) ...);

-> decltype(REACT::Filter(std::declval<Events>(), std::forward<F>(f)))

{

return REACT::Filter(*this, std::forward<F>(f));

-> decltype(REACT::Transform(std::declval<Events>(), std::forward<F>(f)))

{

return REACT::Transform(*this, std::forward<F>(f));

{

using NodeT = REACT_IMPL::EventSourceNode<D,E>;

using NodePtrT = std::shared_ptr<NodeT>;

// Default ctor

EventSource() = default;

// Copy ctor

EventSource(const EventSource&) = default;

// Move ctor

EventSource(EventSource&& other) :

EventSource::Events( std::move(other) )

{}

// Node ctor

explicit EventSource(NodePtrT&& nodePtr) :

EventSource::Events( std::move(nodePtr) )

{}

// Copy assignemnt

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

// Move assignment

EventSource& operator=(EventSource&& other)

{

EventSource::Events::operator=( std::move(other) );

return *this;

}

// Explicit emit

void Emit(const E& e) const { EventSource::EventStreamBase::emit(e); }

void Emit(E&& e) const { EventSource::EventStreamBase::emit(std::move(e)); }

void Emit() const

{

static_assert(std::is_same<E,Token>::value, "Can't emit on non token stream.");

EventSource::EventStreamBase::emit(Token::value);

}

// Function object style

void operator()(const E& e) const { EventSource::EventStreamBase::emit(e); }

void operator()(E&& e) const { EventSource::EventStreamBase::emit(std::move(e)); }

void operator()() const

{

static_assert(std::is_same<E,Token>::value, "Can't emit on non token stream.");

EventSource::EventStreamBase::emit(Token::value);

}

// Stream style

const EventSource& operator<<(const E& e) const

{

EventSource::EventStreamBase::emit(e);

return *this;

}

const EventSource& operator<<(E&& e) const

{

EventSource::EventStreamBase::emit(std::move(e));

return *this;

}

{

using NodeT = REACT_IMPL::EventOpNode<D,E,TOp>;

using NodePtrT = std::shared_ptr<NodeT>;

// Default ctor

TempEvents() = default;

// Copy ctor

TempEvents(const TempEvents&) = default;

// Move ctor

TempEvents(TempEvents&& other) :

TempEvents::Events( std::move(other) )

{}

// Node ctor

explicit TempEvents(NodePtrT&& nodePtr) :

TempEvents::Events( std::move(nodePtr) )

{}

// Copy assignment

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

// Move assignment

TempEvents& operator=(TempEvents&& other)

{

TempEvents::EventStreamBase::operator=( std::move(other) );

return *this;

}

TOp StealOp()

{

return std::move(reinterpret_cast<NodeT*>(this->ptr_.get())->StealOp());

}

template <typename ... TArgs>

auto Merge(TArgs&& ... args)

-> decltype(REACT::Merge(std::declval<TempEvents>(), std::forward<TArgs>(args) ...))

{

return REACT::Merge(*this, std::forward<TArgs>(args) ...);

}

template <typename F>

auto Filter(F&& f) const

-> decltype(REACT::Filter(std::declval<TempEvents>(), std::forward<F>(f)))

{

return REACT::Filter(*this, std::forward<F>(f));

}

template <typename F>

auto Transform(F&& f) const

-> decltype(REACT::Transform(std::declval<TempEvents>(), std::forward<F>(f)))

{

return REACT::Transform(*this, std::forward<F>(f));

}