orthanc: OrthancServer/Sources/ServerIndex.cpp comparison

comparison OrthancServer/Sources/ServerIndex.cpp @ 4564:5a0adc1c19a9 db-changes

avoid copy of objects in ServerIndex

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 08 Mar 2021 11:08:03 +0100
parents	bb1c365f9e44
children	3495a3d97ab6

comparison

equal deleted inserted replaced

-:bb1c365f9e44
+:5a0adc1c19a9
 bool ServerIndex::ExpandResource(Json::Value& target,
 const std::string& publicId,
 ResourceType level)
 {
-class Operations : public ReadOnlyOperationsT4<bool*, Json::Value*, std::string, ResourceType>
+class Operations : public ReadOnlyOperationsT4<bool&, Json::Value&, const std::string&, ResourceType>
 {
 private:
 ServerIndex&  index_;
 public:
 ResourceType type;
 std::string parent;
 if (!transaction.LookupResourceAndParent(internalId, type, parent, tuple.get<2>()) ||
 type != tuple.get<3>())
 {
-*tuple.get<0>() = false;
+tuple.get<0>() = false;
 }
 else
 {
-Json::Value& target = *tuple.get<1>();
+Json::Value& target = tuple.get<1>();
 target = Json::objectValue;
 // Set information about the parent resource (if it exists)
 if (type == ResourceType_Patient)
 {
 {
 target["LastUpdate"] = tmp;
 }
 }
-*tuple.get<0>() = true;
+tuple.get<0>() = true;
 }
 }
 };
 bool found;
 Operations operations(*this);
-operations.Apply(*this, &found, &target, publicId, level);
+operations.Apply(*this, found, target, publicId, level);
 return found;
 }
 void ServerIndex::GetAllMetadata(std::map<MetadataType, std::string>& target,
 const std::string& publicId,
 ResourceType level)
 {
-class Operations : public ReadOnlyOperationsT3<std::map<MetadataType, std::string>*, std::string, ResourceType>
+class Operations : public ReadOnlyOperationsT3<std::map<MetadataType, std::string>&, const std::string&, ResourceType>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 {
 throw OrthancException(ErrorCode_UnknownResource);
 }
 else
 {
-transaction.GetAllMetadata(*tuple.get<0>(), id);
+transaction.GetAllMetadata(tuple.get<0>(), id);
 }
 }
 };
 Operations operations;
-operations.Apply(*this, &target, publicId, level);
+operations.Apply(*this, target, publicId, level);
 }
 bool ServerIndex::LookupAttachment(FileInfo& attachment,
 const std::string& instancePublicId,
 FileContentType contentType)
 {
-class Operations : public ReadOnlyOperationsT4<bool*, FileInfo*, std::string, FileContentType>
+class Operations : public ReadOnlyOperationsT4<bool&, FileInfo&, const std::string&, FileContentType>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 ResourceType type;
 if (!transaction.LookupResource(internalId, type, tuple.get<2>()))
 {
 throw OrthancException(ErrorCode_UnknownResource);
 }
-else if (transaction.LookupAttachment(*tuple.get<1>(), internalId, tuple.get<3>()))
+else if (transaction.LookupAttachment(tuple.get<1>(), internalId, tuple.get<3>()))
 {
-assert(tuple.get<1>()->GetContentType() == tuple.get<3>());
+assert(tuple.get<1>().GetContentType() == tuple.get<3>());
-*tuple.get<0>() = true;
+tuple.get<0>() = true;
 }
 else
 {
-*tuple.get<0>() = false;
+tuple.get<0>() = false;
 }
 }
 };
 bool found;
 Operations operations;
-operations.Apply(*this, &found, &attachment, instancePublicId, contentType);
+operations.Apply(*this, found, attachment, instancePublicId, contentType);
 return found;
 }
 void ServerIndex::GetAllUuids(std::list<std::string>& target,
 ResourceType resourceType)
 {
-class Operations : public ReadOnlyOperationsT2<std::list<std::string>*, ResourceType>
+class Operations : public ReadOnlyOperationsT2<std::list<std::string>&, ResourceType>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 // TODO - CANDIDATE FOR "TransactionType_SingleStatement"
-transaction.GetAllPublicIds(*tuple.get<0>(), tuple.get<1>());
+transaction.GetAllPublicIds(tuple.get<0>(), tuple.get<1>());
 }
 };
 Operations operations;
