std :: tr1 :: function :: target <TFuncPtr>и ко / контравариантность - PullRequest
Новая
       14

std :: tr1 :: function :: target <TFuncPtr>и ко / контравариантность

4 голосов
/ 12 июля 2010

Поскольку я люблю программировать в C # и C ++, я собираюсь реализовать C # -подобную систему событий в качестве твердой основы для моего планируемого C ++ SFML-GUI.

Это только фрагмент моего кода, и я надеюсь, что это проясняет мою концепцию: 

// Event.h
// STL headers:
#include <functional>
#include <type_traits>
#include <iostream>
// boost headers:
#include <boost/signals/trackable.hpp>
#include <boost/signal.hpp>

namespace Utils
{
    namespace Gui
    {
        #define IMPLEMENTS_EVENT(EVENTNAME, EVENTARGS) public: \
            Utils::Gui::IEvent<EVENTARGS>& EVENTNAME() { return m_on##EVENTNAME; } \
        protected: \
            virtual void On##EVENTNAME(EVENTARGS& e) { m_on##EVENTNAME(this, e); } \
        private: \
            Utils::Gui::Event<EVENTARGS> m_on##EVENTNAME;


        #define MAKE_EVENTFIRING_CLASS(EVENTNAME, EVENTARGS) class Fires##EVENTNAME##Event \
        { \
            IMPLEMENTS_EVENT(EVENTNAME, EVENTARGS); \
        };


        class EventArgs
        {
        public:
            static EventArgs Empty;
        };

        EventArgs EventArgs::Empty = EventArgs();

        template<class TEventArgs>
        class EventHandler : public std::function<void (void*, TEventArgs&)>
        {
            static_assert(std::is_base_of<EventArgs, TEventArgs>::value, 
                "EventHandler must be instantiated with a TEventArgs template paramater type deriving from EventArgs.");
        public:
            typedef void Signature(void*, TEventArgs&);
            typedef void (*HandlerPtr)(void*, TEventArgs&);

            EventHandler() : std::function<Signature>() { }

            template<class TContravariantEventArgs>
            EventHandler(const EventHandler<TContravariantEventArgs>& rhs)
                : std::function<Signature>(reinterpret_cast<HandlerPtr>(*rhs.target<EventHandler<TContravariantEventArgs>::HandlerPtr>())) 
            {
                static_assert(std::is_base_of<TContravariantEventArgs, TEventArgs>::value,
                    "The eventHandler instance to copy does not suffice the rules of contravariance.");
            }

            template<class F>
            EventHandler(F f) : std::function<Signature>(f) { }

            template<class F, class Allocator>
            EventHandler(F f, Allocator alloc) : std::function<Signature>(f, alloc) { }
        };

        template<class TEventArgs>
        class IEvent
        {
        public:
            typedef boost::signal<void (void*, TEventArgs&)> SignalType;

            void operator+= (const EventHandler<TEventArgs>& eventHandler)
            {
                Subscribe(eventHandler);
            }

            void operator-= (const EventHandler<TEventArgs>& eventHandler)
            {
                Unsubscribe(eventHandler);
            }

            virtual void Subscribe(const EventHandler<TEventArgs>& eventHandler) = 0;

            virtual void Subscribe(const EventHandler<TEventArgs>& eventHandler, int group) = 0;

            virtual void Unsubscribe(const EventHandler<TEventArgs>& eventHandler) = 0;
        };

        template<class TEventArgs>
        class Event : public IEvent<TEventArgs>
        {
        public:
            virtual void Subscribe(const EventHandler<TEventArgs>& eventHandler)
            {
                m_signal.connect(*eventHandler.target<EventHandler<TEventArgs>::HandlerPtr>());
            }

            virtual void Subscribe(const EventHandler<TEventArgs>& eventHandler, int group)
            {
                m_signal.connect(group, *eventHandler.target<EventHandler<TEventArgs>::HandlerPtr>());
            }

            virtual void Unsubscribe(const EventHandler<TEventArgs>& eventHandler)
            {
                m_signal.disconnect(*eventHandler.target<EventHandler<TEventArgs>::HandlerPtr>());
            }

            void operator() (void* sender, TEventArgs& e)
            {
                m_signal(sender, e);
            }

        private:
            SignalType m_signal;
        };

        class IEventListener : public boost::signals::trackable
        {
        };
    };
};

Как вы можете видеть, я использую boost :: signal в качестве моей реальной системы событий, но я инкапсулирую ее с интерфейсом IEvent (который на самом деле является абстрактным классом), чтобы предотвратить прослушивание события с помощью оператора operator () ,

Для удобства я перегрузил операторы сложения-назначения и вычитания-назначения. Если я теперь получаю свои классы прослушивания событий из IEventListener, я могу писать код, не беспокоясь о висячем указателе функции в сигнале.

Пока я проверяю свои результаты, но у меня проблемы с std::tr1::function::target<TFuncPtr>(): 

class BaseEventArgs : public Utils::Gui::EventArgs
{
};

class DerivedEventArgs : public BaseEventArgs
{
};

void Event_BaseEventRaised(void* sender, BaseEventArgs& e)
{
    std::cout << "Event_BaseEventRaised called";
}

void Event_DerivedEventRaised(void* sender, DerivedEventArgs& e)
{
   std::cout << "Event_DerivedEventRaised called";
}

int main()
{
    using namespace Utils::Gui;
    typedef EventHandler<BaseEventArgs>::HandlerPtr pfnBaseEventHandler;
    typedef EventHandler<DerivedEventArgs>::HandlerPtr pfnNewEventHandler;

    // BaseEventHandler with a function taking a BaseEventArgs
    EventHandler<BaseEventArgs> baseEventHandler(Event_BaseEventRaised);
    // DerivedEventHandler with a function taking a DerivedEventArgs
    EventHandler<DerivedEventArgs> newEventHandler(Event_DerivedEventRaised);
    // DerivedEventHandler with a function taking a BaseEventArgs -> Covariance
    EventHandler<DerivedEventArgs> covariantBaseEventHandler(Event_BaseEventRaised);

    const pfnBaseEventHandler* pBaseFunc = baseEventHandler.target<pfnBaseEventHandler>();
    std::cout << "baseEventHandler function pointer is " << ((pBaseFunc != nullptr) ? "valid" : "invalid") << std::endl;

    const pfnNewEventHandler* pNewFunc = newEventHandler.target<pfnNewEventHandler>();
    std::cout << "baseEventHandler function pointer is " << ((pNewFunc != nullptr) ? "valid" : "invalid") << std::endl;

    // Here is the error, covariantBaseEventHandler actually stores a pfnBaseEventHandler:
    pNewFunc = covariantBaseEventHandler.target<pfnNewEventHandler>();
    std::cout << "covariantBaseEventHandler as pfnNewEventHandler function pointer is " << ((pNewFunc != nullptr) ? "valid" : "invalid") << std::endl;

    // This works as expected, but template forces compile-time knowledge of the function pointer type
    pBaseFunc = covariantBaseEventHandler.target<pfnBaseEventHandler>();
    std::cout << "covariantBaseEventHandler as pfnBaseEventHandler function pointer is " << ((pBaseFunc != nullptr) ? "valid" : "invalid") << std::endl;

    return EXIT_SUCCESS;
}

Метод EventHandler<TEventArgs>::target<TFuncPtr>() вернет действительный указатель только в том случае, если TFuncPtr - это тот же тип, который хранится в Functor, независимо от ковариации. Из-за проверки RTTI он запрещает доступ к указателю как к стандартному слабому типу указателя на функцию C, что немного раздражает в подобных случаях.

EventHandler имеет тип DerivedEventArgs, но, тем не менее, указывает на функцию pfnBaseEventHandler, даже несмотря на то, что функция проходила через конструктор.

Это означает, что сама функция std :: tr1 :: function «поддерживает» контравариантность, но я не могу найти способ просто получить указатель на функцию из объекта std :: tr1 :: funcion, если я этого не сделаю знать его тип во время компиляции, который требуется для аргумента шаблона.

Я был бы признателен в таких случаях, когда они добавили простой метод get (), как это было сделано для типов указателей RAII.

Поскольку я довольно новичок в программировании, я хотел бы знать, есть ли способ решить эту проблему, предпочтительно во время компиляции с помощью шаблонов (что, я думаю, будет единственным способом).

1 Ответ

2 голосов
/ 14 июля 2010

Только что нашел решение проблемы. Кажется, я просто пропустил актерский состав в другом месте: 

template<class TEventArgs>
class EventHandler : public std::function<void (void*, TEventArgs&)>
{
public:
    typedef void Signature(void*, TEventArgs&);
    typedef void (*HandlerPtr)(void*, TEventArgs&);

    // ...

    template<class TContravariantEventArgs>
    EventHandler(const EventHandler<TContravariantEventArgs>& rhs)
        : std::function<Signature>(reinterpret_cast<HandlerPtr>(*rhs.target<EventHandler<TContravariantEventArgs>::HandlerPtr>())) 
    {
        static_assert(std::is_base_of<TContravariantEventArgs, TEventArgs>::value,
            "The eventHandler instance to copy does not suffice the rules of contravariance.");
    }

    // ...
}

Это работает так, как это должно работать. Тем не менее, спасибо за то, что вы познакомились с этим действительно потрясающим сообществом!

...