changeset 95:9d2893d24226

refactoring
author Sebastien Jodogne <s.jodogne@gmail.com>
date Thu, 10 Dec 2015 10:25:20 +0100
parents 499df60ad0e2
children 21b72749bc24 c27540b930e7
files Plugin/Plugin.cpp Plugin/QidoRs.cpp Plugin/QidoRs.h Plugin/StowRs.cpp Plugin/StowRs.h Plugin/Wado.cpp Plugin/Wado.h Plugin/WadoRs.cpp Plugin/WadoRs.h Plugin/WadoRsRetrieveFrames.cpp
diffstat 10 files changed, 210 insertions(+), 220 deletions(-) [+]
line wrap: on
line diff
--- a/Plugin/Plugin.cpp	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/Plugin.cpp	Thu Dec 10 10:25:20 2015 +0100
@@ -42,14 +42,20 @@
 #include <boost/lexical_cast.hpp>
 
 
-template <OrthancPluginRestCallback Callback>
+typedef void (*RestCallback) (OrthancPluginRestOutput* output,
+                              const char* url,
+                              const OrthancPluginHttpRequest* request);
+
+
+template <RestCallback Callback>
 OrthancPluginErrorCode Protect(OrthancPluginRestOutput* output,
                                const char* url,
                                const OrthancPluginHttpRequest* request)
 {
   try
   {
-    return Callback(output, url, request);
+    Callback(output, url, request);
+    return OrthancPluginErrorCode_Success;
   }
   catch (Orthanc::OrthancException& e)
   {
@@ -70,44 +76,48 @@
 
 
 
-OrthancPluginErrorCode SwitchStudies(OrthancPluginRestOutput* output,
-                                     const char* url,
-                                     const OrthancPluginHttpRequest* request)
+void SwitchStudies(OrthancPluginRestOutput* output,
+                   const char* url,
+                   const OrthancPluginHttpRequest* request)
 {
   switch (request->method)
   {
     case OrthancPluginHttpMethod_Get:
       // This is QIDO-RS
-      return SearchForStudies(output, url, request);
+      SearchForStudies(output, url, request);
+      break;
 
     case OrthancPluginHttpMethod_Post:
       // This is STOW-RS
-      return StowCallback(output, url, request);
+      StowCallback(output, url, request);
+      break;
 
     default:
       OrthancPluginSendMethodNotAllowed(context_, output, "GET,POST");
-      return OrthancPluginErrorCode_Success;
+      break;
   }
 }
 
 
-OrthancPluginErrorCode SwitchStudy(OrthancPluginRestOutput* output,
-                                   const char* url,
-                                   const OrthancPluginHttpRequest* request)
+void SwitchStudy(OrthancPluginRestOutput* output,
+                 const char* url,
+                 const OrthancPluginHttpRequest* request)
 {
   switch (request->method)
   {
     case OrthancPluginHttpMethod_Get:
       // This is WADO-RS
-      return RetrieveDicomStudy(output, url, request);
+      RetrieveDicomStudy(output, url, request);
+      break;
 
     case OrthancPluginHttpMethod_Post:
       // This is STOW-RS
-      return StowCallback(output, url, request);
+      StowCallback(output, url, request);
+      break;
 
     default:
       OrthancPluginSendMethodNotAllowed(context_, output, "GET,POST");
-      return OrthancPluginErrorCode_Success;
+      break;
   }
 }
 
@@ -212,7 +222,7 @@
       std::string message = "URI to the WADO API: " + wado;
       OrthancPluginLogWarning(context_, message.c_str());
 
-      OrthancPluginRegisterRestCallback(context_, wado.c_str(), WadoCallback);
+      OrthancPluginRegisterRestCallback(context_, wado.c_str(), Protect<WadoCallback>);
     }
     else
     {
--- a/Plugin/QidoRs.cpp	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/QidoRs.cpp	Thu Dec 10 10:25:20 2015 +0100
@@ -461,72 +461,69 @@
 
 
 
-OrthancPluginErrorCode SearchForStudies(OrthancPluginRestOutput* output,
-                                        const char* url,
-                                        const OrthancPluginHttpRequest* request)
+void SearchForStudies(OrthancPluginRestOutput* output,
+                      const char* url,
+                      const OrthancPluginHttpRequest* request)
 {
   if (request->method != OrthancPluginHttpMethod_Get)
   {
     OrthancPluginSendMethodNotAllowed(context_, output, "GET");
-    return OrthancPluginErrorCode_Success;
   }
-
-  ModuleMatcher matcher(request);
-  ApplyMatcher(output, request, matcher, QueryLevel_Study);
-
-  return OrthancPluginErrorCode_Success;
+  else
+  {
+    ModuleMatcher matcher(request);
+    ApplyMatcher(output, request, matcher, QueryLevel_Study);
+  }
 }
 
 
-OrthancPluginErrorCode SearchForSeries(OrthancPluginRestOutput* output,
-                                       const char* url,
-                                       const OrthancPluginHttpRequest* request)
+void SearchForSeries(OrthancPluginRestOutput* output,
+                     const char* url,
+                     const OrthancPluginHttpRequest* request)
 {
   if (request->method != OrthancPluginHttpMethod_Get)
   {
     OrthancPluginSendMethodNotAllowed(context_, output, "GET");
-    return OrthancPluginErrorCode_Success;
   }
-
-  ModuleMatcher matcher(request);
-
-  if (request->groupsCount == 1)
+  else
   {
-    // The "StudyInstanceUID" is provided by the regular expression
-    matcher.AddFilter(OrthancPlugins::DICOM_TAG_STUDY_INSTANCE_UID, request->groups[0]);
-  }
+    ModuleMatcher matcher(request);
 
-  ApplyMatcher(output, request, matcher, QueryLevel_Series);
+    if (request->groupsCount == 1)
+    {
+      // The "StudyInstanceUID" is provided by the regular expression
+      matcher.AddFilter(OrthancPlugins::DICOM_TAG_STUDY_INSTANCE_UID, request->groups[0]);
+    }
 
-  return OrthancPluginErrorCode_Success;
+    ApplyMatcher(output, request, matcher, QueryLevel_Series);
+  }
 }
 
 
-OrthancPluginErrorCode SearchForInstances(OrthancPluginRestOutput* output,
-                                          const char* url,
-                                          const OrthancPluginHttpRequest* request)
+void SearchForInstances(OrthancPluginRestOutput* output,
+                        const char* url,
+                        const OrthancPluginHttpRequest* request)
 {
   if (request->method != OrthancPluginHttpMethod_Get)
   {
     OrthancPluginSendMethodNotAllowed(context_, output, "GET");
-    return OrthancPluginErrorCode_Success;
   }
-
-  ModuleMatcher matcher(request);
-
-  if (request->groupsCount == 1 || request->groupsCount == 2)
+  else
   {
-    // The "StudyInstanceUID" is provided by the regular expression
-    matcher.AddFilter(OrthancPlugins::DICOM_TAG_STUDY_INSTANCE_UID, request->groups[0]);
-  }
+    ModuleMatcher matcher(request);
 
-  if (request->groupsCount == 2)
-  {
-    // The "SeriesInstanceUID" is provided by the regular expression
-    matcher.AddFilter(OrthancPlugins::DICOM_TAG_SERIES_INSTANCE_UID, request->groups[1]);
+    if (request->groupsCount == 1 || request->groupsCount == 2)
+    {
+      // The "StudyInstanceUID" is provided by the regular expression
+      matcher.AddFilter(OrthancPlugins::DICOM_TAG_STUDY_INSTANCE_UID, request->groups[0]);
+    }
+
+    if (request->groupsCount == 2)
+    {
+      // The "SeriesInstanceUID" is provided by the regular expression
+      matcher.AddFilter(OrthancPlugins::DICOM_TAG_SERIES_INSTANCE_UID, request->groups[1]);
+    }
+
+    ApplyMatcher(output, request, matcher, QueryLevel_Instance);
   }
-
-  ApplyMatcher(output, request, matcher, QueryLevel_Instance);
-
-  return OrthancPluginErrorCode_Success;
 }
--- a/Plugin/QidoRs.h	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/QidoRs.h	Thu Dec 10 10:25:20 2015 +0100
@@ -23,14 +23,14 @@
 #include "Configuration.h"
 
 
-OrthancPluginErrorCode SearchForStudies(OrthancPluginRestOutput* output,
-                                        const char* url,
-                                        const OrthancPluginHttpRequest* request);
+void SearchForStudies(OrthancPluginRestOutput* output,
+                      const char* url,
+                      const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode SearchForSeries(OrthancPluginRestOutput* output,
-                                       const char* url,
-                                       const OrthancPluginHttpRequest* request);
+void SearchForSeries(OrthancPluginRestOutput* output,
+                     const char* url,
+                     const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode SearchForInstances(OrthancPluginRestOutput* output,
-                                          const char* url,
-                                          const OrthancPluginHttpRequest* request);
+void SearchForInstances(OrthancPluginRestOutput* output,
+                        const char* url,
+                        const OrthancPluginHttpRequest* request);
--- a/Plugin/StowRs.cpp	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/StowRs.cpp	Thu Dec 10 10:25:20 2015 +0100
@@ -84,17 +84,16 @@
 
 
 
-OrthancPluginErrorCode StowCallback(OrthancPluginRestOutput* output,
-                                    const char* url,
-                                    const OrthancPluginHttpRequest* request)
+void StowCallback(OrthancPluginRestOutput* output,
+                  const char* url,
+                  const OrthancPluginHttpRequest* request)
 {
   const std::string wadoBase = OrthancPlugins::Configuration::GetBaseUrl(configuration_, request);
 
-
   if (request->method != OrthancPluginHttpMethod_Post)
   {
     OrthancPluginSendMethodNotAllowed(context_, output, "POST");
-    return OrthancPluginErrorCode_Success;
+    return;
   }
 
   std::string expectedStudy;
@@ -120,7 +119,7 @@
   {
     OrthancPluginLogError(context_, "No content type in the HTTP header of a STOW-RS request");
     OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
-    return OrthancPluginErrorCode_Success;    
+    return;
   }
 
   std::string application;
@@ -134,7 +133,7 @@
     std::string s = "Unable to parse the content type of a STOW-RS request (" + application + ")";
     OrthancPluginLogError(context_, s.c_str());
     OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
-    return OrthancPluginErrorCode_Success;
+    return;
   }
 
 
@@ -144,7 +143,7 @@
   {
     OrthancPluginLogError(context_, "The STOW-RS plugin currently only supports application/dicom");
     OrthancPluginSendHttpStatusCode(context_, output, 415 /* Unsupported media type */);
-    return OrthancPluginErrorCode_Success;
+    return;
   }
 
 
@@ -164,7 +163,7 @@
       std::string s = "The STOW-RS request contains a part that is not application/dicom (it is: \"" + items[i].contentType_ + "\")";
       OrthancPluginLogError(context_, s.c_str());
       OrthancPluginSendHttpStatusCode(context_, output, 415 /* Unsupported media type */);
-      return OrthancPluginErrorCode_Success;
+      return;
     }
 
     OrthancPlugins::ParsedDicomFile dicom(items[i]);
@@ -226,6 +225,4 @@
   SetSequenceTag(result, OrthancPlugins::DICOM_TAG_REFERENCED_SOP_SEQUENCE, success);
 
   OrthancPlugins::AnswerDicom(context_, output, wadoBase, *dictionary_, result, isXml, false);
-
-  return OrthancPluginErrorCode_Success;
 }
--- a/Plugin/StowRs.h	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/StowRs.h	Thu Dec 10 10:25:20 2015 +0100
@@ -24,6 +24,6 @@
 
 bool IsXmlExpected(const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode StowCallback(OrthancPluginRestOutput* output,
-                                    const char* url,
-                                    const OrthancPluginHttpRequest* request);
+void StowCallback(OrthancPluginRestOutput* output,
+                  const char* url,
+                  const OrthancPluginHttpRequest* request);
--- a/Plugin/Wado.cpp	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/Wado.cpp	Thu Dec 10 10:25:20 2015 +0100
@@ -151,8 +151,8 @@
 }
 
 
-static OrthancPluginErrorCode AnswerDicom(OrthancPluginRestOutput* output,
-                                          const std::string& instance)
+static void AnswerDicom(OrthancPluginRestOutput* output,
+                        const std::string& instance)
 {
   std::string uri = "/instances/" + instance + "/file";
 
@@ -160,13 +160,12 @@
   if (OrthancPlugins::RestApiGetString(dicom, context_, uri))
   {
     OrthancPluginAnswerBuffer(context_, output, dicom.c_str(), dicom.size(), "application/dicom");
-    return OrthancPluginErrorCode_Success;
   }
   else
   {
     std::string msg = "WADO: Unable to retrieve DICOM file from " + uri;
     OrthancPluginLogError(context_, msg.c_str());
-    return OrthancPluginErrorCode_Plugin;
+    throw Orthanc::OrthancException(Orthanc::ErrorCode_Plugin);
   }
 }
 
@@ -189,28 +188,29 @@
 }
 
 