-operations.Apply(*this, &target, resourceType);
+operations.Apply(*this, target, resourceType);
 }
 void ServerIndex::GetAllUuids(std::list<std::string>& target,
 ResourceType resourceType,
 {
 target.clear();
 }
 else
 {
-class Operations : public ReadOnlyOperationsT4<std::list<std::string>*, ResourceType, size_t, size_t>
+class Operations : public ReadOnlyOperationsT4<std::list<std::string>&, ResourceType, size_t, size_t>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 // TODO - CANDIDATE FOR "TransactionType_SingleStatement"
-transaction.GetAllPublicIds(*tuple.get<0>(), tuple.get<1>(), tuple.get<2>(), tuple.get<3>());
+transaction.GetAllPublicIds(tuple.get<0>(), tuple.get<1>(), tuple.get<2>(), tuple.get<3>());
 }
 };
 Operations operations;
-operations.Apply(*this, &target, resourceType, since, limit);
+operations.Apply(*this, target, resourceType, since, limit);
 }
 }
 void ServerIndex::GetGlobalStatistics(/* out */ uint64_t& diskSize,
 /* out */ uint64_t& countPatients,
 /* out */ uint64_t& countStudies,
 /* out */ uint64_t& countSeries,
 /* out */ uint64_t& countInstances)
 {
-class Operations : public ReadOnlyOperationsT6<uint64_t*, uint64_t*, uint64_t*, uint64_t*, uint64_t*, uint64_t*>
+class Operations : public ReadOnlyOperationsT6<uint64_t&, uint64_t&, uint64_t&, uint64_t&, uint64_t&, uint64_t&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
-*tuple.get<0>() = transaction.GetTotalCompressedSize();
+tuple.get<0>() = transaction.GetTotalCompressedSize();
-*tuple.get<1>() = transaction.GetTotalUncompressedSize();
+tuple.get<1>() = transaction.GetTotalUncompressedSize();
-*tuple.get<2>() = transaction.GetResourceCount(ResourceType_Patient);
+tuple.get<2>() = transaction.GetResourceCount(ResourceType_Patient);
-*tuple.get<3>() = transaction.GetResourceCount(ResourceType_Study);
+tuple.get<3>() = transaction.GetResourceCount(ResourceType_Study);
-*tuple.get<4>() = transaction.GetResourceCount(ResourceType_Series);
+tuple.get<4>() = transaction.GetResourceCount(ResourceType_Series);
-*tuple.get<5>() = transaction.GetResourceCount(ResourceType_Instance);
+tuple.get<5>() = transaction.GetResourceCount(ResourceType_Instance);
 }
 };
 Operations operations;
-operations.Apply(*this, &diskSize, &uncompressedSize, &countPatients,
+operations.Apply(*this, diskSize, uncompressedSize, countPatients,
-&countStudies, &countSeries, &countInstances);
+countStudies, countSeries, countInstances);
 }
 void ServerIndex::GetChanges(Json::Value& target,
 int64_t since,
 unsigned int maxResults)
 {
-class Operations : public ReadOnlyOperationsT3<Json::Value*, int64_t, unsigned int>
+class Operations : public ReadOnlyOperationsT3<Json::Value&, int64_t, unsigned int>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 {
 last = transaction.GetLastChangeIndex();
 hasLast = true;
 }
-FormatLog(*tuple.get<0>(), changes, "Changes", done, tuple.get<1>(), hasLast, last);
+FormatLog(tuple.get<0>(), changes, "Changes", done, tuple.get<1>(), hasLast, last);
 }
 };
 Operations operations;
