slotclosure.h

Go to the documentation of this file.

/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 **********************************************************************/
 
#pragma once
 
#include <functional>
#include <QObject>
#include "sllconfig.h"
 
namespace LC
{
namespace Util
{
    class UTIL_SLL_API SlotClosureBase : public QObject
    {
        Q_OBJECT
    public:
        using QObject::QObject;
 
        virtual ~SlotClosureBase () = default;
    public Q_SLOTS:
        virtual void run () = 0;
    };

    template<typename FireDestrPolicy>
    class SlotClosure : public SlotClosureBase
                      , public FireDestrPolicy
    {
    public:
        using FunType_t = std::function<typename FireDestrPolicy::Signature_t>;
    private:
        FunType_t Func_;
    public:
        SlotClosure (const FunType_t& func, QObject *parent)
        : SlotClosureBase { parent }
        , Func_ { func }
        {
        }

        SlotClosure (const FunType_t& func,
                QObject *sender,
                const char *signal,
                QObject *parent)
        : SlotClosureBase { parent }
        , Func_ { func }
        {
            connect (sender,
                    signal,
                    this,
                    SLOT (run ()));
        }

        SlotClosure (const FunType_t& func,
                QObject *sender,
                const std::initializer_list<const char*>& signalsList,
                QObject *parent)
        : SlotClosureBase { parent }
        , Func_ { func }
        {
            for (const auto signal : signalsList)
                connect (sender,
                        signal,
                        this,
                        SLOT (run ()));
        }

        void run () override
        {
            FireDestrPolicy::Invoke (Func_, this);
            FireDestrPolicy::Fired (this);
        }
    };
 
    class BasicDeletePolicy
    {
    protected:
        using Signature_t = void ();
 
        void Invoke (const std::function<Signature_t>& f, SlotClosureBase*)
        {
            f ();
        }
 
        virtual ~BasicDeletePolicy () = default;
    };

    class DeleteLaterPolicy : public BasicDeletePolicy
    {
    protected:
        static void Fired (SlotClosureBase *base)
        {
            base->deleteLater ();
        }
    };

    class NoDeletePolicy : public BasicDeletePolicy
    {
    protected:
        static void Fired (SlotClosureBase*)
        {
        }
    };

    class ChoiceDeletePolicy
    {
    public:
        enum class Delete
        {
            No,

            Yes
        };
    protected:
        virtual ~ChoiceDeletePolicy () {}
 
        using Signature_t = Delete ();
 
        static void Invoke (const std::function<Signature_t>& f, SlotClosureBase *base)
        {
            if (f () == Delete::Yes)
                base->deleteLater ();
        }
 
        static void Fired (SlotClosureBase*)
        {
        }
    };
}
}