-static OrthancPluginErrorCode AnswerPngPreview(OrthancPluginRestOutput* output,
-                                               const std::string& instance)
+static void AnswerPngPreview(OrthancPluginRestOutput* output,
+                             const std::string& instance)
 {
   std::string png;
-  if (!RetrievePngPreview(png, instance))
+  if (RetrievePngPreview(png, instance))
   {
-    return OrthancPluginErrorCode_Plugin;
+    OrthancPluginAnswerBuffer(context_, output, png.c_str(), png.size(), "image/png");
   }
-
-  OrthancPluginAnswerBuffer(context_, output, png.c_str(), png.size(), "image/png");
-  return OrthancPluginErrorCode_Success;
+  else
+  {
+    throw Orthanc::OrthancException(Orthanc::ErrorCode_Plugin);
+  }
 }
 
 
-static OrthancPluginErrorCode AnswerJpegPreview(OrthancPluginRestOutput* output,
-                                                const std::string& instance)
+static void AnswerJpegPreview(OrthancPluginRestOutput* output,
+                              const std::string& instance)
 {
   // Retrieve the preview in the PNG format
   std::string png;
   if (!RetrievePngPreview(png, instance))
   {
-    return OrthancPluginErrorCode_Plugin;
+    throw Orthanc::OrthancException(Orthanc::ErrorCode_Plugin);
   }
 
   // Decode the PNG file
@@ -228,47 +228,43 @@
     90 /*quality*/);
 
   OrthancPluginFreeImage(context_, image);
