orthanc: OrthancServer/ServerIndex.cpp comparison

comparison OrthancServer/ServerIndex.cpp @ 759:8cfc6119a5bd dicom-rt

integration mainline -> dicom-rt

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 16 Apr 2014 16:04:55 +0200
parents	ec69658b031b
children	67e6400fca03 401a9633e492

comparison

equal deleted inserted replaced

-:b82292ba2083
+:8cfc6119a5bd
 /**
 * Orthanc - A Lightweight, RESTful DICOM Store
-* Copyright (C) 2012-2013 Medical Physics Department, CHU of Liege,
+* Copyright (C) 2012-2014 Medical Physics Department, CHU of Liege,
 * Belgium
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 void CommitFilesToRemove()
 {
 for (std::list<std::string>::iterator
 it = pendingFilesToRemove_.begin();
-it != pendingFilesToRemove_.end(); it++)
+it != pendingFilesToRemove_.end(); ++it)
 {
 context_.RemoveFile(*it);
 }
 }
 {
 unsigned int sleep;
 try
 {
+boost::mutex::scoped_lock lock(that->mutex_);
 std::string sleepString = that->db_->GetGlobalProperty(GlobalProperty_FlushSleep);
 sleep = boost::lexical_cast<unsigned int>(sleepString);
 }
 catch (boost::bad_lexical_cast&)
 {
 static void ComputeExpectedNumberOfInstances(DatabaseWrapper& db,
 int64_t series,
 const DicomMap& dicomSummary)
 {
-const DicomValue* value;
+try
-const DicomValue* value2;
+{
+const DicomValue* value;
+const DicomValue* value2;
-try
-{
 if ((value = dicomSummary.TestAndGetValue(DICOM_TAG_IMAGES_IN_ACQUISITION)) != NULL &&
 (value2 = dicomSummary.TestAndGetValue(DICOM_TAG_NUMBER_OF_TEMPORAL_POSITIONS)) != NULL)
 {
 // Patch for series with temporal positions thanks to Will Ryder
 int64_t imagesInAcquisition = boost::lexical_cast<int64_t>(value->AsString());
 }
 // Ensure there is enough room in the storage for the new instance
 uint64_t instanceSize = 0;
 for (Attachments::const_iterator it = attachments.begin();
-it != attachments.end(); it++)
+it != attachments.end(); ++it)
 {
 instanceSize += it->GetCompressedSize();
 }
 Recycle(instanceSize, hasher.HashPatient());
 assert(series != -1);
 assert(instance != -1);
 // Attach the files to the newly created instance
 for (Attachments::const_iterator it = attachments.begin();
-it != attachments.end(); it++)
+it != attachments.end(); ++it)
 {
 db_->AddAttachment(instance, *it);
 }
 // Attach the metadata
 size_t expected;
 try
 {
 expected = boost::lexical_cast<size_t>(s);
-if (expected < 0)
-{
-return SeriesStatus_Unknown;
-}
 }
 catch (boost::bad_lexical_cast&)
 {
 return SeriesStatus_Unknown;
 }
 std::list<int64_t> children;
 db_->GetChildrenInternalId(children, id);
 std::set<size_t> instances;
 for (std::list<int64_t>::const_iterator
-it = children.begin(); it != children.end(); it++)
+it = children.begin(); it != children.end(); ++it)
 {
 // Get the index of this instance in the series
 s = db_->GetMetadata(*it, MetadataType_Instance_IndexInSeries);
 size_t index;
 try
 catch (boost::bad_lexical_cast&)
 {
 return SeriesStatus_Unknown;
 }
-if (index <= 0 || index > expected)
+if (!(index > 0 && index <= expected))
 {
 // Out-of-range instance index
 return SeriesStatus_Inconsistent;
 }
 if (type != ResourceType_Instance)
 {
 Json::Value c = Json::arrayValue;
 for (std::list<std::string>::const_iterator
-it = children.begin(); it != children.end(); it++)
+it = children.begin(); it != children.end(); ++it)
 {
 c.append(*it);
 }
 switch (type)
 {
 boost::mutex::scoped_lock lock(mutex_);
 int64_t id;
 ResourceType type;
-if (!db_->LookupResource(instanceUuid, id, type) ||
+if (!db_->LookupResource(instanceUuid, id, type))
-type != ResourceType_Instance)
 {
 throw OrthancException(ErrorCode_InternalError);
 }
 if (db_->LookupAttachment(attachment, id, contentType))
 else
 LOG(INFO) << "Patient " << publicId << " has been unprotected";
 }
+void ServerIndex::GetChildren(std::list<std::string>& result,
+const std::string& publicId)
+{
+result.clear();
+boost::mutex::scoped_lock lock(mutex_);
+ResourceType type;
+int64_t resource;
+if (!db_->LookupResource(publicId, resource, type))
+{
+throw OrthancException(ErrorCode_UnknownResource);
+}
+if (type == ResourceType_Instance)
+{
+// An instance cannot have a child
+throw OrthancException(ErrorCode_BadParameterType);
+}
+std::list<int64_t> tmp;
+db_->GetChildrenInternalId(tmp, resource);
+for (std::list<int64_t>::const_iterator
+it = tmp.begin(); it != tmp.end(); ++it)
+{
+result.push_back(db_->GetPublicId(*it));
+}
+}
 void ServerIndex::GetChildInstances(std::list<std::string>& result,
 const std::string& publicId)
 {
 result.clear();
 else
 {
 // Tag all the children of this resource as to be explored
 db_->GetChildrenInternalId(tmp, resource);
 for (std::list<int64_t>::const_iterator
-it = tmp.begin(); it != tmp.end(); it++)
+it = tmp.begin(); it != tmp.end(); ++it)
 {
 toExplore.push(*it);
 }
 }
 }
 return db_->LookupMetadata(target, id, type);
 }
-bool ServerIndex::ListAvailableMetadata(std::list<MetadataType>& target,
+void ServerIndex::ListAvailableMetadata(std::list<MetadataType>& target,
 const std::string& publicId)
 {
 boost::mutex::scoped_lock lock(mutex_);
 ResourceType rtype;
 if (!db_->LookupResource(publicId, id, rtype))
 {
 throw OrthancException(ErrorCode_UnknownResource);
 }
-return db_->ListAvailableMetadata(target, id);
+db_->ListAvailableMetadata(target, id);
+}
+void ServerIndex::ListAvailableAttachments(std::list<FileContentType>& target,
+const std::string& publicId,
+ResourceType expectedType)
+{
+boost::mutex::scoped_lock lock(mutex_);
+ResourceType type;
+int64_t id;
+if (!db_->LookupResource(publicId, id, type) ||
+expectedType != type)
+{
+throw OrthancException(ErrorCode_UnknownResource);
+}
+db_->ListAvailableAttachments(target, id);
 }
 bool ServerIndex::LookupParent(std::string& target,
 const std::string& publicId)
 boost::mutex::scoped_lock lock(mutex_);
 db_->ClearTable("ExportedResources");
 }
-void ServerIndex::GetStatistics(Json::Value& target,
+void ServerIndex::GetStatisticsInternal(/* out */ uint64_t& compressedSize,
-const std::string& publicId)
+/* out */ uint64_t& uncompressedSize,
-{
+/* out */ unsigned int& countStudies,
-boost::mutex::scoped_lock lock(mutex_);
+/* out */ unsigned int& countSeries,
+/* out */ unsigned int& countInstances,
-ResourceType type;
+/* in  */ int64_t id,
-int64_t top;
+/* in  */ ResourceType type)
-if (!db_->LookupResource(publicId, top, type))
+{
-{
-throw OrthancException(ErrorCode_UnknownResource);
-}
 std::stack<int64_t> toExplore;
-toExplore.push(top);
+toExplore.push(id);
-int countInstances = 0;
+countInstances = 0;
-int countSeries = 0;
+countSeries = 0;
-int countStudies = 0;
+countStudies = 0;
-uint64_t compressedSize = 0;
+compressedSize = 0;
-uint64_t uncompressedSize = 0;
+uncompressedSize = 0;
 while (!toExplore.empty())
 {
 // Get the internal ID of the current resource
 int64_t resource = toExplore.top();
 toExplore.pop();
 ResourceType thisType = db_->GetResourceType(resource);
+std::list<FileContentType> f;
+db_->ListAvailableAttachments(f, resource);
+for (std::list<FileContentType>::const_iterator
+it = f.begin(); it != f.end(); ++it)
+{
+FileInfo attachment;
+if (db_->LookupAttachment(attachment, resource, *it))
+{
+compressedSize += attachment.GetCompressedSize();
+uncompressedSize += attachment.GetUncompressedSize();
+}
+}
 if (thisType == ResourceType_Instance)
 {
-std::list<FileContentType> f;
-db_->ListAvailableAttachments(f, resource);
-for (std::list<FileContentType>::const_iterator
-it = f.begin(); it != f.end(); it++)
-{
-FileInfo attachment;
-if (db_->LookupAttachment(attachment, resource, *it))
-{
-compressedSize += attachment.GetCompressedSize();
-uncompressedSize += attachment.GetUncompressedSize();
-}
-}
 countInstances++;
 }
 else
 {
 switch (thisType)
 // Tag all the children of this resource as to be explored
 std::list<int64_t> tmp;
 db_->GetChildrenInternalId(tmp, resource);
 for (std::list<int64_t>::const_iterator
-it = tmp.begin(); it != tmp.end(); it++)
+it = tmp.begin(); it != tmp.end(); ++it)
 {
 toExplore.push(*it);
 }
 }
 }
