orthanc-stone: Samples/Sdl/Loader.cpp comparison

comparison Samples/Sdl/Loader.cpp @ 623:42dadae61fa9

renamed IObservable::EmitMessage() as BroadcastMessage()

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 07 May 2019 14:16:08 +0200
parents	8a3a25f2d42c
children	2eeb5857eb43

comparison

equal deleted inserted replaced

-:8a3a25f2d42c
+:42dadae61fa9
 #include "../../Framework/StoneInitialization.h"
 #include "../../Framework/Messages/IMessage.h"
 #include "../../Framework/Messages/MessageBroker.h"
 #include "../../Framework/Messages/ICallable.h"
 #include "../../Framework/Messages/IObservable.h"
+#include "../../Framework/Volumes/ImageBuffer3D.h"
 // From Orthanc framework
 #include <Core/IDynamicObject.h>
 #include <Core/Images/Image.h>
 #include <Core/Images/ImageProcessing.h>
 public:
 virtual ~IMessageEmitter()
 {
 }
-virtual void EmitMessage(const OrthancStone::IMessage& message) = 0;
+virtual void EmitMessage(const OrthancStone::IObserver& observer,
+const OrthancStone::IMessage& message) = 0;
 };
 class IOracle : public boost::noncopyable
 {
 public:
 virtual ~IOracle()
 {
 }
-virtual void Schedule(IOracleCommand* command) = 0;  // Takes ownership
+virtual void Schedule(const OrthancStone::IObserver& receiver,
+IOracleCommand* command) = 0;  // Takes ownership
 };
 {
 private:
 class Item : public Orthanc::IDynamicObject
 {
 private:
-std::auto_ptr<IOracleCommand>  command_;
+const OrthancStone::IObserver&  receiver_;
+std::auto_ptr<IOracleCommand>   command_;
 public:
-Item(IOracleCommand* command) :
+Item(const OrthancStone::IObserver& receiver,
-command_(command)
+IOracleCommand* command) :
+receiver_(receiver),
+command_(command)
 {
 if (command == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 }
-const IOracleCommand& GetCommand()
+const OrthancStone::IObserver& GetReceiver() const
+{
+return receiver_;
+}
+const IOracleCommand& GetCommand() const
 {
 assert(command_.get() != NULL);
 return *command_;
 }
 };
 State                          state_;
 boost::mutex                   mutex_;
 std::vector<boost::thread*>    workers_;
-void Execute(const OrthancApiOracleCommand& command)
+void Execute(const OrthancStone::IObserver& receiver,
+const OrthancApiOracleCommand& command)
 {
 Orthanc::HttpClient  client(orthanc_, command.GetUri());
 client.SetMethod(command.GetMethod());
 client.SetBody(command.GetBody());
 client.SetTimeout(command.GetTimeout());
 }
 if (success)
 {
 OrthancApiOracleCommand::SuccessMessage message(command, answerHeaders, answer);
-emitter_.EmitMessage(message);
+emitter_.EmitMessage(receiver, message);
 }
 else
 {
 OrthancApiOracleCommand::FailureMessage message(command, client.GetLastStatus());
-emitter_.EmitMessage(message);
+emitter_.EmitMessage(receiver, message);
 }
 }
 void Step()
 {
-std::auto_ptr<Orthanc::IDynamicObject>  item(queue_.Dequeue(100));
+std::auto_ptr<Orthanc::IDynamicObject>  object(queue_.Dequeue(100));
-if (item.get() != NULL)
+if (object.get() != NULL)
 {
-const IOracleCommand& command = dynamic_cast<Item*>(item.get())->GetCommand();
+const Item& item = dynamic_cast<Item&>(*object);
-switch (command.GetType())
+switch (item.GetCommand().GetType())
 {
 case IOracleCommand::Type_OrthancApi:
-Execute(dynamic_cast<const OrthancApiOracleCommand&>(command));
+Execute(item.GetReceiver(),
+dynamic_cast<const OrthancApiOracleCommand&>(item.GetCommand()));
 break;
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
 void Stop()
 {
 StopInternal();
 }
-virtual void Schedule(IOracleCommand* command)
+virtual void Schedule(const OrthancStone::IObserver& receiver,
-{
+IOracleCommand* command)
-queue_.Enqueue(new Item(command));
+{
+queue_.Enqueue(new Item(receiver, command));
 }
 };
 oracleObservable_(broker_)
 {
 }
-virtual void EmitMessage(const OrthancStone::IMessage& message)
+virtual void EmitMessage(const OrthancStone::IObserver& observer,
+const OrthancStone::IMessage& message)
 {
 boost::unique_lock<boost::shared_mutex>  lock(mutex_);
-oracleObservable_.EmitMessage(message);
+oracleObservable_.EmitMessage(observer, message);
 }
 class ReaderLock : public boost::noncopyable
 {
 {
 return that_.oracleObservable_;
 }
 };
 };
+class AxialVolumeOrthancLoader : public OrthancStone::IObserver
+{
+private:
+void Handle(const Refactoring::OrthancApiOracleCommand::SuccessMessage& message)
+{
+Json::Value v;
+message.GetJsonBody(v);
+printf("ICI [%s]\n", v.toStyledString().c_str());
+}
+std::auto_ptr<OrthancStone::ImageBuffer3D>  image_;
+public:
+AxialVolumeOrthancLoader(OrthancStone::IObservable& oracle) :
+IObserver(oracle.GetBroker())
+{
+oracle.RegisterObserverCallback(
+new OrthancStone::Callable<AxialVolumeOrthancLoader, OrthancApiOracleCommand::SuccessMessage>
+(*this, &AxialVolumeOrthancLoader::Handle));
+}
+};
 }
 class Toto : public OrthancStone::IObserver
 public:
 Toto(OrthancStone::IObservable& oracle) :
 IObserver(oracle.GetBroker())
 {
-oracle.RegisterObserverCallback(new OrthancStone::Callable<Toto, Refactoring::OrthancApiOracleCommand::SuccessMessage>(*this, &Toto::Handle));
+oracle.RegisterObserverCallback
-oracle.RegisterObserverCallback(new OrthancStone::Callable<Toto, Refactoring::OrthancApiOracleCommand::FailureMessage>(*this, &Toto::Handle));
+(new OrthancStone::Callable
+<Toto, Refactoring::OrthancApiOracleCommand::SuccessMessage>(*this, &Toto::Handle));
 }
 };
 void Run(Refactoring::NativeApplicationContext& context)
 std::auto_ptr<Toto> toto;
 {
 Refactoring::NativeApplicationContext::WriterLock lock(context);
 toto.reset(new Toto(lock.GetOracleObservable()));
+}
+std::auto_ptr<Refactoring::AxialVolumeOrthancLoader> loader;
+{
+Refactoring::NativeApplicationContext::WriterLock lock(context);
+loader.reset(new Refactoring::AxialVolumeOrthancLoader(lock.GetOracleObservable()));
 }
 Refactoring::NativeOracle oracle(context);
 {
 std::auto_ptr<Refactoring::OrthancApiOracleCommand>  command(new Refactoring::OrthancApiOracleCommand);
 command->SetMethod(Orthanc::HttpMethod_Post);
 command->SetUri("/tools/find");
 command->SetBody(v);
-oracle.Schedule(command.release());
+oracle.Schedule(*toto, command.release());
 }
 boost::this_thread::sleep(boost::posix_time::seconds(1));
 oracle.Stop();

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 623:42dadae61fa9