-
-  return OrthancPluginErrorCode_Success;
 }
 
 
-OrthancPluginErrorCode WadoCallback(OrthancPluginRestOutput* output,
-                                    const char* url,
-                                    const OrthancPluginHttpRequest* request)
+void WadoCallback(OrthancPluginRestOutput* output,
+                  const char* url,
+                  const OrthancPluginHttpRequest* request)
 {
   if (request->method != OrthancPluginHttpMethod_Get)
   {
     OrthancPluginSendMethodNotAllowed(context_, output, "GET");
-    return OrthancPluginErrorCode_Plugin;
+    return;
   }
 
   std::string instance;
   std::string contentType = "image/jpg";  // By default, JPEG image will be returned
   if (!LocateInstance(instance, contentType, request))
   {
-    return OrthancPluginErrorCode_UnknownResource;
+    throw Orthanc::OrthancException(Orthanc::ErrorCode_UnknownResource);
   }
 
   if (contentType == "application/dicom")
   {
-    return AnswerDicom(output, instance);
+    AnswerDicom(output, instance);
   }
   else if (contentType == "image/png")
   {
-    return AnswerPngPreview(output, instance);
+    AnswerPngPreview(output, instance);
   }
   else if (contentType == "image/jpeg" ||
            contentType == "image/jpg")
   {
-    return AnswerJpegPreview(output, instance);
+    AnswerJpegPreview(output, instance);
   }
   else
   {
     std::string msg = "WADO: Unsupported content type: \"" + contentType + "\"";
     OrthancPluginLogError(context_, msg.c_str());
-    return OrthancPluginErrorCode_Plugin;
+    throw Orthanc::OrthancException(Orthanc::ErrorCode_BadRequest);
   }
-
-  return OrthancPluginErrorCode_Success;
 }
