Mercurial > hg > orthanc-stone
view Framework/Messages/ICallable.h @ 973:38409549db43 toa2019082903
Log with addresses + added fingerprint mechanism to avoid calling zombie objects
where:
- a message is sent with a receiver
- the receiver dies
- another receiver with the SAME address is created
- the message reply is executed --> execution on the wrong object!
(since their "identity" is their address. The fix is to identify them with
an UUID stored at creation time)
author | Benjamin Golinvaux <bgo@osimis.io> |
---|---|
date | Thu, 29 Aug 2019 18:07:55 +0200 |
parents | f0008c55e5f7 |
children | e75fd08d6c75 |
line wrap: on
line source
/** * Stone of Orthanc * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics * Department, University Hospital of Liege, Belgium * Copyright (C) 2017-2019 Osimis S.A., Belgium * * This program is free software: you can redistribute it and/or * modify it under the terms of the GNU Affero General Public License * as published by the Free Software Foundation, either version 3 of * the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ #pragma once #include "IMessage.h" #include <Core/Logging.h> #include <boost/noncopyable.hpp> #include <string> namespace OrthancStone { class IObserver; // This is referencing an object and member function that can be notified // by an IObservable. The object must derive from IO // The member functions must be of type "void Function(const IMessage& message)" or reference a derived class of IMessage class ICallable : public boost::noncopyable { public: virtual ~ICallable() { } virtual void Apply(const IMessage& message) = 0; virtual const MessageIdentifier& GetMessageIdentifier() = 0; virtual IObserver* GetObserver() const = 0; }; template <typename TMessage> class MessageHandler: public ICallable { }; template <typename TObserver, typename TMessage> class Callable : public MessageHandler<TMessage> { private: typedef void (TObserver::* MemberFunction) (const TMessage&); TObserver& observer_; MemberFunction function_; std::string observerFingerprint_; public: Callable(TObserver& observer, MemberFunction function) : observer_(observer), observerFingerprint_(observer.GetFingerprint()), function_(function) { } void ApplyInternal(const TMessage& message) { #if 0 (observer_.*function_) (message); #else if (observerFingerprint_ != observer_.GetFingerprint()) { LOG(WARNING) << "The observer at address " << std::hex << &observer_ << std::dec << ") has a different fingerprint than the one recorded at callback registration time. Callback will NOT be sent!"; LOG(WARNING) << " recorded fingerprint = " << observerFingerprint_ << " current fingerprint = " << observer_.GetFingerprint(); } else { (observer_.*function_) (message); } #endif } virtual void Apply(const IMessage& message) { ApplyInternal(dynamic_cast<const TMessage&>(message)); } virtual const MessageIdentifier& GetMessageIdentifier() { return TMessage::GetStaticIdentifier(); } virtual IObserver* GetObserver() const { return &observer_; } }; #if 0 /* __cplusplus >= 201103L*/ #include <functional> template <typename TMessage> class LambdaCallable : public MessageHandler<TMessage> { private: IObserver& observer_; std::function<void (const TMessage&)> lambda_; public: LambdaCallable(IObserver& observer, std::function<void (const TMessage&)> lambdaFunction) : observer_(observer), lambda_(lambdaFunction) { } virtual void Apply(const IMessage& message) { lambda_(dynamic_cast<const TMessage&>(message)); } virtual IObserver* GetObserver() const { return &observer_; } }; #endif //__cplusplus >= 201103L }