-operations.Apply(*this, &target, since, maxResults);
+operations.Apply(*this, target, since, maxResults);
 }
 void ServerIndex::GetLastChange(Json::Value& target)
 {
-class Operations : public ReadOnlyOperationsT1<Json::Value*>
+class Operations : public ReadOnlyOperationsT1<Json::Value&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 {
 last = transaction.GetLastChangeIndex();
 hasLast = true;
 }
-FormatLog(*tuple.get<0>(), changes, "Changes", true, 0, hasLast, last);
+FormatLog(tuple.get<0>(), changes, "Changes", true, 0, hasLast, last);
 }
 };
 Operations operations;
-operations.Apply(*this, &target);
+operations.Apply(*this, target);
 }
 void ServerIndex::GetExportedResources(Json::Value& target,
 int64_t since,
 unsigned int maxResults)
 {
-class Operations : public ReadOnlyOperationsT3<Json::Value*, int64_t, unsigned int>
+class Operations : public ReadOnlyOperationsT3<Json::Value&, int64_t, unsigned int>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 // TODO - CANDIDATE FOR "TransactionType_SingleStatement"
 std::list<ExportedResource> exported;
 bool done;
 transaction.GetExportedResources(exported, done, tuple.get<1>(), tuple.get<2>());
-FormatLog(*tuple.get<0>(), exported, "Exports", done, tuple.get<1>(), false, -1);
+FormatLog(tuple.get<0>(), exported, "Exports", done, tuple.get<1>(), false, -1);
 }
 };
 Operations operations;
-operations.Apply(*this, &target, since, maxResults);
+operations.Apply(*this, target, since, maxResults);
 }
 void ServerIndex::GetLastExportedResource(Json::Value& target)
 {
-class Operations : public ReadOnlyOperationsT1<Json::Value*>
+class Operations : public ReadOnlyOperationsT1<Json::Value&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 // TODO - CANDIDATE FOR "TransactionType_SingleStatement"
 std::list<ExportedResource> exported;
 transaction.GetLastExportedResource(exported);
-FormatLog(*tuple.get<0>(), exported, "Exports", true, 0, false, -1);
+FormatLog(tuple.get<0>(), exported, "Exports", true, 0, false, -1);
 }
 };
 Operations operations;
-operations.Apply(*this, &target);
+operations.Apply(*this, target);
 }
 bool ServerIndex::IsProtectedPatient(const std::string& publicId)
 {
-class Operations : public ReadOnlyOperationsT2<bool*, std::string>
+class Operations : public ReadOnlyOperationsT2<bool&, const std::string&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 {
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
 else
 {
-*tuple.get<0>() = transaction.IsProtectedPatient(id);
+tuple.get<0>() = transaction.IsProtectedPatient(id);
 }
 }
 };
 bool isProtected;
 Operations operations;
-operations.Apply(*this, &isProtected, publicId);
+operations.Apply(*this, isProtected, publicId);
 return isProtected;
 }
 void ServerIndex::GetChildren(std::list<std::string>& result,
 const std::string& publicId)
 {
-class Operations : public ReadOnlyOperationsT2<std::list<std::string>*, std::string>
+class Operations : public ReadOnlyOperationsT2<std::list<std::string>&, const std::string&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 else
 {
 std::list<int64_t> tmp;
 transaction.GetChildrenInternalId(tmp, resource);
-tuple.get<0>()->clear();
+tuple.get<0>().clear();
 for (std::list<int64_t>::const_iterator
 it = tmp.begin(); it != tmp.end(); ++it)
 {
-tuple.get<0>()->push_back(transaction.GetPublicId(*it));
+tuple.get<0>().push_back(transaction.GetPublicId(*it));
 }
 }
 }
 };
 Operations operations;