--- a/Plugin/Wado.h	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/Wado.h	Thu Dec 10 10:25:20 2015 +0100
@@ -22,6 +22,6 @@
 
 #include "Configuration.h"
 
-OrthancPluginErrorCode WadoCallback(OrthancPluginRestOutput* output,
-                                    const char* url,
-                                    const OrthancPluginHttpRequest* request);
+void WadoCallback(OrthancPluginRestOutput* output,
+                  const char* url,
+                  const OrthancPluginHttpRequest* request);
--- a/Plugin/WadoRs.cpp	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/WadoRs.cpp	Thu Dec 10 10:25:20 2015 +0100
@@ -173,20 +173,20 @@
 }
 
 
-static OrthancPluginErrorCode AnswerListOfDicomInstances(OrthancPluginRestOutput* output,
-                                                         const std::string& resource)
+static void AnswerListOfDicomInstances(OrthancPluginRestOutput* output,
+                                       const std::string& resource)
 {
   Json::Value instances;
   if (!OrthancPlugins::RestApiGetJson(instances, context_, resource + "/instances"))
   {
     // Internal error
     OrthancPluginSendHttpStatusCode(context_, output, 400);
-    return OrthancPluginErrorCode_Success;
+    return;
   }
 
   if (OrthancPluginStartMultipartAnswer(context_, output, "related", "application/dicom"))
   {
-    return OrthancPluginErrorCode_Plugin;
+    throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol);
   }
   
   for (Json::Value::ArrayIndex i = 0; i < instances.size(); i++)