+if (countStudies == 0)
+{
+countStudies = 1;
+}
+if (countSeries == 0)
+{
+countSeries = 1;
+}
+}
+void ServerIndex::GetStatistics(Json::Value& target,
+const std::string& publicId)
+{
+boost::mutex::scoped_lock lock(mutex_);
+ResourceType type;
+int64_t top;
+if (!db_->LookupResource(publicId, top, type))
+{
+throw OrthancException(ErrorCode_UnknownResource);
+}
+uint64_t uncompressedSize;
+uint64_t compressedSize;
+unsigned int countStudies;
+unsigned int countSeries;
+unsigned int countInstances;
+GetStatisticsInternal(compressedSize, uncompressedSize, countStudies,
+countSeries, countInstances, top, type);
 target = Json::objectValue;
 target["DiskSize"] = boost::lexical_cast<std::string>(compressedSize);
 target["DiskSizeMB"] = boost::lexical_cast<unsigned int>(compressedSize / MEGA_BYTES);
 target["UncompressedSize"] = boost::lexical_cast<std::string>(uncompressedSize);
 case ResourceType_Instance:
 default:
 break;
 }
+}
+void ServerIndex::GetStatistics(/* out */ uint64_t& compressedSize,
+/* out */ uint64_t& uncompressedSize,
+/* out */ unsigned int& countStudies,
+/* out */ unsigned int& countSeries,
+/* out */ unsigned int& countInstances,
+const std::string& publicId)
+{
+boost::mutex::scoped_lock lock(mutex_);
+ResourceType type;
+int64_t top;
+if (!db_->LookupResource(publicId, top, type))
+{
+throw OrthancException(ErrorCode_UnknownResource);
+}
+GetStatisticsInternal(compressedSize, uncompressedSize, countStudies,
+countSeries, countInstances, top, type);
 }
 void ServerIndex::UnstableResourcesMonitorThread(ServerIndex* that)
 {
 void ServerIndex::LookupTagValue(std::list<std::string>& result,
 DicomTag tag,
-const std::string& value)
+const std::string& value,
+ResourceType type)
 {
 result.clear();
 boost::mutex::scoped_lock lock(mutex_);
 std::list<int64_t> id;
 db_->LookupTagValue(id, tag, value);
 for (std::list<int64_t>::const_iterator
-it = id.begin(); it != id.end(); it++)
+it = id.begin(); it != id.end(); ++it)
+{
+if (db_->GetResourceType(*it) == type)
+{
+result.push_back(db_->GetPublicId(*it));
+}
+}
+}
+void ServerIndex::LookupTagValue(std::list<std::string>& result,
+DicomTag tag,
+const std::string& value)
+{
+result.clear();
+boost::mutex::scoped_lock lock(mutex_);
+std::list<int64_t> id;
+db_->LookupTagValue(id, tag, value);
+for (std::list<int64_t>::const_iterator
+it = id.begin(); it != id.end(); ++it)
 {
 result.push_back(db_->GetPublicId(*it));
 }
 }
 std::list<int64_t> id;
 db_->LookupTagValue(id, value);
 for (std::list<int64_t>::const_iterator
-it = id.begin(); it != id.end(); it++)
+it = id.begin(); it != id.end(); ++it)
 {
 result.push_back(db_->GetPublicId(*it));
 }
 }