-operations.Apply(*this, &result, publicId);
+operations.Apply(*this, result, publicId);
 }
 void ServerIndex::GetChildInstances(std::list<std::string>& result,
 const std::string& publicId)
 {
-class Operations : public ReadOnlyOperationsT2<std::list<std::string>*, std::string>
+class Operations : public ReadOnlyOperationsT2<std::list<std::string>&, const std::string&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
-tuple.get<0>()->clear();
+tuple.get<0>().clear();
 ResourceType type;
 int64_t top;
 if (!transaction.LookupResource(top, type, tuple.get<1>()))
 {
 throw OrthancException(ErrorCode_UnknownResource);
 }
 else if (type == ResourceType_Instance)
 {
 // The resource is already an instance: Do not go down the hierarchy
-tuple.get<0>()->push_back(tuple.get<1>());
+tuple.get<0>().push_back(tuple.get<1>());
 }
 else
 {
 std::stack<int64_t> toExplore;
 toExplore.push(top);
 // TODO - This could be optimized by seeing how many
 // levels "type == transaction.GetResourceType(top)" is
 // above the "instances level"
 if (transaction.GetResourceType(resource) == ResourceType_Instance)
 {
-tuple.get<0>()->push_back(transaction.GetPublicId(resource));
+tuple.get<0>().push_back(transaction.GetPublicId(resource));
 }
 else
 {
 // Tag all the children of this resource as to be explored
 transaction.GetChildrenInternalId(tmp, resource);
 }
 }
 };
 Operations operations;
-operations.Apply(*this, &result, publicId);
+operations.Apply(*this, result, publicId);
 }
 bool ServerIndex::LookupMetadata(std::string& target,
 const std::string& publicId,
 ResourceType expectedType,
 MetadataType type)
 {
-class Operations : public ReadOnlyOperationsT5<bool*, std::string*, std::string, ResourceType, MetadataType>
+class Operations : public ReadOnlyOperationsT5<bool&, std::string&, const std::string&, ResourceType, MetadataType>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 {
 throw OrthancException(ErrorCode_UnknownResource);
 }
 else
 {
-*tuple.get<0>() = transaction.LookupMetadata(*tuple.get<1>(), id, tuple.get<4>());
+tuple.get<0>() = transaction.LookupMetadata(tuple.get<1>(), id, tuple.get<4>());
 }
 }
 };
 bool found;
 Operations operations;
-operations.Apply(*this, &found, &target, publicId, expectedType, type);
+operations.Apply(*this, found, target, publicId, expectedType, type);
 return found;
 }
 void ServerIndex::ListAvailableAttachments(std::set<FileContentType>& target,
 const std::string& publicId,
 ResourceType expectedType)
 {
-class Operations : public ReadOnlyOperationsT3<std::set<FileContentType>*, std::string, ResourceType>
+class Operations : public ReadOnlyOperationsT3<std::set<FileContentType>&, const std::string&, ResourceType>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 {
 throw OrthancException(ErrorCode_UnknownResource);
 }
 else
 {
-transaction.ListAvailableAttachments(*tuple.get<0>(), id);
+transaction.ListAvailableAttachments(tuple.get<0>(), id);
 }
 }
 };
 Operations operations;
-operations.Apply(*this, &target, publicId, expectedType);
+operations.Apply(*this, target, publicId, expectedType);
 }
 bool ServerIndex::LookupParent(std::string& target,
 const std::string& publicId)
 {
-class Operations : public ReadOnlyOperationsT3<bool*, std::string*, std::string>
+class Operations : public ReadOnlyOperationsT3<bool&, std::string&, const std::string&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 else
 {
 int64_t parentId;
 if (transaction.LookupParent(parentId, id))
 {
-*tuple.get<1>() = transaction.GetPublicId(parentId);
+tuple.get<1>() = transaction.GetPublicId(parentId);
-*tuple.get<0>() = true;
+tuple.get<0>() = true;
 }
 else
 {
-*tuple.get<0>() = false;
+tuple.get<0>() = false;
 }
 }
 }
 };
 bool found;
 Operations operations;