@@ -196,11 +196,9 @@
     if (OrthancPlugins::RestApiGetString(dicom, context_, uri) &&
         OrthancPluginSendMultipartItem(context_, output, dicom.c_str(), dicom.size()) != 0)
     {
-      return OrthancPluginErrorCode_Plugin;
+      throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
     }
   }
-
-  return OrthancPluginErrorCode_Success;
 }
 
 
@@ -379,138 +377,132 @@
 }
 
 
-OrthancPluginErrorCode RetrieveDicomStudy(OrthancPluginRestOutput* output,
-                                          const char* url,
-                                          const OrthancPluginHttpRequest* request)
+void RetrieveDicomStudy(OrthancPluginRestOutput* output,
+                        const char* url,
+                        const OrthancPluginHttpRequest* request)
 {
   if (!AcceptMultipartDicom(request))
   {
     OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
-    return OrthancPluginErrorCode_Success;
   }
-
-  std::string uri;
-  if (LocateStudy(output, uri, request))
+  else
   {
-    AnswerListOfDicomInstances(output, uri);
+    std::string uri;
+    if (LocateStudy(output, uri, request))
+    {
+      AnswerListOfDicomInstances(output, uri);
+    }
   }
-
-  return OrthancPluginErrorCode_Success;
 }
 
 
-OrthancPluginErrorCode RetrieveDicomSeries(OrthancPluginRestOutput* output,
-                                           const char* url,
-                                           const OrthancPluginHttpRequest* request)
+void RetrieveDicomSeries(OrthancPluginRestOutput* output,
+                         const char* url,
+                         const OrthancPluginHttpRequest* request)
 {
   if (!AcceptMultipartDicom(request))
   {
     OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
-    return OrthancPluginErrorCode_Success;
   }
-
-  std::string uri;
-  if (LocateSeries(output, uri, request))
+  else
   {
-    AnswerListOfDicomInstances(output, uri);
+    std::string uri;
+    if (LocateSeries(output, uri, request))
+    {
+      AnswerListOfDicomInstances(output, uri);
+    }
   }
-
-  return OrthancPluginErrorCode_Success;
 }
 
 
 
-OrthancPluginErrorCode RetrieveDicomInstance(OrthancPluginRestOutput* output,
-                                             const char* url,
-                                             const OrthancPluginHttpRequest* request)
+void RetrieveDicomInstance(OrthancPluginRestOutput* output,
+                           const char* url,
+                           const OrthancPluginHttpRequest* request)
 {
   if (!AcceptMultipartDicom(request))
   {
     OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
-    return OrthancPluginErrorCode_Success;
   }
-
-  std::string uri;
-  if (LocateInstance(output, uri, request))
+  else
   {
-    if (OrthancPluginStartMultipartAnswer(context_, output, "related", "application/dicom"))
+    std::string uri;
+    if (LocateInstance(output, uri, request))
     {
-      return OrthancPluginErrorCode_Plugin;
-    }
+      if (OrthancPluginStartMultipartAnswer(context_, output, "related", "application/dicom"))
+      {
+        throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol);
+      }
   
-    std::string dicom;
-    if (OrthancPlugins::RestApiGetString(dicom, context_, uri + "/file") &&
-        OrthancPluginSendMultipartItem(context_, output, dicom.c_str(), dicom.size()) != 0)
-    {
-      return OrthancPluginErrorCode_Plugin;
+      std::string dicom;
+      if (OrthancPlugins::RestApiGetString(dicom, context_, uri + "/file") &&
+          OrthancPluginSendMultipartItem(context_, output, dicom.c_str(), dicom.size()) != 0)
+      {
+        throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol);
+      }
     }
   }
