Mercurial > hg > orthanc-stone

comparison Framework/Messages/ICallable.h @ 1059:e713f1a99861 broker

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
replacing MessageBroker by weak_ptr
author Sebastien Jodogne <s.jodogne@gmail.com>
date Fri, 11 Oct 2019 17:08:34 +0200
parents 3f6e5a38c88f
children af4b9cba905f
comparison
equal deleted inserted replaced
1058:a36c47487a70 1059:e713f1a99861
20 20
21 21
22 #pragma once 22 #pragma once
23 23
24 #include "IMessage.h" 24 #include "IMessage.h"
25 #include "IObserver.h"
25 26
26 #include <Core/Logging.h> 27 #include <Core/Logging.h>
27 28
28 #include <boost/noncopyable.hpp> 29 #include <boost/noncopyable.hpp>
30 #include <boost/weak_ptr.hpp>
29 31
30 #include <string> 32 #include <string>
31 33
32 namespace OrthancStone { 34 namespace OrthancStone
33 35 {
34 class IObserver;
35
36 // This is referencing an object and member function that can be notified 36 // This is referencing an object and member function that can be notified
37 // by an IObservable. The object must derive from IO 37 // by an IObservable. The object must derive from IO
38 // The member functions must be of type "void Function(const IMessage& message)" or reference a derived class of IMessage 38 // The member functions must be of type "void Function(const IMessage& message)" or reference a derived class of IMessage
39 class ICallable : public boost::noncopyable 39 class ICallable : public boost::noncopyable
40 { 40 {
45 45
46 virtual void Apply(const IMessage& message) = 0; 46 virtual void Apply(const IMessage& message) = 0;
47 47
48 virtual const MessageIdentifier& GetMessageIdentifier() = 0; 48 virtual const MessageIdentifier& GetMessageIdentifier() = 0;
49 49
50 virtual IObserver* GetObserver() const = 0; 50 // TODO - Is this needed?
51 virtual boost::weak_ptr<IObserver> GetObserver() const = 0;
51 }; 52 };
52 53
54
55 // TODO - Remove this class
53 template <typename TMessage> 56 template <typename TMessage>
54 class MessageHandler: public ICallable 57 class MessageHandler : public ICallable
55 { 58 {
56 }; 59 };
57 60
58 61
59 template <typename TObserver, 62 template <typename TObserver,
61 class Callable : public MessageHandler<TMessage> 64 class Callable : public MessageHandler<TMessage>
62 { 65 {
63 private: 66 private:
64 typedef void (TObserver::* MemberFunction) (const TMessage&); 67 typedef void (TObserver::* MemberFunction) (const TMessage&);
65 68
66 TObserver& observer_; 69 boost::weak_ptr<IObserver> observer_;
67 MemberFunction function_; 70 MemberFunction function_;
68 std::string observerFingerprint_;
69 71
70 public: 72 public:
71 Callable(TObserver& observer, 73 Callable(boost::shared_ptr<TObserver> observer,
72 MemberFunction function) : 74 MemberFunction function) :
73 observer_(observer), 75 observer_(observer),
74 function_(function), 76 function_(function)
75 observerFingerprint_(observer.GetFingerprint())
76 { 77 {
77 }
78
79 void ApplyInternal(const TMessage& message)
80 {
81 std::string currentFingerprint(observer_.GetFingerprint());
82 if (observerFingerprint_ != currentFingerprint)
83 {
84 LOG(TRACE) << "The observer at address " <<
85 std::hex << &observer_ << std::dec <<
86 ") has a different fingerprint than the one recorded at callback " <<
87 "registration time. This means that it is not the same object as " <<
88 "the one recorded, even though their addresses are the same. " <<
89 "Callback will NOT be sent!";
90 LOG(TRACE) << " recorded fingerprint = " << observerFingerprint_ <<
91 " current fingerprint = " << currentFingerprint;
92 }
93 else
94 {
95 LOG(TRACE) << "The recorded fingerprint is " << observerFingerprint_
96 << " and the current fingerprint is " << currentFingerprint
97 << " -- callable will be called.";
98 (observer_.*function_) (message);
99 }
100 } 78 }
101 79
102 virtual void Apply(const IMessage& message) 80 virtual void Apply(const IMessage& message)
103 { 81 {
104 ApplyInternal(dynamic_cast<const TMessage&>(message)); 82 boost::shared_ptr<IObserver> lock(observer_);
83 if (lock)
84 {
85 TObserver& observer = dynamic_cast<TObserver&>(*lock);
86 const TMessage& typedMessage = dynamic_cast<const TMessage&>(message);
87 (observer.*function_) (typedMessage);
88 }
105 } 89 }
106 90
107 virtual const MessageIdentifier& GetMessageIdentifier() 91 virtual const MessageIdentifier& GetMessageIdentifier()
108 { 92 {
109 return TMessage::GetStaticIdentifier(); 93 return TMessage::GetStaticIdentifier();
110 } 94 }
111 95
112 virtual IObserver* GetObserver() const 96 virtual boost::weak_ptr<IObserver> GetObserver() const
113 { 97 {
114 return &observer_; 98 return observer_;
115 } 99 }
116 }; 100 };
117 101
118 #if 0 /* __cplusplus >= 201103L*/ 102 #if 0 /* __cplusplus >= 201103L*/
119 103