MovieSceneDataEventContainer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "MovieSceneFwd.h"
#include "Delegates/Delegate.h"
#include "Containers/List.h"
 
namespace UE
{
namespace MovieScene
{
 
struct FDataEventScope
{
    FSimpleMulticastDelegate OnBracketClosed;
 
    MOVIESCENE_API FDataEventScope();
    MOVIESCENE_API ~FDataEventScope();
};
 
template<typename T>
class TIntrusiveEventHandler : public TIntrusiveLinkedList<TIntrusiveEventHandler<T>>, public T
{
protected:
    virtual ~TIntrusiveEventHandler()
    {
        this->Unlink();
    }
};
 
template<typename T>
struct TNonIntrusiveEventHandler : public TLinkedList<T*>
{
    TNonIntrusiveEventHandler()
    {}
 
    TNonIntrusiveEventHandler(T* InInstance)
        : TLinkedList<T*>(InInstance)
    {}
 
    ~TNonIntrusiveEventHandler()
    {
        this->Unlink();
    }
};
 
template<typename EventInterface>
struct TDataEventContainer
{
#if UE_MOVIESCENE_EVENTS
    ~TDataEventContainer()
    {
        if (IntrusiveHandlers)
        {
            IntrusiveHandlers->Unlink();
        }
        if (NonIntrusiveHandlers)
        {
            NonIntrusiveHandlers->Unlink();
        }
    }
 
    template<typename FuncType, typename... ArgTypes>
    void Trigger(FuncType&& Func, ArgTypes&&... Args) const
    {
        for (typename TIntrusiveLinkedList<TIntrusiveEventHandler<EventInterface>>::TIterator It(IntrusiveHandlers); It; )
        {
            TIntrusiveEventHandler<EventInterface>& Current = *It;
            // Increment before invoking to ensure that removals inside the invocation do not cause the iteration to return prematurely
            ++It;
 
            Invoke(Func, Current, Forward<ArgTypes>(Args)...);
        }
        for (typename TNonIntrusiveEventHandler<EventInterface>::TIterator It(NonIntrusiveHandlers); It; )
        {
            EventInterface* Current = *It;
            // Increment before invoking to ensure that removals inside the invocation do not cause the iteration to return prematurely
            ++It;
 
            Invoke(Func, Current, Forward<ArgTypes>(Args)...);
        }
    }
 
    void Link(TIntrusiveEventHandler<EventInterface>* InLink) const
    {
        check(!InLink->IsLinked());
        InLink->LinkHead(IntrusiveHandlers);
    }
 
    void Link(TNonIntrusiveEventHandler<EventInterface>& InLink, EventInterface* Instance) const
    {
        check(!InLink.IsLinked());
        InLink = TNonIntrusiveEventHandler<EventInterface>(Instance);
        InLink.LinkHead(NonIntrusiveHandlers);
    }
 
private:
 
    mutable TIntrusiveEventHandler<EventInterface>* IntrusiveHandlers = nullptr;
    mutable TLinkedList<EventInterface*>* NonIntrusiveHandlers = nullptr;
 
#else
 
    template<typename ...ArgTypes>
    void Trigger(ArgTypes&&...) const
    {}
 
#endif
};
 
} // namespace MovieScene
} // namespace UE