-
-  return OrthancPluginErrorCode_Success;
 }
 
 
 
-OrthancPluginErrorCode RetrieveStudyMetadata(OrthancPluginRestOutput* output,
-                                             const char* url,
-                                             const OrthancPluginHttpRequest* request)
+void RetrieveStudyMetadata(OrthancPluginRestOutput* output,
+                           const char* url,
+                           const OrthancPluginHttpRequest* request)
 {
   bool isXml;
   if (!AcceptMetadata(request, isXml))
   {
     OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
-    return OrthancPluginErrorCode_Success;
   }
-
-  std::string uri;
-  if (LocateStudy(output, uri, request))
+  else
   {
-    AnswerMetadata(output, request, uri, false, isXml);
+    std::string uri;
+    if (LocateStudy(output, uri, request))
+    {
+      AnswerMetadata(output, request, uri, false, isXml);
+    }
   }
-
-  return OrthancPluginErrorCode_Success;
 }
 
 
-OrthancPluginErrorCode RetrieveSeriesMetadata(OrthancPluginRestOutput* output,
-                                              const char* url,
-                                              const OrthancPluginHttpRequest* request)
+void RetrieveSeriesMetadata(OrthancPluginRestOutput* output,
+                            const char* url,
+                            const OrthancPluginHttpRequest* request)
 {
   bool isXml;
   if (!AcceptMetadata(request, isXml))
   {
     OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
-    return OrthancPluginErrorCode_Success;
   }
-
-  std::string uri;
-  if (LocateSeries(output, uri, request))
+  else
   {
-    AnswerMetadata(output, request, uri, false, isXml);
+    std::string uri;
+    if (LocateSeries(output, uri, request))
+    {
+      AnswerMetadata(output, request, uri, false, isXml);
+    }
   }
-
-  return OrthancPluginErrorCode_Success;
 }
 
 
-OrthancPluginErrorCode RetrieveInstanceMetadata(OrthancPluginRestOutput* output,
-                                                const char* url,
-                                                const OrthancPluginHttpRequest* request)
+void RetrieveInstanceMetadata(OrthancPluginRestOutput* output,
+                              const char* url,
+                              const OrthancPluginHttpRequest* request)
 {
   bool isXml;
   if (!AcceptMetadata(request, isXml))
   {
     OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
-    return OrthancPluginErrorCode_Success;
   }
-
-  std::string uri;
-  if (LocateInstance(output, uri, request))
+  else
   {
-    AnswerMetadata(output, request, uri, true, isXml);
+    std::string uri;
+    if (LocateInstance(output, uri, request))
+    {
+      AnswerMetadata(output, request, uri, true, isXml);
+    }
   }
-
-  return OrthancPluginErrorCode_Success;
 }
 
 
@@ -585,14 +577,15 @@
   return false;
 }
 
-OrthancPluginErrorCode RetrieveBulkData(OrthancPluginRestOutput* output,
-                                        const char* url,
-                                        const OrthancPluginHttpRequest* request)
+
+void RetrieveBulkData(OrthancPluginRestOutput* output,
+                      const char* url,
+                      const OrthancPluginHttpRequest* request)
 {
   if (!AcceptBulkData(request))
   {
     OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
-    return OrthancPluginErrorCode_Success;
+    return;
   }
 
   std::string uri, content;
@@ -611,7 +604,7 @@
       if (OrthancPluginStartMultipartAnswer(context_, output, "related", "application/octet-stream") != 0 ||
           OrthancPluginSendMultipartItem(context_, output, result.c_str(), result.size()) != 0)
       {
-        return OrthancPluginErrorCode_Plugin;
+        throw Orthanc::OrthancException(Orthanc::ErrorCode_Plugin);
       }
     }
     else