-operations.Apply(*this, &found, &target, publicId);
+operations.Apply(*this, found, target, publicId);
 return found;
 }
 void ServerIndex::GetResourceStatistics(/* out */ ResourceType& type,
 bool ServerIndex::LookupGlobalProperty(std::string& value,
 GlobalProperty property)
 {
-class Operations : public ReadOnlyOperationsT3<bool*, std::string*, GlobalProperty>
+class Operations : public ReadOnlyOperationsT3<bool&, std::string&, GlobalProperty>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 // TODO - CANDIDATE FOR "TransactionType_SingleStatement"
-*tuple.get<0>() = transaction.LookupGlobalProperty(*tuple.get<1>(), tuple.get<2>());
+tuple.get<0>() = transaction.LookupGlobalProperty(tuple.get<1>(), tuple.get<2>());
 }
 };
 bool found;
 Operations operations;
-operations.Apply(*this, &found, &value, property);
+operations.Apply(*this, found, value, property);
 return found;
 }
 std::string ServerIndex::GetGlobalProperty(GlobalProperty property,
 {
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
-class Operations : public ReadOnlyOperationsT5<bool*, DicomMap*, std::string, ResourceType, ResourceType>
+class Operations : public ReadOnlyOperationsT5<bool&, DicomMap&, const std::string&, ResourceType, ResourceType>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 int64_t id;
 ResourceType type;
 if (!transaction.LookupResource(id, type, tuple.get<2>()) ||
 type != tuple.get<3>())
 {
-*tuple.get<0>() = false;
+tuple.get<0>() = false;
 }
 else if (type == ResourceType_Study)
 {
 DicomMap tmp;
 transaction.GetMainDicomTags(tmp, id);
 switch (tuple.get<4>())
 {
 case ResourceType_Patient:
-tmp.ExtractPatientInformation(*tuple.get<1>());
+tmp.ExtractPatientInformation(tuple.get<1>());
-*tuple.get<0>() = true;
+tuple.get<0>() = true;
 break;
 case ResourceType_Study:
-tmp.ExtractStudyInformation(*tuple.get<1>());
+tmp.ExtractStudyInformation(tuple.get<1>());
-*tuple.get<0>() = true;
+tuple.get<0>() = true;
 break;
 default:
 throw OrthancException(ErrorCode_InternalError);
 }
 }
 else
 {
-transaction.GetMainDicomTags(*tuple.get<1>(), id);
+transaction.GetMainDicomTags(tuple.get<1>(), id);
-*tuple.get<0>() = true;
+tuple.get<0>() = true;
 }
 }
 };
 result.Clear();
 bool found;
 Operations operations;
-operations.Apply(*this, &found, &result, publicId, expectedType, levelOfInterest);
+operations.Apply(*this, found, result, publicId, expectedType, levelOfInterest);
 return found;
 }
 bool ServerIndex::GetAllMainDicomTags(DicomMap& result,
 const std::string& instancePublicId)
 {
-class Operations : public ReadOnlyOperationsT3<bool*, DicomMap*, std::string>
+class Operations : public ReadOnlyOperationsT3<bool&, DicomMap&, const std::string&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 int64_t instance;
 ResourceType type;
 if (!transaction.LookupResource(instance, type, tuple.get<2>()) ||
 type != ResourceType_Instance)
 {
-*tuple.get<0>() =  false;
+tuple.get<0>() =  false;
 }
 else
 {
 DicomMap tmp;
 transaction.GetMainDicomTags(tmp, instance);
-tuple.get<1>()->Merge(tmp);
+tuple.get<1>().Merge(tmp);
 int64_t series;
 if (!transaction.LookupParent(series, instance))
 {
 throw OrthancException(ErrorCode_InternalError);
 }
 tmp.Clear();
 transaction.GetMainDicomTags(tmp, series);
-tuple.get<1>()->Merge(tmp);
+tuple.get<1>().Merge(tmp);
 int64_t study;
 if (!transaction.LookupParent(study, series))
 {
 throw OrthancException(ErrorCode_InternalError);
 }
 tmp.Clear();
 transaction.GetMainDicomTags(tmp, study);
-tuple.get<1>()->Merge(tmp);
+tuple.get<1>().Merge(tmp);
 #ifndef NDEBUG
 {
 // Sanity test to check that all the main DICOM tags from the
 // patient level are copied at the study level
 tmp.GetTags(patientTags);
 for (std::set<DicomTag>::const_iterator
 it = patientTags.begin(); it != patientTags.end(); ++it)
 {
-assert(tuple.get<1>()->HasTag(*it));
+assert(tuple.get<1>().HasTag(*it));
 }
 }
 #endif
-*tuple.get<0>() =  true;
+tuple.get<0>() =  true;
 }
 }
 };
 result.Clear();
 bool found;
 Operations operations;
