36 #include "OrthancCDatabasePlugin.h"
49 NonCopyable(
const NonCopyable&);
51 NonCopyable& operator= (
const NonCopyable&);
78 AllowedAnswers_Attachment,
79 AllowedAnswers_Change,
80 AllowedAnswers_DicomTag,
81 AllowedAnswers_ExportedResource
86 AllowedAnswers allowedAnswers_;
88 void SetAllowedAnswers(AllowedAnswers allowed)
90 allowedAnswers_ = allowed;
98 allowedAnswers_(AllowedAnswers_All )
102 void LogError(
const std::string& message)
107 void LogWarning(
const std::string& message)
112 void LogInfo(
const std::string& message)
117 void SignalDeletedAttachment(
const std::string& uuid,
119 uint64_t uncompressedSize,
120 const std::string& uncompressedHash,
121 int32_t compressionType,
122 uint64_t compressedSize,
123 const std::string& compressedHash)
125 OrthancPluginAttachment attachment;
126 attachment.uuid = uuid.c_str();
127 attachment.contentType = contentType;
128 attachment.uncompressedSize = uncompressedSize;
129 attachment.uncompressedHash = uncompressedHash.c_str();
130 attachment.compressionType = compressionType;
131 attachment.compressedSize = compressedSize;
132 attachment.compressedHash = compressedHash.c_str();
134 OrthancPluginDatabaseSignalDeletedAttachment(context_, database_, &attachment);
137 void SignalDeletedResource(
const std::string& publicId,
140 OrthancPluginDatabaseSignalDeletedResource(context_, database_, publicId.c_str(), resourceType);
143 void SignalRemainingAncestor(
const std::string& ancestorId,
146 OrthancPluginDatabaseSignalRemainingAncestor(context_, database_, ancestorId.c_str(), ancestorType);
149 void AnswerAttachment(
const std::string& uuid,
151 uint64_t uncompressedSize,
152 const std::string& uncompressedHash,
153 int32_t compressionType,
154 uint64_t compressedSize,
155 const std::string& compressedHash)
157 if (allowedAnswers_ != AllowedAnswers_All &&
158 allowedAnswers_ != AllowedAnswers_Attachment)
160 throw std::runtime_error(
"Cannot answer with an attachment in the current state");
163 OrthancPluginAttachment attachment;
164 attachment.uuid = uuid.c_str();
165 attachment.contentType = contentType;
166 attachment.uncompressedSize = uncompressedSize;
167 attachment.uncompressedHash = uncompressedHash.c_str();
168 attachment.compressionType = compressionType;
169 attachment.compressedSize = compressedSize;
170 attachment.compressedHash = compressedHash.c_str();
172 OrthancPluginDatabaseAnswerAttachment(context_, database_, &attachment);
175 void AnswerChange(int64_t seq,
178 const std::string& publicId,
179 const std::string& date)
181 if (allowedAnswers_ != AllowedAnswers_All &&
182 allowedAnswers_ != AllowedAnswers_Change)
184 throw std::runtime_error(
"Cannot answer with a change in the current state");
187 OrthancPluginChange change;
189 change.changeType = changeType;
190 change.resourceType = resourceType;
191 change.publicId = publicId.c_str();
192 change.date = date.c_str();
194 OrthancPluginDatabaseAnswerChange(context_, database_, &change);
197 void AnswerDicomTag(uint16_t group,
199 const std::string& value)
201 if (allowedAnswers_ != AllowedAnswers_All &&
202 allowedAnswers_ != AllowedAnswers_DicomTag)
204 throw std::runtime_error(
"Cannot answer with a DICOM tag in the current state");
207 OrthancPluginDicomTag tag;
209 tag.element = element;
210 tag.value = value.c_str();
212 OrthancPluginDatabaseAnswerDicomTag(context_, database_, &tag);
215 void AnswerExportedResource(int64_t seq,
217 const std::string& publicId,
218 const std::string& modality,
219 const std::string& date,
220 const std::string& patientId,
221 const std::string& studyInstanceUid,
222 const std::string& seriesInstanceUid,
223 const std::string& sopInstanceUid)
225 if (allowedAnswers_ != AllowedAnswers_All &&
226 allowedAnswers_ != AllowedAnswers_ExportedResource)
228 throw std::runtime_error(
"Cannot answer with an exported resource in the current state");
231 OrthancPluginExportedResource exported;
233 exported.resourceType = resourceType;
234 exported.publicId = publicId.c_str();
235 exported.modality = modality.c_str();
236 exported.date = date.c_str();
237 exported.patientId = patientId.c_str();
238 exported.studyInstanceUid = studyInstanceUid.c_str();
239 exported.seriesInstanceUid = seriesInstanceUid.c_str();
240 exported.sopInstanceUid = sopInstanceUid.c_str();
242 OrthancPluginDatabaseAnswerExportedResource(context_, database_, &exported);
289 virtual void Open() = 0;
291 virtual void Close() = 0;
293 virtual void AddAttachment(int64_t
id,
294 const OrthancPluginAttachment& attachment) = 0;
296 virtual void AttachChild(int64_t parent,
299 virtual void ClearChanges() = 0;
301 virtual void ClearExportedResources() = 0;
303 virtual int64_t CreateResource(
const char* publicId,
306 virtual void DeleteAttachment(int64_t
id,
307 int32_t attachment) = 0;
309 virtual void DeleteMetadata(int64_t
id,
310 int32_t metadataType) = 0;
312 virtual void DeleteResource(int64_t
id) = 0;
314 virtual void GetAllPublicIds(std::list<std::string>& target,
317 virtual void GetAllPublicIds(std::list<std::string>& target,
323 virtual void GetChanges(
bool& done ,
325 uint32_t maxResults) = 0;
327 virtual void GetChildrenInternalId(std::list<int64_t>& target ,
330 virtual void GetChildrenPublicId(std::list<std::string>& target ,
334 virtual void GetExportedResources(
bool& done ,
336 uint32_t maxResults) = 0;
339 virtual void GetLastChange() = 0;
342 virtual void GetLastExportedResource() = 0;
345 virtual void GetMainDicomTags(int64_t
id) = 0;
347 virtual std::string GetPublicId(int64_t resourceId) = 0;
353 virtual uint64_t GetTotalCompressedSize() = 0;
355 virtual uint64_t GetTotalUncompressedSize() = 0;
357 virtual bool IsExistingResource(int64_t internalId) = 0;
359 virtual bool IsProtectedPatient(int64_t internalId) = 0;
361 virtual void ListAvailableMetadata(std::list<int32_t>& target ,
364 virtual void ListAvailableAttachments(std::list<int32_t>& target ,
367 virtual void LogChange(
const OrthancPluginChange& change) = 0;
369 virtual void LogExportedResource(
const OrthancPluginExportedResource& resource) = 0;
372 virtual bool LookupAttachment(int64_t
id,
373 int32_t contentType) = 0;
375 virtual bool LookupGlobalProperty(std::string& target ,
376 int32_t property) = 0;
387 const char* value) = 0;
390 const char* value) = 0;
392 virtual bool LookupMetadata(std::string& target ,
394 int32_t metadataType) = 0;
396 virtual bool LookupParent(int64_t& parentId ,
397 int64_t resourceId) = 0;
399 virtual bool LookupResource(int64_t&
id ,
401 const char* publicId) = 0;
403 virtual bool SelectPatientToRecycle(int64_t& internalId ) = 0;
405 virtual bool SelectPatientToRecycle(int64_t& internalId ,
406 int64_t patientIdToAvoid) = 0;
408 virtual void SetGlobalProperty(int32_t property,
409 const char* value) = 0;
411 virtual void SetMainDicomTag(int64_t
id,
414 const char* value) = 0;
416 virtual void SetIdentifierTag(int64_t
id,
419 const char* value) = 0;
421 virtual void SetMetadata(int64_t
id,
422 int32_t metadataType,
423 const char* value) = 0;
425 virtual void SetProtectedPatient(int64_t internalId,
426 bool isProtected) = 0;
428 virtual void StartTransaction() = 0;
430 virtual void RollbackTransaction() = 0;
432 virtual void CommitTransaction() = 0;
434 virtual uint32_t GetDatabaseVersion() = 0;
436 virtual void UpgradeDatabase(uint32_t targetVersion,
460 const std::runtime_error& e)
462 backend->GetOutput().LogError(
"Exception in database back-end: " + std::string(e.what()));
466 static int32_t AddAttachment(
void* payload,
468 const OrthancPluginAttachment* attachment)
471 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
475 backend->AddAttachment(
id, *attachment);
478 catch (std::runtime_error& e)
480 LogError(backend, e);
486 static int32_t AttachChild(
void* payload,
491 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
495 backend->AttachChild(parent, child);
498 catch (std::runtime_error& e)
500 LogError(backend, e);
506 static int32_t ClearChanges(
void* payload)
509 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
513 backend->ClearChanges();
516 catch (std::runtime_error& e)
518 LogError(backend, e);
524 static int32_t ClearExportedResources(
void* payload)
527 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
531 backend->ClearExportedResources();
534 catch (std::runtime_error& e)
536 LogError(backend, e);
542 static int32_t CreateResource(int64_t*
id,
544 const char* publicId,
548 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
552 *
id = backend->CreateResource(publicId, resourceType);
555 catch (std::runtime_error& e)
557 LogError(backend, e);
563 static int32_t DeleteAttachment(
void* payload,
568 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
572 backend->DeleteAttachment(
id, contentType);
575 catch (std::runtime_error& e)
577 LogError(backend, e);
583 static int32_t DeleteMetadata(
void* payload,
585 int32_t metadataType)
588 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
592 backend->DeleteMetadata(
id, metadataType);
595 catch (std::runtime_error& e)
597 LogError(backend, e);
603 static int32_t DeleteResource(
void* payload,
607 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
611 backend->DeleteResource(
id);
614 catch (std::runtime_error& e)
616 LogError(backend, e);
627 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
631 std::list<std::string> ids;
632 backend->GetAllPublicIds(ids, resourceType);
634 for (std::list<std::string>::const_iterator
635 it = ids.begin(); it != ids.end(); ++it)
637 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
638 backend->GetOutput().database_,
644 catch (std::runtime_error& e)
646 LogError(backend, e);
659 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
663 std::list<std::string> ids;
664 backend->GetAllPublicIds(ids, resourceType, since, limit);
666 for (std::list<std::string>::const_iterator
667 it = ids.begin(); it != ids.end(); ++it)
669 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
670 backend->GetOutput().database_,
676 catch (std::runtime_error& e)
678 LogError(backend, e);
690 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change);
695 backend->GetChanges(done, since, maxResult);
699 OrthancPluginDatabaseAnswerChangesDone(backend->GetOutput().context_,
700 backend->GetOutput().database_);
705 catch (std::runtime_error& e)
707 LogError(backend, e);
718 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
722 std::list<int64_t> target;
723 backend->GetChildrenInternalId(target,
id);
725 for (std::list<int64_t>::const_iterator
726 it = target.begin(); it != target.end(); ++it)
728 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
729 backend->GetOutput().database_, *it);
734 catch (std::runtime_error& e)
736 LogError(backend, e);
747 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
751 std::list<std::string> ids;
752 backend->GetChildrenPublicId(ids,
id);
754 for (std::list<std::string>::const_iterator
755 it = ids.begin(); it != ids.end(); ++it)
757 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
758 backend->GetOutput().database_,
764 catch (std::runtime_error& e)
766 LogError(backend, e);
778 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource);
783 backend->GetExportedResources(done, since, maxResult);
787 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetOutput().context_,
788 backend->GetOutput().database_);
792 catch (std::runtime_error& e)
794 LogError(backend, e);
804 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change);
808 backend->GetLastChange();
811 catch (std::runtime_error& e)
813 LogError(backend, e);
823 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource);
827 backend->GetLastExportedResource();
830 catch (std::runtime_error& e)
832 LogError(backend, e);
843 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_DicomTag);
847 backend->GetMainDicomTags(
id);
850 catch (std::runtime_error& e)
852 LogError(backend, e);
863 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
867 std::string s = backend->GetPublicId(
id);
868 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
869 backend->GetOutput().database_,
874 catch (std::runtime_error& e)
876 LogError(backend, e);
882 static int32_t GetResourceCount(uint64_t* target,
887 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
891 *target = backend->GetResourceCount(resourceType);
894 catch (std::runtime_error& e)
896 LogError(backend, e);
907 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
911 *resourceType = backend->GetResourceType(
id);
914 catch (std::runtime_error& e)
916 LogError(backend, e);
922 static int32_t GetTotalCompressedSize(uint64_t* target,
926 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
930 *target = backend->GetTotalCompressedSize();
933 catch (std::runtime_error& e)
935 LogError(backend, e);
941 static int32_t GetTotalUncompressedSize(uint64_t* target,
945 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
949 *target = backend->GetTotalUncompressedSize();
952 catch (std::runtime_error& e)
954 LogError(backend, e);
960 static int32_t IsExistingResource(int32_t* existing,
965 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
969 *existing = backend->IsExistingResource(
id);
972 catch (std::runtime_error& e)
974 LogError(backend, e);
980 static int32_t IsProtectedPatient(int32_t* isProtected,
985 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
989 *isProtected = backend->IsProtectedPatient(
id);
992 catch (std::runtime_error& e)
994 LogError(backend, e);
1005 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1009 std::list<int32_t> target;
1010 backend->ListAvailableMetadata(target,
id);
1012 for (std::list<int32_t>::const_iterator
1013 it = target.begin(); it != target.end(); ++it)
1015 OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_,
1016 backend->GetOutput().database_,
1022 catch (std::runtime_error& e)
1024 LogError(backend, e);
1035 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1039 std::list<int32_t> target;
1040 backend->ListAvailableAttachments(target,
id);
1042 for (std::list<int32_t>::const_iterator
1043 it = target.begin(); it != target.end(); ++it)
1045 OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_,
1046 backend->GetOutput().database_,
1052 catch (std::runtime_error& e)
1054 LogError(backend, e);
1060 static int32_t LogChange(
void* payload,
1061 const OrthancPluginChange* change)
1064 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1068 backend->LogChange(*change);
1071 catch (std::runtime_error& e)
1073 LogError(backend, e);
1079 static int32_t LogExportedResource(
void* payload,
1080 const OrthancPluginExportedResource* exported)
1083 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1087 backend->LogExportedResource(*exported);
1090 catch (std::runtime_error& e)
1092 LogError(backend, e);
1101 int32_t contentType)
1104 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Attachment);
1108 backend->LookupAttachment(
id, contentType);
1111 catch (std::runtime_error& e)
1113 LogError(backend, e);
1124 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1129 if (backend->LookupGlobalProperty(s, property))
1131 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
1132 backend->GetOutput().database_,
1138 catch (std::runtime_error& e)
1140 LogError(backend, e);
1148 const OrthancPluginDicomTag* tag)
1151 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1155 std::list<int64_t> target;
1158 for (std::list<int64_t>::const_iterator
1159 it = target.begin(); it != target.end(); ++it)
1161 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1162 backend->GetOutput().database_, *it);
1167 catch (std::runtime_error& e)
1169 LogError(backend, e);
1180 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1184 std::list<int64_t> target;
1187 for (std::list<int64_t>::const_iterator
1188 it = target.begin(); it != target.end(); ++it)
1190 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1191 backend->GetOutput().database_, *it);
1196 catch (std::runtime_error& e)
1198 LogError(backend, e);
1210 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1215 if (backend->LookupMetadata(s,
id, metadata))
1217 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
1218 backend->GetOutput().database_, s.c_str());
1223 catch (std::runtime_error& e)
1225 LogError(backend, e);
1236 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1241 if (backend->LookupParent(parent,
id))
1243 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1244 backend->GetOutput().database_, parent);
1249 catch (std::runtime_error& e)
1251 LogError(backend, e);
1259 const char* publicId)
1262 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1268 if (backend->LookupResource(
id, type, publicId))
1270 OrthancPluginDatabaseAnswerResource(backend->GetOutput().context_,
1271 backend->GetOutput().database_,
1277 catch (std::runtime_error& e)
1279 LogError(backend, e);
1289 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1294 if (backend->SelectPatientToRecycle(
id))
1296 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1297 backend->GetOutput().database_, id);
1302 catch (std::runtime_error& e)
1304 LogError(backend, e);
1312 int64_t patientIdToAvoid)
1315 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1320 if (backend->SelectPatientToRecycle(
id, patientIdToAvoid))
1322 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1323 backend->GetOutput().database_, id);
1328 catch (std::runtime_error& e)
1330 LogError(backend, e);
1336 static int32_t SetGlobalProperty(
void* payload,
1341 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1345 backend->SetGlobalProperty(property, value);
1348 catch (std::runtime_error& e)
1350 LogError(backend, e);
1356 static int32_t SetMainDicomTag(
void* payload,
1358 const OrthancPluginDicomTag* tag)
1361 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1365 backend->SetMainDicomTag(
id, tag->group, tag->element, tag->value);
1368 catch (std::runtime_error& e)
1370 LogError(backend, e);
1376 static int32_t SetIdentifierTag(
void* payload,
1378 const OrthancPluginDicomTag* tag)
1381 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1385 backend->SetIdentifierTag(
id, tag->group, tag->element, tag->value);
1388 catch (std::runtime_error& e)
1390 LogError(backend, e);
1396 static int32_t SetMetadata(
void* payload,
1402 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1406 backend->SetMetadata(
id, metadata, value);
1409 catch (std::runtime_error& e)
1411 LogError(backend, e);
1417 static int32_t SetProtectedPatient(
void* payload,
1419 int32_t isProtected)
1422 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1426 backend->SetProtectedPatient(
id, (isProtected != 0));
1429 catch (std::runtime_error& e)
1431 LogError(backend, e);
1437 static int32_t StartTransaction(
void* payload)
1440 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1444 backend->StartTransaction();
1447 catch (std::runtime_error& e)
1449 LogError(backend, e);
1455 static int32_t RollbackTransaction(
void* payload)
1458 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1462 backend->RollbackTransaction();
1465 catch (std::runtime_error& e)
1467 LogError(backend, e);
1473 static int32_t CommitTransaction(
void* payload)
1476 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1480 backend->CommitTransaction();
1483 catch (std::runtime_error& e)
1485 LogError(backend, e);
1491 static int32_t Open(
void* payload)
1494 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1501 catch (std::runtime_error& e)
1503 LogError(backend, e);
1509 static int32_t Close(
void* payload)
1512 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1519 catch (std::runtime_error& e)
1521 LogError(backend, e);
1527 static int32_t GetDatabaseVersion(uint32_t* version,
1534 *version = backend->GetDatabaseVersion();
1537 catch (std::runtime_error& e)
1539 LogError(backend, e);
1545 static int32_t UpgradeDatabase(
void* payload,
1546 uint32_t targetVersion,
1553 backend->UpgradeDatabase(targetVersion, storageArea);
1556 catch (std::runtime_error& e)
1558 LogError(backend, e);
1575 OrthancPluginDatabaseBackend params;
1576 memset(¶ms, 0,
sizeof(params));
1578 OrthancPluginDatabaseExtensions extensions;
1579 memset(&extensions, 0,
sizeof(extensions));
1581 params.addAttachment = AddAttachment;
1582 params.attachChild = AttachChild;
1583 params.clearChanges = ClearChanges;
1584 params.clearExportedResources = ClearExportedResources;
1585 params.createResource = CreateResource;
1586 params.deleteAttachment = DeleteAttachment;
1587 params.deleteMetadata = DeleteMetadata;
1588 params.deleteResource = DeleteResource;
1589 params.getAllPublicIds = GetAllPublicIds;
1590 params.getChanges = GetChanges;
1591 params.getChildrenInternalId = GetChildrenInternalId;
1592 params.getChildrenPublicId = GetChildrenPublicId;
1593 params.getExportedResources = GetExportedResources;
1594 params.getLastChange = GetLastChange;
1595 params.getLastExportedResource = GetLastExportedResource;
1596 params.getMainDicomTags = GetMainDicomTags;
1597 params.getPublicId = GetPublicId;
1598 params.getResourceCount = GetResourceCount;
1599 params.getResourceType = GetResourceType;
1600 params.getTotalCompressedSize = GetTotalCompressedSize;
1601 params.getTotalUncompressedSize = GetTotalUncompressedSize;
1602 params.isExistingResource = IsExistingResource;
1603 params.isProtectedPatient = IsProtectedPatient;
1604 params.listAvailableMetadata = ListAvailableMetadata;
1605 params.listAvailableAttachments = ListAvailableAttachments;
1606 params.logChange = LogChange;
1607 params.logExportedResource = LogExportedResource;
1608 params.lookupAttachment = LookupAttachment;
1609 params.lookupGlobalProperty = LookupGlobalProperty;
1610 params.lookupIdentifier = LookupIdentifier;
1611 params.lookupIdentifier2 = LookupIdentifier2;
1612 params.lookupMetadata = LookupMetadata;
1613 params.lookupParent = LookupParent;
1614 params.lookupResource = LookupResource;
1615 params.selectPatientToRecycle = SelectPatientToRecycle;
1616 params.selectPatientToRecycle2 = SelectPatientToRecycle2;
1617 params.setGlobalProperty = SetGlobalProperty;
1618 params.setMainDicomTag = SetMainDicomTag;
1619 params.setIdentifierTag = SetIdentifierTag;
1620 params.setMetadata = SetMetadata;
1621 params.setProtectedPatient = SetProtectedPatient;
1622 params.startTransaction = StartTransaction;
1623 params.rollbackTransaction = RollbackTransaction;
1624 params.commitTransaction = CommitTransaction;
1626 params.close = Close;
1628 extensions.getAllPublicIdsWithLimit = GetAllPublicIdsWithLimit;
1629 extensions.getDatabaseVersion = GetDatabaseVersion;
1630 extensions.upgradeDatabase = UpgradeDatabase;
1635 throw std::runtime_error(
"Unable to register the database backend");
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:647
static void Register(OrthancPluginContext *context, IDatabaseBackend &backend)
Definition: OrthancCppDatabasePlugin.h:1572
virtual void LookupIdentifier(std::list< int64_t > &target, uint16_t group, uint16_t element, const char *value)=0
Definition: OrthancCppDatabasePlugin.h:42
Bridge between C and C++ database engines.
Definition: OrthancCppDatabasePlugin.h:451
Definition: OrthancCppDatabasePlugin.h:69
struct _OrthancPluginDatabaseContext_t OrthancPluginDatabaseContext
Definition: OrthancCDatabasePlugin.h:55
OrthancPluginDatabaseContext * OrthancPluginRegisterDatabaseBackendV2(OrthancPluginContext *context, const OrthancPluginDatabaseBackend *backend, const OrthancPluginDatabaseExtensions *extensions, void *payload)
Definition: OrthancCDatabasePlugin.h:742
Definition: OrthancCppDatabasePlugin.h:250