+StoreStatus ServerIndex::AddAttachment(const FileInfo& attachment,
+const std::string& publicId)
+{
+boost::mutex::scoped_lock lock(mutex_);
+Transaction t(*this);
+ResourceType resourceType;
+int64_t resourceId;
+if (!db_->LookupResource(publicId, resourceId, resourceType))
+{
+return StoreStatus_Failure;  // Inexistent resource
+}
+// Remove possible previous attachment
+db_->DeleteAttachment(resourceId, attachment.GetContentType());
+// Locate the patient of the target resource
+int64_t patientId = resourceId;
+for (;;)
+{
+int64_t parent;
+if (db_->LookupParent(parent, patientId))
+{
+// We have not reached the patient level yet
+patientId = parent;
+}
+else
+{
+// We have reached the patient level
+break;
+}
+}
+// Possibly apply the recycling mechanism while preserving this patient
+assert(db_->GetResourceType(patientId) == ResourceType_Patient);
+Recycle(attachment.GetCompressedSize(), db_->GetPublicId(patientId));
+db_->AddAttachment(resourceId, attachment);
+t.Commit(attachment.GetCompressedSize());
+return StoreStatus_Success;
+}
+void ServerIndex::DeleteAttachment(const std::string& publicId,
+FileContentType type)
+{
+boost::mutex::scoped_lock lock(mutex_);
+listener_->Reset();
+Transaction t(*this);
+ResourceType rtype;
+int64_t id;
+if (!db_->LookupResource(publicId, id, rtype))
+{
+throw OrthancException(ErrorCode_UnknownResource);
+}
+db_->DeleteAttachment(id, type);
+t.Commit(0);
+}
 }

Mercurial > hg > orthanc

comparison OrthancServer/ServerIndex.cpp @ 759:8cfc6119a5bd dicom-rt