orthanc-stone: Applications/Platforms/WebAssembly/WebAssemblyOracle.cpp comparison

comparison Applications/Platforms/WebAssembly/WebAssemblyOracle.cpp @ 1723:81273beabc9f

refactoring: WebAssemblyOracle::ProcessFetchResult()

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 01 Dec 2020 16:54:01 +0100
parents	1393e3393a0b
children	9ac2a65d4172

comparison

equal deleted inserted replaced

-:802cb1272f3a
+:81273beabc9f
 }
 };
 /**
 This object is created on the heap for every http request.
 It is deleted in the success (or error) callbacks.
 This object references the receiver of the request. Since this is a raw
 reference, we need additional checks to make sure we send the response to
 the same object, for the object can be deleted and a new one recreated at the
 same address (it often happens in the [single-threaded] browser context).
 */
 class WebAssemblyOracle::FetchContext : public boost::noncopyable
 {
 private:
 WebAssemblyOracle&             oracle_;
 const std::string& GetExpectedContentType() const
 {
 return expectedContentType_;
 }
-IMessageEmitter& GetEmitter() const
+void EmitException(const Orthanc::OrthancException& exception)
 {
-return oracle_;
+assert(command_.get() != NULL);
-}
+OracleCommandExceptionMessage message(*command_, exception);
-boost::weak_ptr<IObserver> GetReceiver() const
-{
-return receiver_;
-}
-void EmitMessage(const IMessage& message)
-{
-if (Orthanc::Logging::IsTraceLevelEnabled())
-{
-// Calling "receiver_.lock()" is expensive, hence the quick check if TRACE is enabled
-LOG(TRACE) << "WebAssemblyOracle::FetchContext::EmitMessage receiver_ = "
-<< std::hex << receiver_.lock().get() << std::dec;
-}
 oracle_.EmitMessage(receiver_, message);
 }
-IOracleCommand& GetCommand() const
+void ProcessFetchResult(const std::string& answer,
-{
+const HttpHeaders& headers)
-return *command_;
+{
-}
+assert(command_.get() != NULL);
+oracle_.ProcessFetchResult(receiver_, answer, headers, *command_);
-template <typename T>
+}
-const T& GetTypedCommand() const
-{
-return dynamic_cast<T&>(*command_);
-}
-#if ORTHANC_ENABLE_DCMTK == 1
-void StoreInCache(const std::string& sopInstanceUid,
-std::unique_ptr<Orthanc::ParsedDicomFile>& dicom,
-size_t fileSize)
-{
-if (oracle_.dicomCache_.get())
-{
-// Store it into the cache for future use
-oracle_.dicomCache_->Acquire(BUCKET_SOP, sopInstanceUid,
-dicom.release(), fileSize, true);
-}
-}
-#endif
 static void SuccessCallback(emscripten_fetch_t *fetch)
 {
 /**
 * Firstly, make a local copy of the fetched information, and
 * free data associated with the fetch.
 **/
 if (fetch->userData == NULL)
 {
-LOG(ERROR) << "WebAssemblyOracle::FetchContext::SuccessCallback fetch->userData is NULL!!!!!!!";
+LOG(ERROR) << "WebAssemblyOracle::FetchContext::SuccessCallback fetch->userData is NULL!";
 return;
 }
 std::unique_ptr<FetchContext> context(reinterpret_cast<FetchContext*>(fetch->userData));
 LOG(ERROR) << "WebAssemblyOracle::FetchContext::SuccessCallback: (context.get() == NULL)";
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 else
 {
-switch (context->GetCommand().GetType())
+context->ProcessFetchResult(answer, headers);
-{
-case IOracleCommand::Type_Http:
-{
-HttpCommand::SuccessMessage message(context->GetTypedCommand<HttpCommand>(), headers, answer);
-context->EmitMessage(message);
-break;
-}
-case IOracleCommand::Type_OrthancRestApi:
-{
-LOG(TRACE) << "WebAssemblyOracle::FetchContext::SuccessCallback. About to call context->EmitMessage(message);";
-OrthancRestApiCommand::SuccessMessage message
-(context->GetTypedCommand<OrthancRestApiCommand>(), headers, answer);
-context->EmitMessage(message);
-break;
-}
-case IOracleCommand::Type_GetOrthancImage:
-{
-context->GetTypedCommand<GetOrthancImageCommand>().ProcessHttpAnswer
-(context->GetReceiver(), context->GetEmitter(), answer, headers);
-break;
-}
-case IOracleCommand::Type_GetOrthancWebViewerJpeg:
-{
-context->GetTypedCommand<GetOrthancWebViewerJpegCommand>().ProcessHttpAnswer
-(context->GetReceiver(), context->GetEmitter(), answer);
-break;
-}
-case IOracleCommand::Type_ParseDicomFromWado:
-{
-#if ORTHANC_ENABLE_DCMTK == 1
-const ParseDicomFromWadoCommand& command =
-context->GetTypedCommand<ParseDicomFromWadoCommand>();
-size_t fileSize;
-std::unique_ptr<Orthanc::ParsedDicomFile> dicom
-(ParseDicomSuccessMessage::ParseWadoAnswer(fileSize, answer, headers));
-{
-ParseDicomSuccessMessage message(command, command.GetSource(), *dicom, fileSize, true);
-context->EmitMessage(message);
-}
-context->StoreInCache(command.GetSopInstanceUid(), dicom, fileSize);
-#else
-throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
-#endif
-break;
-}
-default:
-LOG(ERROR) << "Command type not implemented by the WebAssembly Oracle (in SuccessCallback): "
-<< context->GetCommand().GetType();
-throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
-}
 }
 }
 catch (Orthanc::OrthancException& e)
 {
 LOG(INFO) << "Error while processing a fetch answer in the oracle: " << e.What();
+context->EmitException(e);
-{
-OracleCommandExceptionMessage message(context->GetCommand(), e);
-context->EmitMessage(message);
-}
 }
 }
 static void FailureCallback(emscripten_fetch_t *fetch)
 {
 << " | totalBytes = " << fetch->totalBytes
 << " | readyState = " << fetch->readyState;
 }
 #endif
