YiSignalBase.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_SIGNAL_BASE_H_
#define _YI_SIGNAL_BASE_H_

#include "event/YiEventDispatcher.h"
#include "signal/YiSignalHandler.h"
#include "signal/internal/YiSignalAbstractConnection.h"
#include "thread/YiWaitCondition.h"

#include <list>

class CYISignalBase : public CYISignalHandler
{
    friend class CYISignalHandler;

public:
    using CYISignalHandler::IsConnected;
    using CYISignalHandler::Disconnect;

    virtual bool IsConnected() const override;

    virtual bool IsConnected(const CYISignalBase &rSignal) const override;

    bool IsConnected(const CYISignalHandler &rSignalHandler) const;

    bool IsConnected(const CYISignalConnectionID &connectionID) const;

    void Disconnect(CYISignalHandler &rSignalHandler);

    void Disconnect(const CYISignalConnectionID &connectionID);

    void Disconnect(CYISignalBase &rSignal);

protected:
    struct SignalObjects
    {
        SignalObjects();

        mutable CYIRecursiveMutex m_signalMutex;

        CYIMutex m_asyncBlockMutex;

        CYIWaitCondition m_asyncBlockCondition;

        std::list<std::unique_ptr<CYISignalAbstractConnection>> m_connectionList;

        std::list<std::unique_ptr<CYISignalAbstractConnection>>::const_iterator m_currentConnectionIt;

#ifdef YI_DEBUG

        bool m_bEmitting;
#endif
    };

    CYISignalBase();
    CYISignalBase(const CYISignalBase &rSignal);
    virtual ~CYISignalBase();
    CYISignalBase &operator=(const CYISignalBase &rSignal);

    void RemoveConnection(CYISignalHandler &rSignalHandler, YI_NOTIFY_FLAG notifyHandler);

    void RemoveAllConnections(YI_NOTIFY_FLAG notifyHandler);

    void RegisterToSignalHandler(const CYISignalHandler &rSignalHandler);

    void UnregisterFromSignalHandler(CYISignalHandler &rSignalHandler);

    void ExclusiveLock(CYIRecursiveMutex &signalMutex) const;

    void ExclusiveLock(const CYISignalHandler &rSignalHandler, CYIRecursiveMutex &signalMutex) const;

    void ExclusiveUnlock(CYIRecursiveMutex &signalMutex) const;

    void ExclusiveUnlock(const CYISignalHandler &rSignalHandler, CYIRecursiveMutex &rSignalMutex) const;

    bool HasConnection(const CYISignalHandler &rSignalHandler) const;

    template<class YI_SIGNAL_EMIT_EVENT>
    void EmitAsync(const CYISignalAbstractConnection *pConnection, YI_CONNECTION_TYPE connectionType, std::unique_ptr<YI_SIGNAL_EMIT_EVENT> pEvent, const std::shared_ptr<CYIEventDispatcher> &pDispatcher);

    CYILazy<SignalObjects> m_signalObjects;

private:
    void DisconnectFromAllSlots();
    void UnblockAsyncBlock();
    std::list<std::unique_ptr<CYISignalAbstractConnection>>::const_iterator FindConnection(const CYISignalConnectionID &connectionID) const;
    void CloneConnections(const CYISignalHandler &rSourceSignalHandler, CYISignalHandler &rDestinationSignalHandler);
    void CopySignal(const CYISignalBase &rSignal);
    void CloneConnectionAndConnect(const CYISignalAbstractConnection *pConnection);
};

template<class YI_SIGNAL_EMIT_EVENT>
void CYISignalBase::EmitAsync(const CYISignalAbstractConnection *pConnection, YI_CONNECTION_TYPE connectionType, std::unique_ptr<YI_SIGNAL_EMIT_EVENT> pEvent, const std::shared_ptr<CYIEventDispatcher> &pDispatcher)
{
    pEvent->Signal.CloneConnectionAndConnect(pConnection);
    if (connectionType == YI_CONNECTION_ASYNC_BLOCK)
    {
        SignalObjects *pSignalObjects = m_signalObjects.Get();
        pSignalObjects->m_asyncBlockMutex.Lock();
        pEvent->Signal.Connect(*this, &CYISignalBase::UnblockAsyncBlock, YI_CONNECTION_SYNC);
        pDispatcher->PostEvent(std::move(pEvent), pDispatcher->GetSignalEmitEventHandler());
        pSignalObjects->m_asyncBlockCondition.Wait(pSignalObjects->m_asyncBlockMutex);
        pSignalObjects->m_asyncBlockMutex.Unlock();
    }
    else
    {
        pDispatcher->PostEvent(std::move(pEvent), pDispatcher->GetSignalEmitEventHandler());
    }
}

#endif /* _YI_SIGNAL_BASE_H_ */