@@ -619,6 +612,4 @@
       OrthancPluginSendHttpStatusCode(context_, output, 400 /* Bad request */);
     }      
   }
-
-  return OrthancPluginErrorCode_Success;
 }
--- a/Plugin/WadoRs.h	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/WadoRs.h	Thu Dec 10 10:25:20 2015 +0100
@@ -27,34 +27,34 @@
                     std::string& uri,
                     const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode RetrieveDicomStudy(OrthancPluginRestOutput* output,
-                                          const char* url,
-                                          const OrthancPluginHttpRequest* request);
+void RetrieveDicomStudy(OrthancPluginRestOutput* output,
+                        const char* url,
+                        const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode RetrieveDicomSeries(OrthancPluginRestOutput* output,
-                                           const char* url,
-                                           const OrthancPluginHttpRequest* request);
+void RetrieveDicomSeries(OrthancPluginRestOutput* output,
+                         const char* url,
+                         const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode RetrieveDicomInstance(OrthancPluginRestOutput* output,
-                                             const char* url,
-                                             const OrthancPluginHttpRequest* request);
+void RetrieveDicomInstance(OrthancPluginRestOutput* output,
+                           const char* url,
+                           const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode RetrieveStudyMetadata(OrthancPluginRestOutput* output,
-                                             const char* url,
-                                             const OrthancPluginHttpRequest* request);
+void RetrieveStudyMetadata(OrthancPluginRestOutput* output,
+                           const char* url,
+                           const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode RetrieveSeriesMetadata(OrthancPluginRestOutput* output,
-                                              const char* url,
-                                              const OrthancPluginHttpRequest* request);
+void RetrieveSeriesMetadata(OrthancPluginRestOutput* output,
+                            const char* url,
+                            const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode RetrieveInstanceMetadata(OrthancPluginRestOutput* output,
-                                                const char* url,
-                                                const OrthancPluginHttpRequest* request);
+void RetrieveInstanceMetadata(OrthancPluginRestOutput* output,
+                              const char* url,
+                              const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode RetrieveBulkData(OrthancPluginRestOutput* output,
-                                        const char* url,
-                                        const OrthancPluginHttpRequest* request);
+void RetrieveBulkData(OrthancPluginRestOutput* output,
+                      const char* url,
+                      const OrthancPluginHttpRequest* request);
 
-OrthancPluginErrorCode RetrieveFrames(OrthancPluginRestOutput* output,
-                                      const char* url,
-                                      const OrthancPluginHttpRequest* request);
+void RetrieveFrames(OrthancPluginRestOutput* output,
+                    const char* url,
+                    const OrthancPluginHttpRequest* request);
--- a/Plugin/WadoRsRetrieveFrames.cpp	Thu Dec 10 09:57:02 2015 +0100
+++ b/Plugin/WadoRsRetrieveFrames.cpp	Thu Dec 10 10:25:20 2015 +0100
@@ -25,6 +25,7 @@
 #include "Dicom.h"
 #include "Plugin.h"
 
+#include <memory>
 #include <list>
 #include <gdcmImageReader.h>
 #include <gdcmImageWriter.h>
@@ -292,7 +293,7 @@
 {
   if (!dicom.GetDataSet().FindDataElement(OrthancPlugins::DICOM_TAG_PIXEL_DATA))
   {
-    return OrthancPluginErrorCode_IncompatibleImageFormat;
+    throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat);
   }
 
   const gdcm::DataElement& pixelData = dicom.GetDataSet().GetDataElement(OrthancPlugins::DICOM_TAG_PIXEL_DATA);
@@ -397,9 +398,9 @@
 
 
 
-OrthancPluginErrorCode RetrieveFrames(OrthancPluginRestOutput* output,
-                                      const char* url,
-                                      const OrthancPluginHttpRequest* request)
+void RetrieveFrames(OrthancPluginRestOutput* output,
+                    const char* url,
+                    const OrthancPluginHttpRequest* request)
 {
   gdcm::TransferSyntax targetSyntax(ParseTransferSyntax(request));
 
@@ -495,6 +496,4 @@
       AnswerFrames(output, request, transcoded, targetSyntax, frames);
     }
   }    
-
-  return OrthancPluginErrorCode_Success;
 }