-{
+context->EmitException(Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol));
-OracleCommandExceptionMessage message
-(context->GetCommand(), Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol));
-context->EmitMessage(message);
-}
 /**
 * TODO - The following code leads to an infinite recursion, at
 * least with Firefox running on incognito mode => WHY?
 **/
 void SetMethod(Orthanc::HttpMethod method)
 {
 method_ = method;
 }
+Orthanc::HttpMethod GetMethod() const
+{
+return method_;
+}
 void SetUrl(const std::string& url)
 {
 url_ = url;
 }
+const std::string& GetUrl() const
+{
+return url_;
+}
 void SetBody(std::string& body /* will be swapped */)
 {
 body_.swap(body);
 }
 {
 headers_[it->first] = it->second;
 }
 }
+const HttpHeaders& GetHttpHeaders() const
+{
+return headers_;
+}
 void SetTimeout(unsigned int timeout)
 {
 timeout_ = timeout;
+}
+unsigned int GetTimeout() const
+{
+return timeout_;
 }
 void SetCredentials(const std::string& username,
 const std::string& password)
 {
 }
 }
 };
+void WebAssemblyOracle::ProcessFetchResult(boost::weak_ptr<IObserver>& receiver,
+const std::string& answer,
+const HttpHeaders& headers,
+const IOracleCommand& command)
+{
+switch (command.GetType())
+{
+case IOracleCommand::Type_Http:
+{
+HttpCommand::SuccessMessage message(dynamic_cast<const HttpCommand&>(command), headers, answer);
+EmitMessage(receiver, message);
+break;
+}
+case IOracleCommand::Type_OrthancRestApi:
+{
+LOG(TRACE) << "WebAssemblyOracle::FetchContext::SuccessCallback. About to call EmitMessage(message);";
+OrthancRestApiCommand::SuccessMessage message
+(dynamic_cast<const OrthancRestApiCommand&>(command), headers, answer);
+EmitMessage(receiver, message);
+break;
+}
+case IOracleCommand::Type_GetOrthancImage:
+{
+dynamic_cast<const GetOrthancImageCommand&>(command).ProcessHttpAnswer(receiver, *this, answer, headers);
+break;
+}
+case IOracleCommand::Type_GetOrthancWebViewerJpeg:
+{
+dynamic_cast<const GetOrthancWebViewerJpegCommand&>(command).ProcessHttpAnswer(receiver, *this, answer);
+break;
+}
+case IOracleCommand::Type_ParseDicomFromWado:
+{
+#if ORTHANC_ENABLE_DCMTK == 1
+const ParseDicomFromWadoCommand& c = dynamic_cast<const ParseDicomFromWadoCommand&>(command);
+size_t fileSize;
+std::unique_ptr<Orthanc::ParsedDicomFile> dicom
+(ParseDicomSuccessMessage::ParseWadoAnswer(fileSize, answer, headers));
+{
+ParseDicomSuccessMessage message(c, c.GetSource(), *dicom, fileSize, true);
+EmitMessage(receiver, message);
+}
+if (dicomCache_.get())
+{
+// Store it into the cache for future use
+dicomCache_->Acquire(BUCKET_SOP, c.GetSopInstanceUid(), dicom.release(), fileSize, true);
+}
+#else
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+#endif
+break;
+}
+default:
+LOG(ERROR) << "Command type not implemented by the WebAssembly Oracle (in SuccessCallback): "
+<< command.GetType();
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
+}
+}
 void WebAssemblyOracle::SetOrthancUrl(FetchCommand& command,
 const std::string& uri) const
 {
 if (isLocalOrthanc_)
 {
 SetOrthancUrl(fetch, command->GetUri());
 fetch.AddHttpHeaders(command->GetHttpHeaders());
 fetch.SetTimeout(command->GetTimeout());
 if (command->GetMethod() == Orthanc::HttpMethod_Post ||
 command->GetMethod() == Orthanc::HttpMethod_Put)
 {
 std::string body;
 command->SwapBody(body);
 fetch.SetBody(body);
 }
 case IOracleCommand::Type_ParseDicomFromWado:
 #if ORTHANC_ENABLE_DCMTK == 1
 Execute(receiver, dynamic_cast<ParseDicomFromWadoCommand*>(protection.release()));
 #else
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented,
 "DCMTK must be enabled to parse DICOM files");
 #endif
 break;
 default:
 LOG(ERROR) << "Command type not implemented by the WebAssembly Oracle (in Schedule): "

Mercurial > hg > orthanc-stone

comparison Applications/Platforms/WebAssembly/WebAssemblyOracle.cpp @ 1723:81273beabc9f