-operations.Apply(*this, &found, &result, instancePublicId);
+operations.Apply(*this, found, result, instancePublicId);
 return found;
 }
 bool ServerIndex::LookupResourceType(ResourceType& type,
 const std::string& publicId)
 {
-class Operations : public ReadOnlyOperationsT3<bool*, ResourceType*, std::string>
+class Operations : public ReadOnlyOperationsT3<bool&, ResourceType&, const std::string&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 // TODO - CANDIDATE FOR "TransactionType_SingleStatement"
 int64_t id;
-*tuple.get<0>() = transaction.LookupResource(id, *tuple.get<1>(), tuple.get<2>());
+tuple.get<0>() = transaction.LookupResource(id, tuple.get<1>(), tuple.get<2>());
 }
 };
 bool found;
 Operations operations;
-operations.Apply(*this, &found, &type, publicId);
+operations.Apply(*this, found, type, publicId);
 return found;
 }
 unsigned int ServerIndex::GetDatabaseVersion()
 {
-class Operations : public ReadOnlyOperationsT1<unsigned int *>
+class Operations : public ReadOnlyOperationsT1<unsigned int&>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 // TODO - CANDIDATE FOR "TransactionType_SingleStatement"
-*tuple.get<0>() = transaction.GetDatabaseVersion();
+tuple.get<0>() = transaction.GetDatabaseVersion();
 }
 };
 unsigned int version;
 Operations operations;
-operations.Apply(*this, &version);
+operations.Apply(*this, version);
 return version;
 }
 bool ServerIndex::LookupParent(std::string& target,
 const std::string& publicId,
 ResourceType parentType)
 {
-class Operations : public ReadOnlyOperationsT4<bool*, std::string*, std::string, ResourceType>
+class Operations : public ReadOnlyOperationsT4<bool&, std::string&, const std::string&, ResourceType>
 {
 public:
 virtual void ApplyTuple(ReadOnlyTransaction& transaction,
 const Tuple& tuple) ORTHANC_OVERRIDE
 {
 int64_t parentId;
 if (type == ResourceType_Patient ||    // Cannot further go up in hierarchy
 !transaction.LookupParent(parentId, id))
 {
-*tuple.get<0>() = false;
+tuple.get<0>() = false;
 return;
 }
 id = parentId;
 type = GetParentResourceType(type);
 }
-*tuple.get<0>() = true;
+tuple.get<0>() = true;
-*tuple.get<1>() = transaction.GetPublicId(id);
+tuple.get<1>() = transaction.GetPublicId(id);
 }
 };
 bool found;
 Operations operations;
-operations.Apply(*this, &found, &target, publicId, parentType);
+operations.Apply(*this, found, target, publicId, parentType);
 return found;
 }
 void ServerIndex::ApplyLookupResources(std::vector<std::string>& resourcesId,
 std::vector<std::string>* instancesId,
 const DatabaseLookup& lookup,
 ResourceType queryLevel,
 size_t limit)
 {
-class Operations : public ReadOnlyOperationsT4<bool, std::vector<DatabaseConstraint>, ResourceType, size_t>
+class Operations : public ReadOnlyOperationsT4<bool, const std::vector<DatabaseConstraint>&, ResourceType, size_t>
 {
 private:
 std::list<std::string>  resourcesList_;
 std::list<std::string>  instancesList_;

Mercurial > hg > orthanc

comparison OrthancServer/Sources/ServerIndex.cpp @ 4564:5a0adc1c19a9 db-changes