C ++ 11 and event handling
I think that event handling as a way of interacting objects in OOP is known to almost everyone who has ever touched OOP. At least, this approach is very convenient in a very wide, in my opinion, range of tasks. In many programming languages, an event handling mechanism is built-in; however, there is no such mechanism in C ++. Let's see what can be done about it.
An event is something that can happen to some object under certain conditions (for example, a button when you click on it with the mouse). Other objects may need to be aware of this; then they subscribe to the event . In this case, when an event occurs, the handler of a third-party object subscribed to the event is called; thus, it is possible for him to execute some code, i.e. respond to the event. Similarly, an object can unsubscribe from an event if it does not want to respond to it anymore. As a result, we have a lot of objects that can be connected with each other through the events of one of them and the reaction to these events of others.
Somehow, although everyone knows this.
It would seem to implement such behavior is easy. And it could look like this:
')
The application of this case should be:
Naturally, a handler method (a member function of a class) will not be the only type of handler, but more on that later.
It seems everything is convenient, compact and cool. But while there are a number of flaws.
To implement the unsubscribe from the event, you must add a comparison capability to the handler ( == and ! == ). Equal will be considered such handlers that call the same method (-function-member of a class) of the same object (that is, the same instance of the same class).
Then we will be able to remove handlers from the event subscription. In this case, you must prevent the addition of the same (equal) handlers.
Here, the handler's add / remove functions return true if successful, and false if the corresponding action (add or delete) was not performed.
Yes, the use case with comparison implies the creation of temporary, not added handlers, which are not deleted anywhere. But more about that later.
Can I use it? Not yet fully.
So, we immediately encounter a crash when executing the code, where the handler itself writes itself off from the event (I think it's not the rarest use case when the handler self-spits under any conditions):
The problem occurs for a very simple reason:
Therefore, it is necessary to check the cases when the list of handlers can be changed, which would lead to the invalidity of the iterators; and then implement read protection for such iterators.
The advantage of std :: list 'and in this application is the fact that when deleting it makes invalid only one iterator - per deleted item (affecting, for example, the subsequent elements); and the addition of an element does not lead to any iterators being invalid. Thus, we need to check a single case: the removal of an element whose iterator is current in the current iteration of elements. In this case, you can, for example, not delete the element, but simply mark that the current element is to be deleted, and let it be done inside the search of elements.
It would be possible to immediately roll out the implementation of this, but I propose to solve this problem together with the following.
Potentially, calls to three possible functions — add, delete, and iterate (when an event fires) handlers — are possible from different threads at random points in time. This creates a whole field of opportunities for their "intersection" in time, "overlaying" their performance on each other and the fall of the program in the end. Let's try to avoid this; mutexes are our everything .
Do not forget to leave the “window” nezalochennoti when calling each handler. This is necessary so that inside the handler you can access the event and modify it (for example, add / remove handlers) without causing a deadlock . For the validity of the data can not be afraid, because, as we found out, the only thing that leads to this is the removal of the current element, and this situation is handled.
UPD1. Thanks Cheater , suggested that std :: shared_mutex appears only in C ++ 17 (and std :: shared_lock only in C ++ 14 ). Those for whom it is critical, apparently, will have to do with std :: mutex .
UPD2. Further, about thread safety (without preserving the sequence of narration).
When using an event as a member of a class, it seems logical to make it appear public so that third-party objects can add / remove their handlers. However, this will result in operator () , i.e. the event call will also be accessible from the outside, which in some cases may be unacceptable. Let's solve this problem by extracting from the event class ( TEvent <...> ) an abstract interface intended only for operating handlers.
Now we can smash into different areas of visibility the part of the event responsible for working with handlers, and the part responsible for calling it.
Thus, now third-party objects can add / remove their handlers via TestWindow :: onButtonClick , however, they will not be able to trigger this event themselves. The call can now be made only inside the class TestWindow (and its descendants, if the scope of the event, as an example, is protected ).
The trivial code gradually begins to turn into something monstrous, but this is not the end.
In the current implementation, the event and any handler must have a strictly corresponding list of parameters. This leads to several disadvantages.
The first. Suppose we have a class template in which there is an event with a template parameter.
Due to the fact that the type that will be used here is unknown in advance, it makes sense to transfer it by a constant reference, and not by value. However, now for any implementation, even with fundamental types, there must be appropriate handlers.
I would like to be able to connect with a similar event and handlers of the form MyHandlerClass :: handleValueChanged2 , but so far there is no such possibility.
The second. Let us try to implement a handler-functor in the same way as an existing handler-method (-functions-members of a class).
Now let's try to screw it to some event.
The result will be a compilation error. For the createFunctorEventHandler function , the compiler cannot infer the types of TParams ... from the only argument of this function - the functor itself. The functor really does not contain any information about what type of handler to create on its basis. The only thing that can be done in this situation is to write something like:
But you don’t want to do this at all.
So, there is a Wishlist, it's up to the implementation. We will consider the situation on the example of a handler-functor; a handler-method (-function-member of a class) will turn out in the same way.
Since, based on the functor alone, it is impossible to say what the list of parameters of the corresponding handler will be, then we will not do that. This issue becomes relevant not at the time of the creation of the handler, but at the time of the attempt to join it to a specific event. And yes, these are two different points. You can implement this idea as follows:
In short, the separation of the moments of creating a handler and attaching it to an event here is more pronounced than before. This allows you to bypass the problems described in the previous paragraph. The type compatibility check will occur when trying to caste a particular FunctorHolder to a certain FunctorEventHandler , or rather, to create an instance of the class FunctorEventHandler <....> With a very specific type of functor; and in this class there will be a line of code m_functorHolder.m_functor (params ...); , which is simply not compiled for a set of types incompatible with a functor (or if it is not a functor at all, that is, an object that does not have a operator () ).
I repeat that the problem of deleting temporary objects will be discussed below. In addition, it is worth noting that a bunch of macros for each case is made, firstly, in order to demonstrate the capabilities of this type of handler, and secondly, in case of possible modification by a file of any of them.
Check the result.
A compilation error occurs when trying to convert one of the parameters from const lvalue to lvalue . Converting from rvalue to unconst lvalue does not cause an error, although it is worth noting that it creates a potential threat to a self-shot in the leg: the handler will be able to change the variable copied to the stack, which will happily be deleted when it leaves this handler.
In general, the error message should look something like this:
For greater clarity, when using events and handlers in third-party code, you can add your own error message. This will require writing a small supporting structure (I admit, I have peeped around this approach):
This work is based on the SFINAE mechanism. In short, an attempt is made to compile the first exists function, however, if this fails due to the incompatibility of the arguments (or the lack of operator () of what is passed as a functor), the compiler does not throw an error, but simply tries to compile the second function; we do everything so that its compilation is always successful, and then, in fact, which of the functions was compiled, we conclude (writing the result in value ) about the compatibility of the arguments for the given types.
Now the error message will look like this:
In addition to an additional, more informative error message, this approach solves the problem of converting argument (s) from rvalue to unconst lvalue : now it causes an error of incompatible arguments, i.e. an attempt to add the functor6 handler from the example above results in a compile-time error.
UPD. Revision (without preserving the sequence of the story).
Due to changes in the class handler, the implementation of comparing instances of this class will change a little. Again, I will only give the implementation of a handler-functor, because a handler-method (-function-member of a class) will look similar.
At this similarity in the implementation of the comparison ends and begins part only for handlers-functors.
As noted above, we have obtained several types of handler-functors: directly objects-functors, lambda expressions, instances of the class std :: function , separate functions. Of these, functor objects, lambda expressions, and instances of the std :: function class cannot be compared using operator == (they need to be compared by address), but individual functions can, because already stored at. In order not to rewrite the comparison function separately for each case, we write it in a general form:
It is implied that is_equatable is an auxiliary template that determines whether two instances of a given type can be checked for equality. With it, using std :: enable_if , we choose one of two partially specialized structures EqualityChecker , which will make the comparison: by value or by address. Implemented is_equatable it can be as follows:
This implementation is based on the SFINAE mechanism that was previously used . Only here we check the availability of operator == for instances of a given class.
In such a simple way, the implementation of the comparison of handlers-functors is ready.
Be indulgent, I also wanted to insert a loud headline.
We are approaching the final, and it’s time to get rid of the huge amount of objects that are being created that no one controls.
At each event of the event with the handler, two objects are created: Holder , which stores the executable part of the handler, and EventHandlerassociating it with an event. Do not forget that in the case of an attempt to re-add the handler, no addition will occur - two objects “hung in the air” (unless, of course, separately check this case each time). Another situation: delete handler; two new objects are also created to search for the same (equal) in the list of event handlers; The handler found from the list is, of course, removed (if any), and this temporary, created for search and consisting of two objects, is again “in the air”. In general, not cool.
Turn to smart pointers . It is necessary to determine what the semantics of ownership of each of the two handler objects will be: sole ownership ( std :: unique_ptr ) or shared ( std :: shared_ptr ).
Holderbesides using the event itself when adding / deleting should be stored in the EventHandler , therefore we use for shared ownership, and for the EventHandler , the sole ownership , because after creation, it will be stored only in the list of event handlers.
We implement this idea:
Everything in order.
To start the event and its interface for working with handlers. In the latter, converting types directly using static_cast will no longer work, because the type to be transformed lies "inside" std :: shared_ptr . Now for such a transformation we will use the auxiliary structure HandlerCast , which by its private specialization will provide access to the object inside std :: shared_ptr , and already working with it (in its non-specialized implementation), apply the good old static_cast .
The event itself; There are some important changes here too. First, stop manually deleting instances of handlers in the destructor and during deletion; now it is enough to remove from the list a smart pointer with this handler. In addition, when adding a handler, it is important not to forget std :: move , since std :: unique_ptr does not support copying (which is quite logical for such semantics).
Let's go to the handlers. According to the old tradition, only one of them is given, the second is similar. And here, at first glance, it all comes down to changing the types of stored / created objects from links / pointers to smart pointers.
But there is one subtle point. The createMethodEventHandler function will return std :: shared_ptr to the instance.MethodHolder . A little later, an attempt will be made to convert it to a handler type ( MethodEventHandler ), where it will have to create a new instance of MethodEventHandler , passing it to the constructor std :: shared_ptr to itself. That was how it was intended that the MethodHolder instance would later retire when the MethodEventHandler instance was deleted . But the problem is that MethodHolder does not have access to the already created std :: shared_ptr that stores it.
To solve the problem, you will have to store a smart pointer to yourself in MethodHolder . However, so that he does not affect his removal, we usestd :: weak_ptr :
For better clarity, I’ll give an approximate order of events when removing a handler from an event (my apologies for the random pun):
It is important to remember that the destructor of the AbstractEventHandler class must be virtual; otherwise, after point 2 in point 3 , the AbstractEventHandler destructor will be called and no further actions will be performed.
In some cases, when adding / removing a single handler from an event occurs quite often (according to some logic), I don’t want to mess around, taking an instance of the event and an instance of the handler each time to once again implement a subscription / unsubscribe from this event. And you want to connect them once, and then, if necessary, work with this connection, adding / removing with it the predefined handler from a predetermined event. You can implement this as follows:
As you can see, now we have added another possible storage location for the handler instance, so we will use std :: shared_ptr for this instead of std :: unique_ptr .
However, this class, as for me, is slightly inconvenient to use. It would be desirable to store and create instances of connections without a list of parameters instantiating a class template.
We do this with the help of an abstract ancestor class and a wrapper:
HandlerCast is the same supporting structure that was used here . By the way, it is important not to forget to make the AbstractEventJoin destructor virtual so that when you delete its instance in the EventJoinWrapper destructor, the HandlerEventJoin destructor is called , otherwise the THandlerPtr field and, therefore, the handler itself will not be destroyed .
This implementation seems to work, but only at first glance. Copying or moving an EventJoinWrapper instance will re-delete m_eventJoin in its destructor. Therefore, we use std :: shared_ptr to store the instance.AbstractEventJoin , as well as implement slightly optimized motion semantics (and copying), since this will be a potentially frequent operation.
Now, when connecting the handler to the event, you can immediately return an instance of the new connection:
And after settling the triangular dependencies by include (IEvent <= EventJointWrapper.hpp; EventJointWrapper <= HandlerEventJoin.hpp; HandlerEventJoin <= IEvent.hpp) you can even work with splitting some files into .h and .hpp .
Creation of instances of connections occurs according to the same rules as when a handler is subscribed to an event:
Plus, you can “turn on” / “turn off” event handling (for which, in principle, connections were created):
First, it is worth noting that the task to write an article as briefly and concisely as possible is completely failed.
I hope that the resulting implementation of event handling is quite efficient and will be at least useful to someone.
It is worth noting a number of important points:
In addition, in the final version there are some points omitted in the article for greater clarity and readability of the code:
To all those who read to here at least diagonally, a low bow. I enclose all the code; You can also take it here (with all the latest modifications).
UPD1. Here and earlier on the article is the code written under VC ++ 14 . For compatibility with other compilers, it is better to take the code by reference. Special thanks to Cheater for ensuring compatibility with GCC .
UPD2. Thank you lexxmark for noticing a thread-safety hole in terms of several simultaneous event calls.
I think I’m not mistaken if I say that Qt is a very common framework for developing in C ++ . Among other things, it also has its own event-handling mechanism , in which there are signals as event analogs and slots as handler analogs. It is implemented using the Meta-Object Compiler , which is part of a more global Meta-Object System , which, in turn, is implemented using the add-in over Q ++ used in Qt .
It is important to note that this comparison with Qt is still very subjective and is not aimed at exalting or condemning this framework. It must be remembered that in addition to the signal / slot mechanism, Qt provides a great deal of functionality, both using this mechanism and not depending on it. In any case, it's always up to you to decide what to use and what not.
Brief introduction
An event is something that can happen to some object under certain conditions (for example, a button when you click on it with the mouse). Other objects may need to be aware of this; then they subscribe to the event . In this case, when an event occurs, the handler of a third-party object subscribed to the event is called; thus, it is possible for him to execute some code, i.e. respond to the event. Similarly, an object can unsubscribe from an event if it does not want to respond to it anymore. As a result, we have a lot of objects that can be connected with each other through the events of one of them and the reaction to these events of others.
Somehow, although everyone knows this.
The simplest implementation
It would seem to implement such behavior is easy. And it could look like this:
')
template<class ...TParams> class AbstractEventHandler { public: virtual void call( TParams... params ) = 0; protected: AbstractEventHandler() {} }; template<class ...TParams> class TEvent { using TEventHandler = AbstractEventHandler<TParams...>; public: TEvent() : m_handlers() { } ~TEvent() { for( TEventHandler* oneHandler : m_handlers ) delete oneHandler; m_handlers.clear(); } void operator()( TParams... params ) { for( TEventHandler* oneHandler : m_handlers ) oneHandler->call( params... ); } void operator+=( TEventHandler& eventHandler ) { m_handlers.push_back( &eventHandler ); } private: std::list<TEventHandler*> m_handlers; }; template<class TObject, class ...TParams> class MethodEventHandler : public AbstractEventHandler<TParams...> { using TMethod = void( TObject::* )( TParams... ); public: MethodEventHandler( TObject& object, TMethod method ) : AbstractEventHandler<TParams...>(), m_object( object ), m_method( method ) { assert( m_method != nullptr ); } virtual void call( TParams... params ) override final { ( m_object.*m_method )( params... ); } private: TObject& m_object; TMethod m_method; }; template<class TObject, class ...TParams> AbstractEventHandler<TParams...>& createMethodEventHandler( TObject& object, void( TObject::*method )( TParams... ) ) { return *new MethodEventHandler<TObject, TParams...>( object, method ); } #define METHOD_HANDLER( Object, Method ) createMethodEventHandler( Object, &Method ) #define MY_METHOD_HANDLER( Method ) METHOD_HANDLER( *this, Method ) The application of this case should be:
class TestWindow { . . . public: TEvent<const std::string&, unsigned int> onButtonClick; . . . }; class ClickEventHandler { . . . public: void testWindowButtonClick( const std::string&, unsigned int ) { ... } . . . }; int main( int argc, char *argv[] ) { . . . TestWindow testWindow; ClickEventHandler clickEventHandler; testWindow.onButtonClick += METHOD_HANDLER( clickEventHandler, ClickEventHandler::testWindowButtonClick ); . . . } Naturally, a handler method (a member function of a class) will not be the only type of handler, but more on that later.
It seems everything is convenient, compact and cool. But while there are a number of flaws.
Handler comparison
To implement the unsubscribe from the event, you must add a comparison capability to the handler ( == and ! == ). Equal will be considered such handlers that call the same method (-function-member of a class) of the same object (that is, the same instance of the same class).
template<class ...TParams> class AbstractEventHandler { . . . using MyType = AbstractEventHandler<TParams...>; public: bool operator==( const MyType& other ) const { return isEquals( other ); } bool operator!=( const MyType& other ) const { return !( *this == other ); } protected: virtual bool isEquals( const MyType& other ) const = 0; . . . }; template<class TMethodHolder, class ...TParams> class MethodEventHandler : public AbstractEventHandler<TParams...> { . . . using TMethod = void( TObject::* )( TParams... ); protected: virtual bool isEquals( const AbstractEventHandler<TParams...>& other ) const override { const MyType* _other = dynamic_cast<const MyType*>( &other ); return ( _other != nullptr && &m_object == &_other.m_object && m_method == _other.m_method ); } private: TObject& m_object; TMethod m_method; . . . }; Then we will be able to remove handlers from the event subscription. In this case, you must prevent the addition of the same (equal) handlers.
template<class ...TParams> class TEvent { . . . using TEventHandler = AbstractEventHandler<TParams...>; using TEventHandlerIt = typename std::list<TEventHandler*>::const_iterator; public: bool operator+=( TEventHandler& eventHandler ) { if( findEventHandler( eventHandler ) == m_handlers.end() ) { m_handlers.push_back( &eventHandler ); return true; } return false; } bool operator-=( TEventHandler& eventHandler ) { auto it = findEventHandler( eventHandler ); if( it != m_handlers.end() ) { TEventHandler* removedEventHandler = *it; m_handlers.erase( it ); delete removedEventHandler; return true; } return false; } private: inline TEventHandlerIt findEventHandler( TEventHandler& eventHandler ) const { return std::find_if( m_handlers.cbegin(), m_handlers.cend(), [ &eventHandler ]( const TEventHandler* oneHandler ) { return ( *oneHandler == eventHandler ); } ); } std::list<TEventHandler*> m_handlers; . . . }; Here, the handler's add / remove functions return true if successful, and false if the corresponding action (add or delete) was not performed.
Yes, the use case with comparison implies the creation of temporary, not added handlers, which are not deleted anywhere. But more about that later.
Can I use it? Not yet fully.
Delete handler inside handler
So, we immediately encounter a crash when executing the code, where the handler itself writes itself off from the event (I think it's not the rarest use case when the handler self-spits under any conditions):
class TestWindow { . . . public: TEvent<const std::string&, unsigned int> onButtonClick; static TestWindow& instance(); . . . }; class ClickEventHandler { . . . public: void testWindowButtonClick( const std::string&, unsigned int ) { TestWindow::instance().onButtonClick -= MY_METHOD_HANDLER( ClickEventHandler::testWindowButtonClick ); } . . . }; int main( int argc, char *argv[] ) { . . . ClickEventHandler clickEventHandler; TestWindow::instance().onButtonClick += METHOD_HANDLER( clickEventHandler, ClickEventHandler::testWindowButtonClick ); . . . } The problem occurs for a very simple reason:
- the event is triggered and starts iterating through (with the help of iterators) handlers, calling them;
- another handler inside causes itself to delete itself;
- event removes the given handler, making the corresponding iterator invalid;
- after this handler is completed, the event returns to the rest, but the current iterator (corresponding to the remote handler) is no longer valid;
- an event tries to access an invalid iterator, causing a crash.
Therefore, it is necessary to check the cases when the list of handlers can be changed, which would lead to the invalidity of the iterators; and then implement read protection for such iterators.
The advantage of std :: list 'and in this application is the fact that when deleting it makes invalid only one iterator - per deleted item (affecting, for example, the subsequent elements); and the addition of an element does not lead to any iterators being invalid. Thus, we need to check a single case: the removal of an element whose iterator is current in the current iteration of elements. In this case, you can, for example, not delete the element, but simply mark that the current element is to be deleted, and let it be done inside the search of elements.
It would be possible to immediately roll out the implementation of this, but I propose to solve this problem together with the following.
Thread safety
Potentially, calls to three possible functions — add, delete, and iterate (when an event fires) handlers — are possible from different threads at random points in time. This creates a whole field of opportunities for their "intersection" in time, "overlaying" their performance on each other and the fall of the program in the end. Let's try to avoid this; mutexes are our everything .
template<class ...TParams> class TEvent { using TEventHandler = AbstractEventHandler<TParams...>; using TEventHandlerIt = typename std::list<TEventHandler*>::const_iterator; public: TEvent() : m_handlers(), m_currentIt(), m_isCurrentItRemoved( false ), m_handlerListMutex() { } void operator()( TParams... params ) { m_handlerListMutex.lock_shared(); m_isCurrentItRemoved = false; m_currentIt = m_handlers.begin(); while( m_currentIt != m_handlers.end() ) { m_handlerListMutex.unlock_shared(); ( *m_currentIt )->call( params... ); m_handlerListMutex.lock_shared(); if( m_isCurrentItRemoved ) { m_isCurrentItRemoved = false; TEventHandlerIt removedIt = m_currentIt; ++m_currentIt; deleteHandler( removedIt ); } else { ++m_currentIt; } } m_handlerListMutex.unlock_shared(); } bool operator+=( TEventHandler& eventHandler ) { std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex ); if( findEventHandler( eventHandler ) == m_handlers.end() ) { m_handlers.push_back( std::move( eventHandler ) ); return true; } return false; } bool operator-=( TEventHandler& eventHandler ) { std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex ); auto it = findEventHandler( eventHandler ); if( it != m_handlers.end() ) { if( it == m_currentIt ) m_isCurrentItRemoved = true; else deleteHandler( it ); return true; } return false; } private: // 'm_handlerListMutex' inline TEventHandlerIt findEventHandler( TEventHandler& eventHandler ) const { return std::find_if( m_handlers.cbegin(), m_handlers.cend(), [ &eventHandler ]( const TEventHandler* oneHandler ) { return ( *oneHandler == eventHandler ); } ); } // 'm_handlerListMutex' inline void deleteHandler( TEventHandlerIt it ) { TEventHandler* removedEventHandler = *it; m_handlers.erase( it ); delete removedEventHandler; } std::list<TEventHandler*> m_handlers; // 'm_handlerListMutex' mutable TEventHandlerIt m_currentIt; mutable bool m_isCurrentItRemoved; mutable std::shared_mutex m_handlerListMutex; }; Do not forget to leave the “window” nezalochennoti when calling each handler. This is necessary so that inside the handler you can access the event and modify it (for example, add / remove handlers) without causing a deadlock . For the validity of the data can not be afraid, because, as we found out, the only thing that leads to this is the removal of the current element, and this situation is handled.
UPD1. Thanks Cheater , suggested that std :: shared_mutex appears only in C ++ 17 (and std :: shared_lock only in C ++ 14 ). Those for whom it is critical, apparently, will have to do with std :: mutex .
UPD2. Further, about thread safety (without preserving the sequence of narration).
Event visibility problem
When using an event as a member of a class, it seems logical to make it appear public so that third-party objects can add / remove their handlers. However, this will result in operator () , i.e. the event call will also be accessible from the outside, which in some cases may be unacceptable. Let's solve this problem by extracting from the event class ( TEvent <...> ) an abstract interface intended only for operating handlers.
template<class ...TParams> class IEvent { protected: using TEventHandler = AbstractEventHandler<TParams...>; public: bool operator+=( TEventHandler& eventHandler ) { return addHandler( eventHandler ); } bool operator-=( TEventHandler& eventHandler ) { return removeHandler( eventHandler ); } protected: IEvent() {} virtual bool addHandler( TEventHandler& eventHandler ) = 0; virtual bool removeHandler( TEventHandler& eventHandler ) = 0; }; template<class ...TParams> class TEvent : public IEvent<TParams...> { . . . public: TEvent() : IEvent<TParams...>() . . . { } protected: virtual bool addHandler( TEventHandler& eventHandler ) override { // , 'TEvent::operator+=' } virtual bool removeHandler( TEventHandler& eventHandler ) override { // , 'TEvent::operator-=' } . . . }; Now we can smash into different areas of visibility the part of the event responsible for working with handlers, and the part responsible for calling it.
class TestWindow { . . . public: TestWindow() : onButtonClick( m_onButtonClick ), m_onButtonClick() { } IEvent<const std::string&, unsigned int>& onButtonClick; protected: TEvent<const std::string&, unsigned int> m_onButtonClick; . . . }; Thus, now third-party objects can add / remove their handlers via TestWindow :: onButtonClick , however, they will not be able to trigger this event themselves. The call can now be made only inside the class TestWindow (and its descendants, if the scope of the event, as an example, is protected ).
The trivial code gradually begins to turn into something monstrous, but this is not the end.
Matching the parameters of the event and its handlers
In the current implementation, the event and any handler must have a strictly corresponding list of parameters. This leads to several disadvantages.
The first. Suppose we have a class template in which there is an event with a template parameter.
template<class TSource> class MyClass { . . . public: TEvent<const TSource&> onValueChanged; . . . }; Due to the fact that the type that will be used here is unknown in advance, it makes sense to transfer it by a constant reference, and not by value. However, now for any implementation, even with fundamental types, there must be appropriate handlers.
MyClass<bool> myBoolClass; . . . template<class TSource> class MyHandlerClass { . . . private: void handleValueChanged1( const bool& newValue ); void handleValueChanged2( bool newValue ); . . . }; . . . MyHandlerClass myHandlerClass; myBoolClass.onValueChanged += METHOD_HANDLER( myHandlerClass, MyHandlerClass::handleValueChanged1 ); // OK myBoolClass.onValueChanged += METHOD_HANDLER( myHandlerClass, MyHandlerClass::handleValueChanged2 ); // compile error I would like to be able to connect with a similar event and handlers of the form MyHandlerClass :: handleValueChanged2 , but so far there is no such possibility.
The second. Let us try to implement a handler-functor in the same way as an existing handler-method (-functions-members of a class).
template<class TFunctor, class ...TParams> class FunctorEventHandler : public AbstractEventHandler<TParams...> { public: FunctorEventHandler( TFunctor& functor ) : AbstractEventHandler<TParams...>(), m_functor( functor ) { } virtual void call( TParams... params ) override final { m_functor( params... ); } private: TFunctor& m_functor; }; template<class TFunctor, class ...TParams> AbstractEventHandler<TParams...>& createFunctorEventHandler( TFunctor&& functor ) { return *new FunctorEventHandler<TFunctor, TParams...>( functor ); } #define FUNCTOR_HANDLER( Functor ) createFunctorEventHandler( Functor ) Now let's try to screw it to some event.
class TestWindow { . . . public: TEvent<const std::string&, unsigned int> onButtonClick; . . . }; struct ClickEventHandler { void operator()( const std::string&, unsigned int ) { . . . } }; int main( int argc, char *argv[] ) { . . . TestWindow testWindow; ClickEventHandler clickEventHandler; testWindow.onButtonClick += FUNCTOR_HANDLER( clickEventHandler ); . . . } The result will be a compilation error. For the createFunctorEventHandler function , the compiler cannot infer the types of TParams ... from the only argument of this function - the functor itself. The functor really does not contain any information about what type of handler to create on its basis. The only thing that can be done in this situation is to write something like:
testWindow.onButtonClick += createFunctorEventHandler<ClickEventHandler, const std::string&, unsigned int>( clickEventHandler ); But you don’t want to do this at all.
Connection of event with handlers of different types
So, there is a Wishlist, it's up to the implementation. We will consider the situation on the example of a handler-functor; a handler-method (-function-member of a class) will turn out in the same way.
Since, based on the functor alone, it is impossible to say what the list of parameters of the corresponding handler will be, then we will not do that. This issue becomes relevant not at the time of the creation of the handler, but at the time of the attempt to join it to a specific event. And yes, these are two different points. You can implement this idea as follows:
template<class TFunctor> class FunctorHolder; template<class TFunctor, class ...TParams> class FunctorEventHandler : public AbstractEventHandler<TParams...> { public: FunctorEventHandler( FunctorHolder<TFunctor>& functorHolder ) : AbstractEventHandler<TParams...>(), m_functorHolder( functorHolder ) { } virtual void call( TParams... params ) override { m_functorHolder.m_functor( params... ); } private: FunctorHolder<TFunctor>& m_functorHolder; . . . }; template<class TFunctor> class FunctorHolder { public: FunctorHolder( TFunctor& functor ) : m_functor( functor ) { } template<class ...TCallParams> operator AbstractEventHandler<TCallParams...>&() { return *new FunctorEventHandler<TFunctor, TCallParams...>( *this ); } private: TFunctor& m_functor; . . . template<class TFunctor, class ...TParams> friend class FunctorEventHandler; }; template<class TFunctor> FunctorHolder<TFunctor>& createFunctorEventHandler( TFunctor&& functor ) { return *new FunctorHolder<TFunctor>( functor ); } #define FUNCTOR_HANDLER( Functor ) createFunctorEventHandler( Functor ) #define LAMBDA_HANDLER( Lambda ) FUNCTOR_HANDLER( Lambda ) #define STD_FUNCTION_HANDLER( StdFunction ) FUNCTOR_HANDLER( StdFunction ) #define FUNCTION_HANDLER( Function ) FUNCTOR_HANDLER( &Function ) template<class ...TParams> class IEvent { protected: using TEventHandler = AbstractEventHandler<TParams...>; public: template<class TSome> bool operator+=( TSome&& some ) { return addHandler( static_cast<TEventHandler&>( some ) ); } template<class TSome> bool operator-=( TSome&& some ) { return removeHandler( static_cast<TEventHandler&>( some ) ); } protected: IEvent() {} virtual bool addHandler( TEventHandler& eventHandler ) = 0; virtual bool removeHandler( TEventHandler& eventHandler ) = 0; }; In short, the separation of the moments of creating a handler and attaching it to an event here is more pronounced than before. This allows you to bypass the problems described in the previous paragraph. The type compatibility check will occur when trying to caste a particular FunctorHolder to a certain FunctorEventHandler , or rather, to create an instance of the class FunctorEventHandler <....> With a very specific type of functor; and in this class there will be a line of code m_functorHolder.m_functor (params ...); , which is simply not compiled for a set of types incompatible with a functor (or if it is not a functor at all, that is, an object that does not have a operator () ).
I repeat that the problem of deleting temporary objects will be discussed below. In addition, it is worth noting that a bunch of macros for each case is made, firstly, in order to demonstrate the capabilities of this type of handler, and secondly, in case of possible modification by a file of any of them.
Check the result.
class TestWindow { . . . public: TEvent<const std::string&, unsigned int> onButtonClick; . . . }; struct Functor { void operator()( const std::string&, unsigned int ) {} }; struct Functor2 { void operator()( std::string, unsigned int ) {} }; struct Functor3 { void operator()( const std::string&, const unsigned int& ) {} }; struct Functor4 { void operator()( std::string, const unsigned int& ) {} }; struct Functor5 { void operator()( std::string&, unsigned int& ) {} }; struct Functor6 { void operator()( const std::string&, unsigned int& ) {} }; struct Functor7 { void operator()( std::string&, const unsigned int& ) {} }; int main( int argc, char *argv[] ) { . . . TestWindow testWindow; Functor functor; Functor2 functor2; Functor3 functor3; Functor4 functor4; Functor5 functor5; Functor6 functor6; Functor7 functor7; testWindow.onButtonClick += FUNCTOR_HANDLER( functor ); // ok testWindow.onButtonClick += FUNCTOR_HANDLER( functor2 ); // ok testWindow.onButtonClick += FUNCTOR_HANDLER( functor3 ); // ok testWindow.onButtonClick += FUNCTOR_HANDLER( functor4 ); // ok testWindow.onButtonClick += FUNCTOR_HANDLER( functor5 ); // compile error testWindow.onButtonClick += FUNCTOR_HANDLER( functor6 ); // ok testWindow.onButtonClick += FUNCTOR_HANDLER( functor7 ); // compile error . . . } A compilation error occurs when trying to convert one of the parameters from const lvalue to lvalue . Converting from rvalue to unconst lvalue does not cause an error, although it is worth noting that it creates a potential threat to a self-shot in the leg: the handler will be able to change the variable copied to the stack, which will happily be deleted when it leaves this handler.
In general, the error message should look something like this:
Error C2664 'void Functor5::operator ()(std::string &,unsigned int &)': cannot convert argument 1 from 'const std::string' to 'std::string &' For greater clarity, when using events and handlers in third-party code, you can add your own error message. This will require writing a small supporting structure (I admit, I have peeped around this approach):
namespace { template<class TFunctor, class ...TParams> struct IsFunctorParamsCompatible { private: template<class TCheckedFunctor, class ...TCheckedParams> static constexpr std::true_type exists( decltype( std::declval<TCheckedFunctor>()( std::declval<TCheckedParams>()... ) )* = nullptr ); template<class TCheckedFunctor, class ...TCheckedParams> static constexpr std::false_type exists( ... ); public: static constexpr bool value = decltype( exists<TFunctor, TParams...>( nullptr ) )::value; }; } // template<class TFunctor, class ...TParams> class FunctorEventHandler : public AbstractEventHandler<TParams...> { . . . public: virtual void call( TParams... params ) override { static_assert( IsFunctorParamsCompatible<TFunctor, TParams...>::value, "Event and functor arguments are not compatible" ); m_functorHolder->m_functor( params... ); } . . . }; This work is based on the SFINAE mechanism. In short, an attempt is made to compile the first exists function, however, if this fails due to the incompatibility of the arguments (or the lack of operator () of what is passed as a functor), the compiler does not throw an error, but simply tries to compile the second function; we do everything so that its compilation is always successful, and then, in fact, which of the functions was compiled, we conclude (writing the result in value ) about the compatibility of the arguments for the given types.
Now the error message will look like this:
Error C2338 Event and functor arguments are not compatible Error C2664 'void Functor5::operator ()(std::string &,unsigned int &)': cannot convert argument 1 from 'const std::string' to 'std::string &' In addition to an additional, more informative error message, this approach solves the problem of converting argument (s) from rvalue to unconst lvalue : now it causes an error of incompatible arguments, i.e. an attempt to add the functor6 handler from the example above results in a compile-time error.
UPD. Revision (without preserving the sequence of the story).
Comparison of functors
Due to changes in the class handler, the implementation of comparing instances of this class will change a little. Again, I will only give the implementation of a handler-functor, because a handler-method (-function-member of a class) will look similar.
template<class ...TParams> class AbstractEventHandler { . . . using MyType = AbstractEventHandler<TParams...>; public: bool operator==( const MyType& other ) const { return isEquals( other ); } bool operator!=( const MyType& other ) const { return !( *this == other ); } protected: virtual bool isEquals( const MyType& other ) const = 0; . . . }; template<class TFunctor, class ...TParams> class FunctorEventHandler : public AbstractEventHandler<TParams...> { . . . using MyType = FunctorEventHandler<TFunctor, TParams...>; protected: virtual bool isEquals( const AbstractEventHandler<TParams...>& other ) const override { const MyType* _other = dynamic_cast<const MyType*>( &other ); return ( _other != nullptr && *m_functorHolder == *_other->m_functorHolder ); } private: FunctorHolder<TFunctor>& m_functorHolder; . . . }; template<class TFunctor> class FunctorHolder { . . . using MyType = FunctorHolder<TFunctor>; public: bool operator==( const MyType& other ) const { return ( m_functor == other.m_functor ); } bool operator!=( const MyType& other ) const { return !( *this == other ); } private: TFunctor& m_functor; . . . }; At this similarity in the implementation of the comparison ends and begins part only for handlers-functors.
As noted above, we have obtained several types of handler-functors: directly objects-functors, lambda expressions, instances of the class std :: function , separate functions. Of these, functor objects, lambda expressions, and instances of the std :: function class cannot be compared using operator == (they need to be compared by address), but individual functions can, because already stored at. In order not to rewrite the comparison function separately for each case, we write it in a general form:
namespace { template<class TEqu, class TEnabled = void> struct EqualityChecker; template<class TEquatable> struct EqualityChecker<TEquatable, typename std::enable_if<is_equatable<TEquatable>::value>::type> { static constexpr bool isEquals( const TEquatable& operand1, const TEquatable& operand2 ) { return ( operand1 == operand2 ); } }; template<class TNonEquatable> struct EqualityChecker<TNonEquatable, typename std::enable_if<!is_equatable<TNonEquatable>::value>::type> { static constexpr bool isEquals( const TNonEquatable& operand1, const TNonEquatable& operand2 ) { return ( &operand1 == &operand2 ); } }; } // template<class TFunctor> class FunctorHolder { . . . using MyType = FunctorHolder<TFunctor>; public: bool operator==( const MyType& other ) const { return EqualityChecker<TFunctor>::isEquals( m_functor, other.m_functor ); } private: TFunctor& m_functor; . . . }; It is implied that is_equatable is an auxiliary template that determines whether two instances of a given type can be checked for equality. With it, using std :: enable_if , we choose one of two partially specialized structures EqualityChecker , which will make the comparison: by value or by address. Implemented is_equatable it can be as follows:
template<class T> class is_equatable { private: template<class U> static constexpr std::true_type exists( decltype( std::declval<U>() == std::declval<U>() )* = nullptr ); template<class U> static constexpr std::false_type exists( ... ); public: static constexpr bool value = decltype( exists<T>( nullptr ) )::value; }; This implementation is based on the SFINAE mechanism that was previously used . Only here we check the availability of operator == for instances of a given class.
In such a simple way, the implementation of the comparison of handlers-functors is ready.
Garbage collection
Be indulgent, I also wanted to insert a loud headline.
We are approaching the final, and it’s time to get rid of the huge amount of objects that are being created that no one controls.
At each event of the event with the handler, two objects are created: Holder , which stores the executable part of the handler, and EventHandlerassociating it with an event. Do not forget that in the case of an attempt to re-add the handler, no addition will occur - two objects “hung in the air” (unless, of course, separately check this case each time). Another situation: delete handler; two new objects are also created to search for the same (equal) in the list of event handlers; The handler found from the list is, of course, removed (if any), and this temporary, created for search and consisting of two objects, is again “in the air”. In general, not cool.
Turn to smart pointers . It is necessary to determine what the semantics of ownership of each of the two handler objects will be: sole ownership ( std :: unique_ptr ) or shared ( std :: shared_ptr ).
Holderbesides using the event itself when adding / deleting should be stored in the EventHandler , therefore we use for shared ownership, and for the EventHandler , the sole ownership , because after creation, it will be stored only in the list of event handlers.
We implement this idea:
template<class ...TParams> class AbstractEventHandler { . . . public: virtual ~AbstractEventHandler() {} . . . }; template<class ...Types> using THandlerPtr = std::unique_ptr<AbstractEventHandler<Types...>>; namespace { template<class TSome> struct HandlerCast { template<class ...Types> static constexpr THandlerPtr<Types...> cast( TSome& some ) { return static_cast<THandlerPtr<Types...>>( some ); } }; template<class TPtr> struct HandlerCast<std::shared_ptr<TPtr>> { template<class ...Types> static constexpr THandlerPtr<Types...> cast( std::shared_ptr<TPtr> some ) { return HandlerCast<TPtr>::cast<Types...>( *some ); } }; } // template<class ...TParams> class IEvent { public: template<class TSome> bool operator+=( TSome&& some ) { return addHandler( HandlerCast<TSome>::cast<TParams...>( some ) ); } template<class TSome> bool operator-=( TSome&& some ) { return removeHandler( HandlerCast<TSome>::cast<TParams...>( some ) ); } protected: using TEventHandlerPtr = THandlerPtr<TParams...>; IEvent() {} virtual bool addHandler( TEventHandlerPtr eventHandler ) = 0; virtual bool removeHandler( TEventHandlerPtr eventHandler ) = 0; }; template<class ...TParams> class TEvent : public IEvent<TParams...> { using TEventHandlerIt = typename std::list<TEventHandlerPtr>::const_iterator; public: TEvent() { . . . } ~TEvent() { // empty } protected: virtual bool addHandler( TEventHandlerPtr eventHandler ) override { std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex ); if( findEventHandler( eventHandler ) == m_handlers.end() ) { m_handlers.push_back( std::move( eventHandler ) ); return true; } return false; } virtual bool removeHandler( TEventHandlerPtr eventHandler ) override { . . . } private: // 'm_handlerListMutex' inline TEventHandlerIt findEventHandler( const TEventHandlerPtr& eventHandler ) const { return std::find_if( m_handlers.cbegin(), m_handlers.cend(), [ &eventHandler ]( const TEventHandlerPtr& oneHandler ) { return ( *oneHandler == *eventHandler ); } ); } // 'm_handlerListMutex' inline void deleteHandler( TEventHandlerIt it ) { m_handlers.erase( it ); } std::list<TEventHandlerPtr> m_handlers; . . . }; template<class TMethodHolder, class ...TParams> class MethodEventHandler : public AbstractEventHandler<TParams...> { . . . using TMethodHolderPtr = std::shared_ptr<TMethodHolder>; public: MethodEventHandler( TMethodHolderPtr methodHolder ) : AbstractEventHandler<TParams...>(), m_methodHolder( methodHolder ) { assert( m_methodHolder != nullptr ); } private: TMethodHolderPtr m_methodHolder; . . . }; template<class TObject, class ...TParams> class MethodHolder { using MyType = MethodHolder<TObject, TParams...>; using TMethod = void( TObject::* )( TParams... ); public: MethodHolder( TObject& object, TMethod method ) { . . . } template<class ...TCallParams> operator THandlerPtr<TCallParams...>() { return THandlerPtr<TCallParams...>( new MethodEventHandler<MyType, TCallParams...>( /* ? */ ) ); } . . . }; template<class TObject, class ...TParams> std::shared_ptr<MethodHolder<TObject, TParams...>> createMethodEventHandler( TObject& object, void( TObject::*method )( TParams... ) ) { return std::shared_ptr<MethodHolder<TObject, TParams...>>( new MethodHolder<TObject, TParams...>( object, method ) ); } #define METHOD_HANDLER( Object, Method ) createMethodEventHandler( Object, &Method ) #define MY_METHOD_HANDLER( Method ) METHOD_HANDLER( *this, Method ) Everything in order.
To start the event and its interface for working with handlers. In the latter, converting types directly using static_cast will no longer work, because the type to be transformed lies "inside" std :: shared_ptr . Now for such a transformation we will use the auxiliary structure HandlerCast , which by its private specialization will provide access to the object inside std :: shared_ptr , and already working with it (in its non-specialized implementation), apply the good old static_cast .
The event itself; There are some important changes here too. First, stop manually deleting instances of handlers in the destructor and during deletion; now it is enough to remove from the list a smart pointer with this handler. In addition, when adding a handler, it is important not to forget std :: move , since std :: unique_ptr does not support copying (which is quite logical for such semantics).
Let's go to the handlers. According to the old tradition, only one of them is given, the second is similar. And here, at first glance, it all comes down to changing the types of stored / created objects from links / pointers to smart pointers.
But there is one subtle point. The createMethodEventHandler function will return std :: shared_ptr to the instance.MethodHolder . A little later, an attempt will be made to convert it to a handler type ( MethodEventHandler ), where it will have to create a new instance of MethodEventHandler , passing it to the constructor std :: shared_ptr to itself. That was how it was intended that the MethodHolder instance would later retire when the MethodEventHandler instance was deleted . But the problem is that MethodHolder does not have access to the already created std :: shared_ptr that stores it.
To solve the problem, you will have to store a smart pointer to yourself in MethodHolder . However, so that he does not affect his removal, we usestd :: weak_ptr :
template<class TObject, class ...TParams> class MethodHolder { using MyType = MethodHolder<TObject, TParams...>; using TMethod = void( TObject::* )( TParams... ); public: template<class ...TCallParams> operator THandlerPtr<TCallParams...>() { return THandlerPtr<TCallParams...>( new MethodEventHandler<MyType, TCallParams...>( m_me.lock() ) ); } template<class TObject, class ...TParams> static std::shared_ptr<MyType> create( TObject& object, TMethod method ) { std::shared_ptr<MyType> result( new MyType( object, method ) ); result->m_me = result; return result; } private: MethodHolder( TObject& object, TMethod method ) : m_object( object ), m_method( method ) { assert( m_method != nullptr ); } TObject& m_object; TMethod m_method; std::weak_ptr<MyType> m_me; }; template<class TObject, class ...TParams> std::shared_ptr<MethodHolder<TObject, TParams...>> createMethodEventHandler( TObject& object, void( TObject::*method )( TParams... ) ) { return MethodHolder<TObject, TParams...>::create( object, method ); } For better clarity, I’ll give an approximate order of events when removing a handler from an event (my apologies for the random pun):
- an event deletes an element from the list ( m_handlers.erase (it); ), which causes its destructor to be called;
- the std :: unique_ptr destructor is called , which causes the managed object's destructor to be called ;
- The MethodEventHandler destructor is called , which removes all object fields, including the m_methodHolder field , which is std :: shared_ptr ;
- std::shared_ptr ; , (.. ) ( MethodHolder ); , std::weak_ptr ;
- MethodHolder , , , m_me , std::weak_ptr ;
- std::weak_ptr ; ; because std::weak_ptr , ;
- profit
It is important to remember that the destructor of the AbstractEventHandler class must be virtual; otherwise, after point 2 in point 3 , the AbstractEventHandler destructor will be called and no further actions will be performed.
Connection of event and handler
In some cases, when adding / removing a single handler from an event occurs quite often (according to some logic), I don’t want to mess around, taking an instance of the event and an instance of the handler each time to once again implement a subscription / unsubscribe from this event. And you want to connect them once, and then, if necessary, work with this connection, adding / removing with it the predefined handler from a predetermined event. You can implement this as follows:
template<class ...Types> using THandlerPtr = std::shared_ptr<AbstractEventHandler<Types...>>; template<class ...TParams> class IEvent { . . . protected: using TEventHandlerPtr = THandlerPtr<TParams...>; virtual bool isHandlerAdded( const TEventHandlerPtr& eventHandler ) const = 0; virtual bool addHandler( TEventHandlerPtr eventHandler ) = 0; virtual bool removeHandler( TEventHandlerPtr eventHandler ) = 0; friend class HandlerEventJoin<TParams...>; . . . }; template<class ...TParams> class TEvent : public IEvent<TParams...> { . . . protected: virtual bool isHandlerAdded( const TEventHandlerPtr& eventHandler ) const override { std::shared_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex ); return ( findEventHandler( eventHandler ) != m_handlers.end() ); } virtual bool addHandler( TEventHandlerPtr eventHandler ) override { . . . } virtual bool removeHandler( TEventHandlerPtr eventHandler ) override { . . . } private: // 'm_handlerListMutex' inline TEventHandlerIt findEventHandler( const TEventHandlerPtr& eventHandler ) const { . . . } std::list<TEventHandlerPtr> m_handlers; mutable std::shared_mutex m_handlerListMutex; . . . }; template<class ...TParams> class HandlerEventJoin { public: HandlerEventJoin( IEvent<TParams...>& _event, THandlerPtr<TParams...> handler ) : m_event( _event ), m_handler( handler ) { } inline bool isJoined() const { return m_event.isHandlerAdded( m_handler ); } inline bool join() { return m_event.addHandler( m_handler ); } inline bool unjoin() { return m_event.removeHandler( m_handler ); } private: IEvent<TParams...>& m_event; THandlerPtr<TParams...> m_handler; }; As you can see, now we have added another possible storage location for the handler instance, so we will use std :: shared_ptr for this instead of std :: unique_ptr .
However, this class, as for me, is slightly inconvenient to use. It would be desirable to store and create instances of connections without a list of parameters instantiating a class template.
We do this with the help of an abstract ancestor class and a wrapper:
class AbstractEventJoin { public: virtual ~AbstractEventJoin() {} virtual bool isJoined() const = 0; virtual bool join() = 0; virtual bool unjoin() = 0; protected: AbstractEventJoin() {} }; template<class ...TParams> class HandlerEventJoin : public AbstractEventJoin { . . . public: virtual inline bool isJoined() const override { . . . } virtual inline bool join() override { . . . } virtual inline bool unjoin() override { . . . } . . . }; class EventJoinWrapper { public: template<class TSome, class ...TParams> inline EventJoinWrapper( IEvent<TParams...>& _event, TSome&& handler ) : m_eventJoin( std::make_shared<HandlerEventJoin<TParams...>>( _event, HandlerCast<TSome>::cast<TParams...>( handler ) ) ) { } constexpr EventJoinWrapper() : m_eventJoin( nullptr ) { } ~EventJoinWrapper() { if( m_eventJoin != nullptr ) delete m_eventJoin; } operator bool() const { return isJoined(); } bool isAssigned() const { return ( m_eventJoin != nullptr ); } bool isJoined() const { return ( m_eventJoin != nullptr && m_eventJoin->isJoined() ); } bool join() { return ( m_eventJoin != nullptr ? m_eventJoin->join() : false ); } bool unjoin() { return ( m_eventJoin != nullptr ? m_eventJoin->unjoin() : false ); } private: AbstractEventJoin* m_eventJoin; }; using EventJoin = EventJoinWrapper; HandlerCast is the same supporting structure that was used here . By the way, it is important not to forget to make the AbstractEventJoin destructor virtual so that when you delete its instance in the EventJoinWrapper destructor, the HandlerEventJoin destructor is called , otherwise the THandlerPtr field and, therefore, the handler itself will not be destroyed .
This implementation seems to work, but only at first glance. Copying or moving an EventJoinWrapper instance will re-delete m_eventJoin in its destructor. Therefore, we use std :: shared_ptr to store the instance.AbstractEventJoin , as well as implement slightly optimized motion semantics (and copying), since this will be a potentially frequent operation.
class EventJoinWrapper { public: EventJoinWrapper( EventJoinWrapper&& other ) : m_eventJoin( std::move( other.m_eventJoin ) ) { } EventJoinWrapper( EventJoinWrapper& other ) : m_eventJoin( other.m_eventJoin ) { } ~EventJoinWrapper() { /*empty*/ } EventJoinWrapper& operator=( EventJoinWrapper&& other ) { m_eventJoin = std::move( other.m_eventJoin ); return *this; } EventJoinWrapper& operator=( const EventJoinWrapper& other ) { m_eventJoin = other.m_eventJoin; return *this; } . . . private: std::shared_ptr<AbstractEventJoin> m_eventJoin; }; Now, when connecting the handler to the event, you can immediately return an instance of the new connection:
template<class ...TParams> class IEvent { . . . public: template<class TSome> EventJoin operator+=( TSome&& some ) { EventJoin result( *this, std::forward<TSome>( some ) ); result.join(); return result; } . . . }; And after settling the triangular dependencies by include (IEvent <= EventJointWrapper.hpp; EventJointWrapper <= HandlerEventJoin.hpp; HandlerEventJoin <= IEvent.hpp) you can even work with splitting some files into .h and .hpp .
Creation of instances of connections occurs according to the same rules as when a handler is subscribed to an event:
struct EventHolder { TEvent<const std::string&> onEvent; }; struct MethodsHolder { void method1( const std::string& ) {} void method2( std::string ) {} void method3( std::string&& ) {} void method4( std::string& ) {} void method5( const int& ) {} }; int main( int argc, char* argv[] ) { EventHolder _eventHolder; MethodsHolder _methodsHolder; EventJoin join1 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method1 ) ); // ok EventJoin join2 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method2 ) ); // ok EventJoin join3 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method3 ) ); // error EventJoin join4 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method4 ) ); // error EventJoin join5 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method5 ) ); // error return 0; } Plus, you can “turn on” / “turn off” event handling (for which, in principle, connections were created):
struct EventHolder { TEvent<const std::string&, unsigned int> onEvent; }; struct MethodsHolder { void handleEvent( const std::string& text, unsigned int count ) { std::cout << "Text '" << text << "' handled " << count << " times." << std::endl; } }; int main__( int argc, char* argv[] ) { EventHolder _eventHolder; MethodsHolder methodsHolder; EventJoin eventJoin = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( methodsHolder, MethodsHolder::handleEvent ) ); static const std::string handlingText = "testing..."; for( int i = 0; i < 10; ++i ) { if( eventJoin.isJoined() ) eventJoin.unjoin(); else eventJoin.join(); _eventHolder.onEvent( handlingText, i ); } return 0; } Text 'testing...' handled 0 times. Text 'testing...' handled 2 times. Text 'testing...' handled 4 times. Text 'testing...' handled 6 times. Text 'testing...' handled 8 times. Total
First, it is worth noting that the task to write an article as briefly and concisely as possible is completely failed.
I hope that the resulting implementation of event handling is quite efficient and will be at least useful to someone.
A rather cumbersome example demonstrating the main features.
Conclusion:
#include <iostream> #include <functional> #include "events/event.hpp" #include "events/handler/methodeventhandler.hpp" #include "events/handler/functoreventhandler.hpp" #include "events/join/handlereventjoin.hpp" #include "events/join/eventjoinwrapper.hpp" class Foo { public: Foo() : onMake( m_onMake ), m_onMake(), m_onMakeInner(), m_makeCount( 0 ) { m_onMakeInner += FUNCTOR_HANDLER( m_onMake ); } IEvent<unsigned int>& onMake; void make() { m_onMakeInner( m_makeCount++ ); } private: TEvent<unsigned int> m_onMake, m_onMakeInner; unsigned int m_makeCount; }; namespace instances { Foo& getFoo() { static Foo _foo; return _foo; } } // instances struct FunctorHandler { void operator()( unsigned int makeCount ); }; void functionHandler( unsigned int makeCount ); class ClassHandler { public: void handle( unsigned int makeCount ); }; namespace instances { FunctorHandler& getFunctorHandler() { static FunctorHandler _functorHandler; return _functorHandler; } std::function<void( unsigned int )>& getStdFunctionHandler() { static std::function<void( unsigned int )> _stdFunctionHandler = []( unsigned int makeCount ) { std::cout << "It's std::function handler" << std::endl; if( makeCount >= 2 ) instances::getFoo().onMake -= STD_FUNCTION_HANDLER( instances::getStdFunctionHandler() ); }; return _stdFunctionHandler; } ClassHandler& getClassHandler() { static ClassHandler _classHandler; return _classHandler; } } // instances void FunctorHandler::operator()( unsigned int makeCount ) { std::cout << "It's functor handler" << std::endl; if( makeCount >= 0 ) instances::getFoo().onMake -= FUNCTOR_HANDLER( instances::getFunctorHandler() ); } void functionHandler( unsigned int makeCount ) { std::cout << "It's function handler" << std::endl; if( makeCount >= 3 ) instances::getFoo().onMake -= FUNCTION_HANDLER( functionHandler ); } void ClassHandler::handle( unsigned int makeCount ) { std::cout << "It's method handler" << std::endl; if( makeCount >= 4 ) instances::getFoo().onMake -= MY_METHOD_HANDLER( ClassHandler::handle ); } int main( int argc, char* argv[] ) { Foo& foo = instances::getFoo(); auto lambdaHandler = []( unsigned int ) { std::cout << "It's lambda handler" << std::endl; }; foo.onMake += FUNCTOR_HANDLER( instances::getFunctorHandler() ); foo.onMake += LAMBDA_HANDLER( lambdaHandler ); EventJoin lambdaJoin = foo.onMake += LAMBDA_HANDLER( ( [ &foo, &lambdaHandler ]( unsigned int makeCount ) { if( makeCount >= 1 ) foo.onMake -= LAMBDA_HANDLER( lambdaHandler ); } ) ); foo.onMake += STD_FUNCTION_HANDLER( instances::getStdFunctionHandler() ); foo.onMake += FUNCTION_HANDLER( functionHandler ); foo.onMake += METHOD_HANDLER( instances::getClassHandler(), ClassHandler::handle ); for( int i = 0; i < 6; ++i ) { std::cout << "Make " << i << " time:" << std::endl; foo.make(); std::cout << std::endl; } lambdaJoin.unjoin(); return 0; } Conclusion:
Make 0 time: It's functor handler It's lambda handler It's std::function handler It's function handler It's method handler Make 1 time: It's lambda handler It's std::function handler It's function handler It's method handler Make 2 time: It's std::function handler It's function handler It's method handler Make 3 time: It's function handler It's method handler Make 4 time: It's method handler Make 5 time: It is worth noting a number of important points:
- it was not specified separately, therefore, I will mention that the event itself in this implementation is a functor, and therefore, can act as a handler for another event;
- now you cannot use constant methods (class member functions) as handlers; I think that if such an opportunity is needed, it is not difficult to write for this a new type of handler based on the existing ones.
In addition, in the final version there are some points omitted in the article for greater clarity and readability of the code:
- the return type of the method (the class member function) for the corresponding handler can be any, not necessarily void (for handlers-functors this was done and so);
- the whole implementation is wrapped in namespaces for ease of use in projects (if this seems odd to someone, they can always be removed);
- here and there the noexcept specifier is added .
To all those who read to here at least diagonally, a low bow. I enclose all the code; You can also take it here (with all the latest modifications).
All code
./events/helpers/is_equatable.hpp
#pragma once #include <type_traits> template<class T> class is_equatable { private: template<class U> static constexpr std::true_type exists( decltype( std::declval<U>() == std::declval<U>() )* = nullptr ) noexcept; template<class U> static constexpr std::false_type exists( ... ) noexcept; public: static constexpr bool value = decltype( exists<T>( nullptr ) )::value; }; ./events/handlers/abstracteventhandler.hpp
#pragma once #include "eventhandlerptr.h" namespace events { namespace handlers { template<class ...TParams> class AbstractEventHandler { using MyType = AbstractEventHandler<TParams...>; public: virtual ~AbstractEventHandler() {} virtual void call( TParams... params ) = 0; bool operator==( const MyType& other ) const noexcept { return isEquals( other ); } bool operator!=( const MyType& other ) const noexcept { return !( *this == other ); } protected: AbstractEventHandler() {} virtual bool isEquals( const MyType& other ) const noexcept = 0; }; } // handlers } // events ./events/handlers/eventhandlerptr.h
#pragma once #include <memory> namespace events { namespace handlers { template<class ...TParams> class AbstractEventHandler; template<class ...Types> using TEventHandlerPtr = std::shared_ptr<AbstractEventHandler<Types...>>; } // handlers } // events ./events/handlers/functoreventhandler.hpp
#pragma once #include <memory> #include <assert.h> #include "abstracteventhandler.hpp" #include "../helpers/is_equatable.hpp" namespace events { namespace handlers { namespace { template<class TFunctor, class ...TParams> struct IsFunctorParamsCompatible { private: template<class TCheckedFunctor, class ...TCheckedParams> static constexpr std::true_type exists( decltype( std::declval<TCheckedFunctor>()( std::declval<TCheckedParams>()... ) )* = nullptr ) noexcept; template<class TCheckedFunctor, class ...TCheckedParams> static constexpr std::false_type exists( ... ) noexcept; public: static constexpr bool value = decltype( exists<TFunctor, TParams...>( nullptr ) )::value; }; } // template<class TFunctor> class FunctorHolder; template<class TFunctor, class ...TParams> class FunctorEventHandler : public AbstractEventHandler<TParams...> { using MyType = FunctorEventHandler<TFunctor, TParams...>; using TFunctorHolderPtr = std::shared_ptr<FunctorHolder<TFunctor>>; public: FunctorEventHandler( TFunctorHolderPtr functorHolder ) : AbstractEventHandler<TParams...>(), m_functorHolder( functorHolder ) { assert( m_functorHolder != nullptr ); } virtual void call( TParams... params ) override { static_assert( IsFunctorParamsCompatible<TFunctor, TParams...>::value, "Event and functor arguments are not compatible" ); m_functorHolder->m_functor( params... ); } protected: virtual bool isEquals( const AbstractEventHandler<TParams...>& other ) const noexcept override { const MyType* _other = dynamic_cast<const MyType*>( &other ); return ( _other != nullptr && *m_functorHolder == *_other->m_functorHolder ); } private: TFunctorHolderPtr m_functorHolder; }; namespace { template<class TEqu, class TEnabled = void> struct EqualityChecker; template<class TEquatable> struct EqualityChecker<TEquatable, typename std::enable_if<is_equatable<TEquatable>::value>::type> { static constexpr bool isEquals( const TEquatable& operand1, const TEquatable& operand2 ) noexcept { return ( operand1 == operand2 ); } }; template<class TNonEquatable> struct EqualityChecker<TNonEquatable, typename std::enable_if<!is_equatable<TNonEquatable>::value>::type> { static constexpr bool isEquals( const TNonEquatable& operand1, const TNonEquatable& operand2 ) noexcept { return ( &operand1 == &operand2 ); } }; } // template<class TFunctor> class FunctorHolder { using MyType = FunctorHolder<TFunctor>; public: template<class ...TCallParams> operator TEventHandlerPtr<TCallParams...>() { return TEventHandlerPtr<TCallParams...>( new FunctorEventHandler<TFunctor, TCallParams...>( m_me.lock() ) ); } bool operator==( const MyType& other ) const noexcept { return EqualityChecker<TFunctor>::isEquals( m_functor, other.m_functor ); } bool operator!=( const MyType& other ) const noexcept { return !( *this == other ); } template<class TFunctor> static std::shared_ptr<MyType> create( TFunctor&& functor ) { std::shared_ptr<MyType> result( new MyType( functor ) ); result->m_me = result; return result; } private: FunctorHolder( TFunctor& functor ) : m_functor( functor ), m_me() { } TFunctor& m_functor; std::weak_ptr<MyType> m_me; template<class TFunctor, class ...TParams> friend class FunctorEventHandler; }; template<class TFunctor> std::shared_ptr<FunctorHolder<TFunctor>> createFunctorEventHandler( TFunctor&& functor ) { return FunctorHolder<TFunctor>::create( functor ); } } // handlers } // events #define FUNCTOR_HANDLER( Functor ) ::events::handlers::createFunctorEventHandler( Functor ) #define LAMBDA_HANDLER( Lambda ) FUNCTOR_HANDLER( Lambda ) #define STD_FUNCTION_HANDLER( StdFunction ) FUNCTOR_HANDLER( StdFunction ) #define FUNCTION_HANDLER( Function ) FUNCTOR_HANDLER( &Function ) ./events/handlers/methodeventhandler.hpp
#pragma once #include <memory> #include <assert.h> #include "abstracteventhandler.hpp" namespace events { namespace handlers { namespace { template<class TMethodHolder, class ...TParams> struct IsMethodParamsCompatible { private: template<class TCheckedMethodHolder, class ...TCheckedParams> static constexpr std::true_type exists( decltype( ( std::declval<TCheckedMethodHolder>().m_object.*std::declval<TCheckedMethodHolder>().m_method )( std::declval<TCheckedParams>()... ) )* = nullptr ) noexcept; template<class TCheckedMethodHolder, class ...TCheckedParams> static constexpr std::false_type exists( ... ) noexcept; public: static constexpr bool value = decltype( exists<TMethodHolder, TParams...>( nullptr ) )::value; }; } // template<class TMethodHolder, class ...TParams> class MethodEventHandler : public AbstractEventHandler<TParams...> { using MyType = MethodEventHandler<TMethodHolder, TParams...>; using TMethodHolderPtr = std::shared_ptr<TMethodHolder>; public: MethodEventHandler( TMethodHolderPtr methodHolder ) : AbstractEventHandler<TParams...>(), m_methodHolder( methodHolder ) { assert( m_methodHolder != nullptr ); } virtual void call( TParams... params ) override { static_assert( IsMethodParamsCompatible<TMethodHolder, TParams...>::value, "Event and method arguments are not compatible" ); ( m_methodHolder->m_object.*m_methodHolder->m_method )( params... ); } protected: virtual bool isEquals( const AbstractEventHandler<TParams...>& other ) const noexcept override { const MyType* _other = dynamic_cast<const MyType*>( &other ); return ( _other != nullptr && *m_methodHolder == *_other->m_methodHolder ); } private: TMethodHolderPtr m_methodHolder; }; template<class TObject, class TResult, class ...TParams> class MethodHolder { using MyType = MethodHolder<TObject, TResult, TParams...>; using TMethod = TResult( TObject::* )( TParams... ); public: template<class ...TCallParams> operator TEventHandlerPtr<TCallParams...>() { return TEventHandlerPtr<TCallParams...>( new MethodEventHandler<MyType, TCallParams...>( m_me.lock() ) ); } bool operator==( const MyType& other ) const noexcept { return ( &m_object == &other.m_object && m_method == other.m_method ); } bool operator!=( const MyType& other ) const noexcept { return !( *this == other ); } template<class TObject, class ...TParams> static std::shared_ptr<MyType> create( TObject& object, TMethod method ) { std::shared_ptr<MyType> result( new MyType( object, method ) ); result->m_me = result; return result; } private: MethodHolder( TObject& object, TMethod method ) : m_object( object ), m_method( method ) { assert( m_method != nullptr ); } TObject& m_object; TMethod m_method; std::weak_ptr<MyType> m_me; template<class TMethodHolder, class ...TParams> friend class MethodEventHandler; template<class TMethodHolder, class ...TParams> friend struct IsMethodParamsCompatible; }; template<class TObject, class TResult, class ...TParams> std::shared_ptr<MethodHolder<TObject, TResult, TParams...>> createMethodEventHandler( TObject& object, TResult( TObject::*method )( TParams... ) ) { return MethodHolder<TObject, TResult, TParams...>::create( object, method ); } } // handlers } // events #define METHOD_HANDLER( Object, Method ) ::events::handlers::createMethodEventHandler( Object, &Method ) #define MY_METHOD_HANDLER( Method ) METHOD_HANDLER( *this, Method ) ./events/handlers/handlercast.hpp
#pragma once #include <memory> #include "eventhandlerptr.h" namespace events { namespace handlers { template<class TSome> struct HandlerCast { template<class ...Types> static constexpr TEventHandlerPtr<Types...> cast( TSome& some ) { return static_cast<TEventHandlerPtr<Types...>>( some ); } }; template<class TPtr> struct HandlerCast<std::shared_ptr<TPtr>> { template<class ...Types> static constexpr TEventHandlerPtr<Types...> cast( std::shared_ptr<TPtr> some ) { return HandlerCast<TPtr>::cast<Types...>( *some ); } }; } // handlers } // events ./events/event.hpp
#pragma once #include <type_traits> #include <list> #include <memory> #include <shared_mutex> #include <algorithm> #include <assert.h> #include "handlers/abstracteventhandler.hpp" #include "handlers/eventhandlerptr.h" #include "handlers/handlercast.hpp" #include "joins/eventjoinwrapper.hpp" namespace events { namespace joins { template<class ...TParams> class HandlerEventJoin; } template<class ...TParams> class IEvent { public: template<class TSome> EventJoin operator+=( TSome&& some ) { EventJoin result( *this, std::forward<TSome>( some ) ); result.join(); return result; } template<class TSome> bool operator-=( TSome&& some ) { return removeHandler( handlers::HandlerCast<TSome>::cast<TParams...>( some ) ); } protected: using TMyEventHandlerPtr = handlers::TEventHandlerPtr<TParams...>; IEvent() {} virtual bool isHandlerAdded( const TMyEventHandlerPtr& eventHandler ) const = 0; virtual bool addHandler( TMyEventHandlerPtr eventHandler ) = 0; virtual bool removeHandler( TMyEventHandlerPtr eventHandler ) = 0; friend class joins::HandlerEventJoin<TParams...>; }; template<class ...TParams> class TEvent : public IEvent<TParams...> { using TEventHandlerIt = typename std::list<TMyEventHandlerPtr>::const_iterator; public: TEvent() : m_handlers(), m_currentIt(), m_isCurrentItRemoved( false ), m_handlerListMutex() { } void operator()( TParams... params ) { m_handlerListMutex.lock_shared(); m_isCurrentItRemoved = false; m_currentIt = m_handlers.begin(); while( m_currentIt != m_handlers.end() ) { m_handlerListMutex.unlock_shared(); ( *m_currentIt )->call( params... ); m_handlerListMutex.lock_shared(); if( m_isCurrentItRemoved ) { m_isCurrentItRemoved = false; TEventHandlerIt removedIt = m_currentIt; ++m_currentIt; deleteHandler( removedIt ); } else { ++m_currentIt; } } m_handlerListMutex.unlock_shared(); } protected: virtual bool isHandlerAdded( const TMyEventHandlerPtr& eventHandler ) const override { std::shared_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex ); return ( findEventHandler( eventHandler ) != m_handlers.end() ); } virtual bool addHandler( TMyEventHandlerPtr eventHandler ) override { std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex ); if( findEventHandler( eventHandler ) == m_handlers.end() ) { m_handlers.push_back( std::move( eventHandler ) ); return true; } return false; } virtual bool removeHandler( TMyEventHandlerPtr eventHandler ) override { std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex ); auto it = findEventHandler( eventHandler ); if( it != m_handlers.end() ) { if( it == m_currentIt ) m_isCurrentItRemoved = true; else deleteHandler( it ); return true; } return false; } private: // 'm_handlerListMutex' inline TEventHandlerIt findEventHandler( const TMyEventHandlerPtr& eventHandler ) const noexcept { return std::find_if( m_handlers.cbegin(), m_handlers.cend(), [ &eventHandler ]( const TMyEventHandlerPtr& oneHandler ) { return ( *oneHandler == *eventHandler ); } ); } // 'm_handlerListMutex' inline void deleteHandler( TEventHandlerIt it ) { m_handlers.erase( it ); } std::list<TMyEventHandlerPtr> m_handlers; // 'm_handlerListMutex' mutable TEventHandlerIt m_currentIt; mutable bool m_isCurrentItRemoved; mutable std::shared_mutex m_handlerListMutex; }; } // events ./events/joins/abstracteventjoin.h
#pragma once namespace events { namespace joins { class AbstractEventJoin { public: virtual ~AbstractEventJoin(); virtual bool isJoined() const = 0; virtual bool join() = 0; virtual bool unjoin() = 0; protected: AbstractEventJoin(); }; } // joins } // events ./events/joins/abstracteventjoin.cpp
#include "abstracteventjoin.h" namespace events { namespace joins { AbstractEventJoin::AbstractEventJoin() { } AbstractEventJoin::~AbstractEventJoin() { } } // joins } // events ./events/joins/handlereventjoin.h
#pragma once #include "abstracteventjoin.h" #include "../handlers/eventhandlerptr.h" namespace events { template<class ...TParams> class IEvent; namespace joins { template<class ...TParams> class HandlerEventJoin : public AbstractEventJoin { public: HandlerEventJoin( IEvent<TParams...>& _event, ::events::handlers::TEventHandlerPtr<TParams...> handler ) : AbstractEventJoin(), m_event( _event ), m_handler( handler ) { } virtual inline bool isJoined() const override; virtual inline bool join() override; virtual inline bool unjoin() override; private: IEvent<TParams...>& m_event; ::events::handlers::TEventHandlerPtr<TParams...> m_handler; }; } // joins } // events ./events/joins/handlereventjoin.hpp
#pragma once #include "handlereventjoin.h" #include "../event.hpp" namespace events { namespace joins { template<class ...TParams> bool HandlerEventJoin<TParams...>::isJoined() const { return m_event.isHandlerAdded( m_handler ); } template<class ...TParams> bool HandlerEventJoin<TParams...>::join() { return m_event.addHandler( m_handler ); } template<class ...TParams> bool HandlerEventJoin<TParams...>::unjoin() { return m_event.removeHandler( m_handler ); } } // joins } // events ./events/joins/eventjoinwrapper.h
#pragma once #include <memory> #include "../handlers/eventhandlerptr.h" namespace events { template<class ...TParams> class IEvent; namespace joins { class AbstractEventJoin; class EventJoinWrapper { public: template<class TSome, class ...TParams> inline EventJoinWrapper( IEvent<TParams...>& _event, TSome&& handler ); constexpr EventJoinWrapper() noexcept; EventJoinWrapper( EventJoinWrapper&& other ) noexcept; EventJoinWrapper( EventJoinWrapper& other ) noexcept; EventJoinWrapper& operator=( EventJoinWrapper&& other ) noexcept; EventJoinWrapper& operator=( const EventJoinWrapper& other ) noexcept; operator bool() const; bool isAssigned() const; bool isJoined() const; bool join(); bool unjoin(); private: std::shared_ptr<AbstractEventJoin> m_eventJoin; }; } // joins using EventJoin = joins::EventJoinWrapper; } // events ./events/joins/eventjoinwrapper.hpp
#pragma once #include "eventjoinwrapper.h" #include "handlereventjoin.h" #include "../handlers/handlercast.hpp" namespace events { namespace joins { template<class TSome, class ...TParams> EventJoinWrapper::EventJoinWrapper( IEvent<TParams...>& _event, TSome&& handler ) : m_eventJoin( std::make_shared<HandlerEventJoin<TParams...>>( _event, ::events::handlers::HandlerCast<TSome>::cast<TParams...>( handler ) ) ) { } } // joins } // events ./events/joins/eventjoinwrapper.cpp
#include "eventjoinwrapper.h" #include <type_traits> #include "abstracteventjoin.h" namespace events { namespace joins { constexpr EventJoinWrapper::EventJoinWrapper() noexcept : m_eventJoin( nullptr ) { } EventJoinWrapper::EventJoinWrapper( EventJoinWrapper&& other ) noexcept : m_eventJoin( std::move( other.m_eventJoin ) ) { } EventJoinWrapper::EventJoinWrapper( EventJoinWrapper& other ) noexcept : m_eventJoin( other.m_eventJoin ) { } EventJoinWrapper& EventJoinWrapper::operator=( EventJoinWrapper&& other ) noexcept { m_eventJoin = std::move( other.m_eventJoin ); return *this; } EventJoinWrapper& EventJoinWrapper::operator=( const EventJoinWrapper& other ) noexcept { m_eventJoin = other.m_eventJoin; return *this; } EventJoinWrapper::operator bool() const { return isJoined(); } bool EventJoinWrapper::isAssigned() const { return ( m_eventJoin != nullptr ); } bool EventJoinWrapper::isJoined() const { return ( m_eventJoin != nullptr && m_eventJoin->isJoined() ); } bool EventJoinWrapper::join() { return ( m_eventJoin != nullptr ? m_eventJoin->join() : false ); } bool EventJoinWrapper::unjoin() { return ( m_eventJoin != nullptr ? m_eventJoin->unjoin() : false ); } } // joins } // events UPD1. Here and earlier on the article is the code written under VC ++ 14 . For compatibility with other compilers, it is better to take the code by reference. Special thanks to Cheater for ensuring compatibility with GCC .
UPD2. Thank you lexxmark for noticing a thread-safety hole in terms of several simultaneous event calls.
Minor improvements
(, , ) HandlerRunner , . , : currentIt ( ) wasRemoving (, ). HandlerRunner' operator() ; (, ) , EventCore . So , , , , , .
UPD3. Thanks isnullxbh found another error. It is associated with incorrect saving and subsequent reference to objects passed by rvalue (mainly lambda expressions). namespace { template<class ...TParams> struct TypeHelper { using TEventHandlerPtr = handlers::TEventHandlerPtr<TParams...>; using TEventHandlerIt = typename std::list<TEventHandlerPtr>::const_iterator; }; } // template<class ...TParams> class IEvent { . . . protected: using TMyEventHandlerPtr = typename TypeHelper<TParams...>::TEventHandlerPtr; . . . }; namespace { template<class ...TParams> struct EventCore { using TMyHandlerPtr = typename TypeHelper<TParams...>::TEventHandlerPtr; std::list<TMyHandlerPtr> handlers; mutable std::shared_mutex coreMutex; }; template<class ...TParams> class HandlerRunner { using TMyEventCore = EventCore<TParams...>; using TMyHandlerIt = typename TypeHelper<TParams...>::TEventHandlerIt; public: HandlerRunner( TMyEventCore& eventCore ) : m_eventCore( eventCore ), currentIt(), wasRemoving( false ) { } void run( TParams... params ) { m_eventCore.coreMutex.lock_shared(); currentIt = m_eventCore.handlers.begin(); wasRemoving = false; while( currentIt != m_eventCore.handlers.end() ) { m_eventCore.coreMutex.unlock_shared(); ( *currentIt )->call( params... ); m_eventCore.coreMutex.lock_shared(); if( wasRemoving ) wasRemoving = false; else ++currentIt; } m_eventCore.coreMutex.unlock_shared(); } TMyHandlerIt currentIt; mutable bool wasRemoving; private: TMyEventCore& m_eventCore; }; } // template<class ...TParams> class TEvent : public IEvent<TParams...> { using TMyEventHandlerPtr = typename TypeHelper<TParams...>::TEventHandlerPtr; using TMyEventHandlerIt = typename TypeHelper<TParams...>::TEventHandlerIt; using TMyHandlerRunner = HandlerRunner<TParams...>; public: TEvent() : m_core() { } void operator()( TParams... params ) { TMyHandlerRunner newHandlerRunner( m_core ); m_core.coreMutex.lock_shared(); auto it = m_handlerRunners.insert( m_handlerRunners.end(), &newHandlerRunner ); m_core.coreMutex.unlock_shared(); newHandlerRunner.run( params... ); m_core.coreMutex.lock_shared(); m_handlerRunners.erase( it ); m_core.coreMutex.unlock_shared(); } protected: virtual bool isHandlerAdded( const TMyEventHandlerPtr& eventHandler ) const override { std::shared_lock<std::shared_mutex> _coreMutexLock( m_core.coreMutex ); return ( findEventHandler( eventHandler ) != m_core.handlers.end() ); } virtual bool addHandler( TMyEventHandlerPtr eventHandler ) override { std::unique_lock<std::shared_mutex> _coreMutexLock( m_core.coreMutex ); if( findEventHandler( eventHandler ) == m_core.handlers.end() ) { m_core.handlers.push_back( std::move( eventHandler ) ); return true; } return false; } virtual bool removeHandler( TMyEventHandlerPtr eventHandler ) override { std::unique_lock<std::shared_mutex> _coreMutexLock( m_core.coreMutex ); auto it = findEventHandler( eventHandler ); if( it != m_core.handlers.end() ) { for( TMyHandlerRunner* oneHandlerRunner : m_handlerRunners ) { if( it == oneHandlerRunner->currentIt ) { ++oneHandlerRunner->currentIt; oneHandlerRunner->wasRemoving = true; } } m_core.handlers.erase( it ); return true; } return false; } private: // 'm_core.coreMutex' inline TMyEventHandlerIt findEventHandler( const TMyEventHandlerPtr& eventHandler ) const { return std::find_if( m_core.handlers.cbegin(), m_core.handlers.cend(), [ &eventHandler ]( const TMyEventHandlerPtr& oneHandler ) { return ( *oneHandler == *eventHandler ); } ); } EventCore<TParams...> m_core; std::list<TMyHandlerRunner*> m_handlerRunners; }; (, , ) HandlerRunner , . , : currentIt ( ) wasRemoving (, ). HandlerRunner' operator() ; (, ) , EventCore . So , , , , , .
Correction
, lvalue , lvalue -, , rvalue , (, ). :
Holder ( lvalue rvalue ), , «» . type erasing ( ). , Holder' .
Holder' . MethodHolder' .
Is done. FunctorHolder . . - .
template<class TSome> struct ObjectSaver; template<class LValue> struct ObjectSaver<LValue&> { using TObject = LValue&; }; template<class RValue> struct ObjectSaver<RValue&&> { using TObject = RValue; }; Holder ( lvalue rvalue ), , «» . type erasing ( ). , Holder' .
template<class TBase> struct AbstractInnerHolder { virtual ~AbstractInnerHolder() {} virtual inline TBase& get() = 0; inline const TBase& get() const { return const_cast<AbstractInnerHolder<TBase>&>( *this ).get(); } }; template<class TBase, class TInner> struct TInnerHolder : public AbstractInnerHolder<TBase> { using TInnerObject = typename ObjectSaver<TInner>::TObject; TInnerHolder( TInner _inner ) : AbstractInnerHolder<TBase>(), inner( std::forward<TInner>( _inner ) ) { } virtual inline TBase& get() override { return static_cast<TBase&>( inner ); } TInnerObject inner; }; template<class TAssignBase, class TArgInner> AbstractInnerHolder<TAssignBase>& createInnerHolder( TArgInner&& inner ) { using TAssignInner = decltype( inner ); return *new TInnerHolder<TAssignBase, TAssignInner>( std::forward<TArgInner>( inner ) ); } Holder' . MethodHolder' .
template<class TObject, class TResult, class ...TParams> class MethodHolder { . . . using MyType = MethodHolder<TObject, TResult, TParams...>; using TMethod = TResult( TObject::* )( TParams... ); public: ~MethodHolder() { delete &m_innerHolder; } bool operator==( const MyType& other ) const { return ( &m_innerHolder.get() == &other.m_innerHolder.get() && m_method == other.m_method ); } template<class TArgObject> static std::shared_ptr<MyType> create( TArgObject&& object, TMethod method ) { std::shared_ptr<MyType> result( new MyType( std::forward<TArgObject>( object ), method ) ); result->m_me = result; return result; } private: template<class TArgObject> MethodHolder( TArgObject&& object, TMethod method ) : m_innerHolder( createInnerHolder<TObject>( std::forward<TArgObject>( object ) ) ), m_method( method ) { assert( m_method != nullptr ); } AbstractInnerHolder<TObject>& m_innerHolder; TMethod m_method; std::weak_ptr<MyType> m_me; . . . }; namespace { template<class TMethodHolder, class ...TParams> struct IsMethodParamsCompatible { private: template<class TCheckedMethodHolder, class ...TCheckedParams> static constexpr std::true_type exists( decltype( ( std::declval<TCheckedMethodHolder>().m_innerHolder.get().*std::declval<TCheckedMethodHolder>().m_method )( std::declval<TCheckedParams>()... ) )* = nullptr ); . . . }; } // template<class TMethodHolder, class ...TParams> class MethodEventHandler : public AbstractEventHandler<TParams...> { public: virtual void call( TParams... params ) override { static_assert( IsMethodParamsCompatible<TMethodHolder, TParams...>::value, "Event and method arguments are not compatible" ); ( m_methodHolder->m_innerHolder.get().*m_methodHolder->m_method )( params... ); } private: TMethodHolderPtr m_methodHolder; . . . }; template<class TObject, class TResult, class ...TParams> std::shared_ptr<MethodHolder<typename std::decay<TObject>::type, TResult, TParams...>> createMethodEventHandler( TObject&& object, TResult( std::decay<TObject>::type::*method )( TParams... ) ) { return MethodHolder<std::decay<TObject>::type, TResult, TParams...>::create( std::forward<TObject>( object ), method ); } Is done. FunctorHolder . . - .
PS Comparison with Qt Signal / Slots Mechanism
I think I’m not mistaken if I say that Qt is a very common framework for developing in C ++ . Among other things, it also has its own event-handling mechanism , in which there are signals as event analogs and slots as handler analogs. It is implemented using the Meta-Object Compiler , which is part of a more global Meta-Object System , which, in turn, is implemented using the add-in over Q ++ used in Qt .
Features of both implementations:
- the ability to connect signals (events) to methods (member functions), functors and functions;
- () (), ( lvalue , rvalue );
- ( );
- () ( ).
Qt :
- ;
Qt ; «», , « » ; , ; , ; - ;
Qt ( ) ( ); , Qt::UniqueConnection ; , , , Qt ; - , ;
Qt::QueuedConnection Qt::BlockingQueuedConnection ; () ; (); , , ; those. , ; , .
Qt :
- QObject ;
, , QObject , , , ( : Virtual inheritance with QObject is not supported. ); , , ; - template';
, public - QObject ; moc' ; ,,, , ;#include <QObject> class AbstractProperty : public QObject { Q_OBJECT protected: AbstractProperty(); signals: void valueChanged(); }; template<class TSource> class TProperty : public AbstractProperty { public: TProperty( const TSource& value = TSource() ) : AbstractProperty(), m_value( value ) { } const TSource& value() const { return m_value; } void setValue( const TSource& newValue ) { if( newValue != m_value ) { m_value = newValue; emit valueChanged(); } } private: TSource m_value; };
, valueChanged ( , ) , . .cpp-;
;- QMetaObject::Connection ;
, Qt ( ) , ; () , , ; , ; Qt ; - use of additional code generated by moc ;
this is completely subjective, but the solution, where for each class that uses signals and slots (slots are not always) there are several (in the file for each configuration) generated files, it brings some inconvenience; but let's be honest, this is the smallest drawback.
It is important to note that this comparison with Qt is still very subjective and is not aimed at exalting or condemning this framework. It must be remembered that in addition to the signal / slot mechanism, Qt provides a great deal of functionality, both using this mechanism and not depending on it. In any case, it's always up to you to decide what to use and what not.
Source: https://habr.com/ru/post/424593/
All Articles