orthanc-stone: Framework/Oracle/GenericOracleRunner.cpp comparison

comparison Framework/Oracle/GenericOracleRunner.cpp @ 1136:42581a6182c8 broker

reactivation of the cache of parsed DICOM files

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 06 Nov 2019 17:54:14 +0100
parents	a0a33e5ea5bb
children	cc029987b6dc

comparison

equal deleted inserted replaced

-:a0a33e5ea5bb
+:42581a6182c8
 emitter.EmitMessage(receiver, message);
 }
 #if ORTHANC_ENABLE_DCMTK == 1
-static void RunInternal(boost::weak_ptr<IObserver> receiver,
+namespace
-IMessageEmitter& emitter,
+{
-const std::string& root,
+class IDicomHandler : public boost::noncopyable
-const ParseDicomFileCommand& command)
+{
-{
+public:
-std::string path = GetPath(root, command.GetPath());
+virtual ~IDicomHandler()
+{
-if (!Orthanc::SystemToolbox::IsRegularFile(path))
+}
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_InexistentFile);
+virtual void Handle(Orthanc::ParsedDicomFile* dicom,
-}
+const ParseDicomFileCommand& command,
+uint64_t fileSize) = 0;
-uint64_t fileSize = Orthanc::SystemToolbox::GetFileSize(path);
+static void Apply(IDicomHandler& handler,
-// Check for 32bit systems
+const std::string& root,
-if (fileSize != static_cast<uint64_t>(static_cast<size_t>(fileSize)))
+const ParseDicomFileCommand& command)
 {
-throw Orthanc::OrthancException(Orthanc::ErrorCode_NotEnoughMemory);
+std::string path = GetPath(root, command.GetPath());
-}
+if (!Orthanc::SystemToolbox::IsRegularFile(path))
-DcmFileFormat dicom;
+{
-bool ok;
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InexistentFile);
+}
-if (command.IsPixelDataIncluded())
-{
+uint64_t fileSize = Orthanc::SystemToolbox::GetFileSize(path);
-ok = dicom.loadFile(path.c_str()).good();
-}
+// Check for 32bit systems
-else
+if (fileSize != static_cast<uint64_t>(static_cast<size_t>(fileSize)))
 {
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NotEnoughMemory);
+}
+DcmFileFormat dicom;
+bool ok;
+if (command.IsPixelDataIncluded())
+{
+ok = dicom.loadFile(path.c_str()).good();
+}
+else
+{
 #if DCMTK_VERSION_NUMBER >= 362
 // NB : We could stop at (0x3007, 0x0000) instead of
 // DCM_PixelData, cf. the Orthanc::DICOM_TAG_* constants
 static const DcmTagKey STOP = DCM_PixelData;
 //static const DcmTagKey STOP(0x3007, 0x0000);
 ok = dicom.loadFileUntilTag(path.c_str(), EXS_Unknown, EGL_noChange,
 DCM_MaxReadLength, ERM_autoDetect, STOP).good();
 #else
 // The primitive "loadFileUntilTag" was introduced in DCMTK 3.6.2
 ok = dicom.loadFile(path.c_str()).good();
 #endif
 }
 printf("Reading %s\n", path.c_str());
 if (ok)
 {
-Orthanc::ParsedDicomFile parsed(dicom);
+handler.Handle(new Orthanc::ParsedDicomFile(dicom), command, fileSize);
-ParseDicomFileCommand::SuccessMessage message
+}
-(command, parsed, static_cast<size_t>(fileSize), command.IsPixelDataIncluded());
+else
-emitter.EmitMessage(receiver, message);
+{
-}
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat,
-else
+"Cannot parse file: " + path);
-{
+}
-throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat,
+}
-"Cannot parse file: " + path);
+};
-}
+class DicomHandlerWithoutCache : public IDicomHandler
+{
+private:
+boost::weak_ptr<IObserver> receiver_;
+IMessageEmitter&           emitter_;
+public:
+DicomHandlerWithoutCache(boost::weak_ptr<IObserver> receiver,
+IMessageEmitter& emitter) :
+receiver_(receiver),
+emitter_(emitter)
+{
+}
+virtual void Handle(Orthanc::ParsedDicomFile* dicom,
+const ParseDicomFileCommand& command,
+uint64_t fileSize)
+{
+std::auto_ptr<Orthanc::ParsedDicomFile> parsed(dicom);
+ParseDicomFileCommand::SuccessMessage message
+(command, *parsed, static_cast<size_t>(fileSize), command.IsPixelDataIncluded());
+emitter_.EmitMessage(receiver_, message);
+}
+};
+class DicomHandlerWithCache : public IDicomHandler
+{
+private:
+boost::weak_ptr<IObserver> receiver_;
+IMessageEmitter&           emitter_;
+boost::shared_ptr<ParsedDicomFileCache>  cache_;
+public:
+DicomHandlerWithCache(boost::weak_ptr<IObserver> receiver,
+IMessageEmitter& emitter,
+boost::shared_ptr<ParsedDicomFileCache> cache) :
+receiver_(receiver),
+emitter_(emitter),
+cache_(cache)
+{
+if (!cache)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
+}
+}
+virtual void Handle(Orthanc::ParsedDicomFile* dicom,
+const ParseDicomFileCommand& command,
+uint64_t fileSize)
+{
+std::auto_ptr<Orthanc::ParsedDicomFile> parsed(dicom);
+{
+ParseDicomFileCommand::SuccessMessage message
+(command, *parsed, static_cast<size_t>(fileSize), command.IsPixelDataIncluded());
+emitter_.EmitMessage(receiver_, message);
+}
+// Store it into the cache for future use
+assert(cache_);
+cache_->Acquire(command.GetPath(), parsed.release(),
+static_cast<size_t>(fileSize), command.IsPixelDataIncluded());
+}
+};
 }
 static void RunInternal(boost::weak_ptr<IObserver> receiver,
 IMessageEmitter& emitter,
 boost::shared_ptr<ParsedDicomFileCache> cache,
 const std::string& root,
 const ParseDicomFileCommand& command)
 {
-#if 0
+#if 1
-// The code to use the cache is buggy in multithreaded environments => TODO FIX
 if (cache.get())
 {
 {
 ParsedDicomFileCache::Reader reader(*cache, command.GetPath());
 if (reader.IsValid() &&
 (!command.IsPixelDataIncluded() ||
 reader.HasPixelData()))
 {
 // Reuse the DICOM file from the cache
-return new ParseDicomFileCommand::SuccessMessage(
+ParseDicomFileCommand::SuccessMessage message(
 command, reader.GetDicom(), reader.GetFileSize(), reader.HasPixelData());
 emitter.EmitMessage(receiver, message);
 return;
 }
 }
-// Not in the cache, first read and parse the DICOM file
+DicomHandlerWithCache handler(receiver, emitter, cache);
-std::auto_ptr<ParseDicomFileCommand::SuccessMessage> message(RunInternal(root, command));
+IDicomHandler::Apply(handler, root, command);
-// Secondly, store it into the cache for future use
-assert(&message->GetOrigin() == &command);
-cache->Acquire(message->GetOrigin().GetPath(), message->GetDicom(),
-message->GetFileSize(), message->HasPixelData());
-return message.release();
 }
 else
 {
 // No cache available
-return RunInternal(root, command);
+DicomHandlerWithoutCache handler(receiver, emitter);
+IDicomHandler::Apply(handler, root, command);
 }
 #else
-return RunInternal(receiver, emitter, root, command);
+DicomHandlerWithoutCache handler(receiver, emitter);
+IDicomHandler::Apply(handler, root, command);
 #endif
 }
 #endif

Mercurial > hg > orthanc-stone

comparison Framework/Oracle/GenericOracleRunner.cpp @ 1136:42581a6182c8 broker