Mercurial > hg > orthanc-databases
comparison SQLite/Plugins/IndexPlugin.cpp @ 209:13a3863df7fa
cont
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Fri, 19 Mar 2021 17:01:38 +0100 |
parents | 696bc0c9fddb |
children | a0c095a4ba7d |
comparison
equal
deleted
inserted
replaced
208:696bc0c9fddb | 209:13a3863df7fa |
---|---|
101 } | 101 } |
102 | 102 |
103 | 103 |
104 void Clear() | 104 void Clear() |
105 { | 105 { |
106 // We don't systematically clear all the vectors, in order to | |
107 // avoid spending unnecessary time | |
108 | |
109 switch (answerType_) | |
110 { | |
111 case _OrthancPluginDatabaseAnswerType_None: | |
112 break; | |
113 | |
114 case _OrthancPluginDatabaseAnswerType_Attachment: | |
115 attachments_.clear(); | |
116 break; | |
117 | |
118 case _OrthancPluginDatabaseAnswerType_Change: | |
119 changes_.clear(); | |
120 break; | |
121 | |
122 case _OrthancPluginDatabaseAnswerType_DicomTag: | |
123 tags_.clear(); | |
124 break; | |
125 | |
126 case _OrthancPluginDatabaseAnswerType_ExportedResource: | |
127 exported_.clear(); | |
128 break; | |
129 | |
130 case _OrthancPluginDatabaseAnswerType_Int32: | |
131 integers32_.clear(); | |
132 break; | |
133 | |
134 case _OrthancPluginDatabaseAnswerType_Int64: | |
135 integers64_.clear(); | |
136 break; | |
137 | |
138 case _OrthancPluginDatabaseAnswerType_MatchingResource: | |
139 matches_.clear(); | |
140 break; | |
141 | |
142 case _OrthancPluginDatabaseAnswerType_Metadata: | |
143 metadata_.clear(); | |
144 break; | |
145 | |
146 case _OrthancPluginDatabaseAnswerType_String: | |
147 stringAnswers_.clear(); | |
148 break; | |
149 | |
150 default: | |
151 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
152 } | |
153 | |
106 answerType_ = _OrthancPluginDatabaseAnswerType_None; | 154 answerType_ = _OrthancPluginDatabaseAnswerType_None; |
107 stringsStore_.clear(); | 155 stringsStore_.clear(); |
108 | 156 |
109 attachments_.clear(); | 157 assert(attachments_.empty()); |
110 changes_.clear(); | 158 assert(changes_.empty()); |
111 tags_.clear(); | 159 assert(tags_.empty()); |
112 exported_.clear(); | 160 assert(exported_.empty()); |
113 events_.clear(); | 161 assert(events_.empty()); |
114 integers32_.clear(); | 162 assert(integers32_.empty()); |
115 integers64_.clear(); | 163 assert(integers64_.empty()); |
116 matches_.clear(); | 164 assert(matches_.empty()); |
117 metadata_.clear(); | 165 assert(metadata_.empty()); |
118 stringAnswers_.clear(); | 166 assert(stringAnswers_.empty()); |
119 } | 167 } |
120 | 168 |
121 | 169 |
122 static OrthancPluginErrorCode ReadAnswersCount(OrthancPluginDatabaseTransaction* transaction, | 170 static OrthancPluginErrorCode ReadAnswersCount(OrthancPluginDatabaseTransaction* transaction, |
123 uint32_t* target /* out */) | 171 uint32_t* target /* out */) |
194 } | 242 } |
195 } | 243 } |
196 | 244 |
197 | 245 |
198 static OrthancPluginErrorCode ReadAnswerChange(OrthancPluginDatabaseTransaction* transaction, | 246 static OrthancPluginErrorCode ReadAnswerChange(OrthancPluginDatabaseTransaction* transaction, |
199 OrthancPluginChange* target /* out */, | 247 OrthancPluginChange* target /* out */, |
200 uint32_t index) | 248 uint32_t index) |
201 { | 249 { |
202 const Output& that = *reinterpret_cast<const Output*>(transaction); | 250 const Output& that = *reinterpret_cast<const Output*>(transaction); |
203 | 251 |
204 if (index < that.changes_.size()) | 252 if (index < that.changes_.size()) |
205 { | 253 { |
565 SetupAnswerType(_OrthancPluginDatabaseAnswerType_String); | 613 SetupAnswerType(_OrthancPluginDatabaseAnswerType_String); |
566 | 614 |
567 stringAnswers_.reserve(values.size()); | 615 stringAnswers_.reserve(values.size()); |
568 std::copy(std::begin(values), std::end(values), std::back_inserter(stringAnswers_)); | 616 std::copy(std::begin(values), std::end(values), std::back_inserter(stringAnswers_)); |
569 } | 617 } |
618 | |
619 | |
620 void AnswerString(const std::string& value) | |
621 { | |
622 SetupAnswerType(_OrthancPluginDatabaseAnswerType_String); | |
623 | |
624 if (stringAnswers_.empty()) | |
625 { | |
626 stringAnswers_.push_back(value); | |
627 } | |
628 else | |
629 { | |
630 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
631 } | |
632 } | |
570 }; | 633 }; |
571 | 634 |
572 | 635 |
573 class Factory : public IDatabaseBackendOutput::IFactory | 636 class Factory : public IDatabaseBackendOutput::IFactory |
574 { | 637 { |
585 | 648 |
586 | 649 |
587 class Transaction : public boost::noncopyable | 650 class Transaction : public boost::noncopyable |
588 { | 651 { |
589 private: | 652 private: |
590 IDatabaseBackend& backend_; | 653 boost::mutex::scoped_lock lock_; // TODO - REMOVE |
591 std::unique_ptr<Output> output_; | 654 IDatabaseBackend& backend_; |
592 | 655 std::unique_ptr<Output> output_; |
656 | |
657 static boost::mutex& GetMutex() // TODO - REMOVE | |
658 { | |
659 static boost::mutex mutex_; | |
660 return mutex_; | |
661 } | |
662 | |
593 public: | 663 public: |
594 Transaction(IDatabaseBackend& backend) : | 664 Transaction(IDatabaseBackend& backend) : |
665 lock_(GetMutex()), | |
595 backend_(backend), | 666 backend_(backend), |
596 output_(new Output) | 667 output_(new Output) |
597 { | 668 { |
598 } | 669 } |
599 | 670 |
963 } | 1034 } |
964 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1035 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); |
965 } | 1036 } |
966 | 1037 |
967 | 1038 |
1039 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseTransaction* transaction, | |
1040 int64_t id) | |
1041 { | |
1042 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1043 | |
1044 try | |
1045 { | |
1046 t->GetOutput().Clear(); | |
1047 | |
1048 std::list<int64_t> values; | |
1049 t->GetBackend().GetChildrenInternalId(values, id); | |
1050 t->GetOutput().AnswerIntegers64(values); | |
1051 | |
1052 return OrthancPluginErrorCode_Success; | |
1053 } | |
1054 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1055 } | |
1056 | |
1057 | |
1058 static OrthancPluginErrorCode GetChildrenMetadata(OrthancPluginDatabaseTransaction* transaction, | |
1059 int64_t resourceId, | |
1060 int32_t metadata) | |
1061 { | |
1062 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1063 | |
1064 try | |
1065 { | |
1066 t->GetOutput().Clear(); | |
1067 | |
1068 std::list<std::string> values; | |
1069 t->GetBackend().GetChildrenMetadata(values, resourceId, metadata); | |
1070 t->GetOutput().AnswerStrings(values); | |
1071 | |
1072 return OrthancPluginErrorCode_Success; | |
1073 } | |
1074 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1075 } | |
1076 | |
1077 | |
1078 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseTransaction* transaction, | |
1079 int64_t id) | |
1080 { | |
1081 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1082 | |
1083 try | |
1084 { | |
1085 t->GetOutput().Clear(); | |
1086 | |
1087 std::list<std::string> values; | |
1088 t->GetBackend().GetChildrenPublicId(values, id); | |
1089 t->GetOutput().AnswerStrings(values); | |
1090 | |
1091 return OrthancPluginErrorCode_Success; | |
1092 } | |
1093 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1094 } | |
1095 | |
1096 | |
1097 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseTransaction* transaction, | |
1098 uint8_t* targetDone /* out */, | |
1099 int64_t since, | |
1100 uint32_t maxResults) | |
1101 { | |
1102 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1103 | |
1104 try | |
1105 { | |
1106 t->GetOutput().Clear(); | |
1107 | |
1108 bool done; | |
1109 t->GetBackend().GetExportedResources(t->GetOutput(), done, since, maxResults); | |
1110 *targetDone = (done ? 1 : 0); | |
1111 | |
1112 return OrthancPluginErrorCode_Success; | |
1113 } | |
1114 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1115 } | |
1116 | |
1117 | |
1118 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseTransaction* transaction) | |
1119 { | |
1120 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1121 | |
1122 try | |
1123 { | |
1124 t->GetOutput().Clear(); | |
1125 t->GetBackend().GetLastChange(t->GetOutput()); | |
1126 return OrthancPluginErrorCode_Success; | |
1127 } | |
1128 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1129 } | |
1130 | |
1131 | |
1132 static OrthancPluginErrorCode GetLastChangeIndex(OrthancPluginDatabaseTransaction* transaction, | |
1133 int64_t* target) | |
1134 { | |
1135 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1136 | |
1137 try | |
1138 { | |
1139 t->GetOutput().Clear(); | |
1140 *target = t->GetBackend().GetLastChangeIndex(); | |
1141 return OrthancPluginErrorCode_Success; | |
1142 } | |
1143 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1144 } | |
1145 | |
1146 | |
1147 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseTransaction* transaction) | |
1148 { | |
1149 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1150 | |
1151 try | |
1152 { | |
1153 t->GetOutput().Clear(); | |
1154 t->GetBackend().GetLastExportedResource(t->GetOutput()); | |
1155 return OrthancPluginErrorCode_Success; | |
1156 } | |
1157 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1158 } | |
1159 | |
1160 | |
1161 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseTransaction* transaction, | |
1162 int64_t id) | |
1163 { | |
1164 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1165 | |
1166 try | |
1167 { | |
1168 t->GetOutput().Clear(); | |
1169 t->GetBackend().GetMainDicomTags(t->GetOutput(), id); | |
1170 return OrthancPluginErrorCode_Success; | |
1171 } | |
1172 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1173 } | |
1174 | |
1175 | |
1176 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseTransaction* transaction, | |
1177 int64_t id) | |
1178 { | |
1179 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1180 | |
1181 try | |
1182 { | |
1183 t->GetOutput().Clear(); | |
1184 t->GetOutput().AnswerString(t->GetBackend().GetPublicId(id)); | |
1185 return OrthancPluginErrorCode_Success; | |
1186 } | |
1187 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1188 } | |
1189 | |
1190 | |
1191 static OrthancPluginErrorCode GetResourcesCount(OrthancPluginDatabaseTransaction* transaction, | |
1192 uint64_t* target /* out */, | |
1193 OrthancPluginResourceType resourceType) | |
1194 { | |
1195 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1196 | |
1197 try | |
1198 { | |
1199 t->GetOutput().Clear(); | |
1200 *target = t->GetBackend().GetResourcesCount(resourceType); | |
1201 return OrthancPluginErrorCode_Success; | |
1202 } | |
1203 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1204 } | |
1205 | |
1206 | |
1207 static OrthancPluginErrorCode GetResourceType(OrthancPluginDatabaseTransaction* transaction, | |
1208 OrthancPluginResourceType* target /* out */, | |
1209 uint64_t resourceId) | |
1210 { | |
1211 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1212 | |
1213 try | |
1214 { | |
1215 t->GetOutput().Clear(); | |
1216 *target = t->GetBackend().GetResourceType(resourceId); | |
1217 return OrthancPluginErrorCode_Success; | |
1218 } | |
1219 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1220 } | |
1221 | |
1222 | |
1223 static OrthancPluginErrorCode GetTotalCompressedSize(OrthancPluginDatabaseTransaction* transaction, | |
1224 uint64_t* target /* out */) | |
1225 { | |
1226 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1227 | |
1228 try | |
1229 { | |
1230 t->GetOutput().Clear(); | |
1231 *target = t->GetBackend().GetTotalCompressedSize(); | |
1232 return OrthancPluginErrorCode_Success; | |
1233 } | |
1234 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1235 } | |
1236 | |
1237 | |
1238 static OrthancPluginErrorCode GetTotalUncompressedSize(OrthancPluginDatabaseTransaction* transaction, | |
1239 uint64_t* target /* out */) | |
1240 { | |
1241 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1242 | |
1243 try | |
1244 { | |
1245 t->GetOutput().Clear(); | |
1246 *target = t->GetBackend().GetTotalUncompressedSize(); | |
1247 return OrthancPluginErrorCode_Success; | |
1248 } | |
1249 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1250 } | |
1251 | |
1252 | |
1253 static OrthancPluginErrorCode IsDiskSizeAbove(OrthancPluginDatabaseTransaction* transaction, | |
1254 uint8_t* target, | |
1255 uint64_t threshold) | |
1256 { | |
1257 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1258 | |
1259 try | |
1260 { | |
1261 t->GetOutput().Clear(); | |
1262 bool above = (t->GetBackend().GetTotalCompressedSize() >= threshold); | |
1263 *target = (above ? 1 : 0); | |
1264 return OrthancPluginErrorCode_Success; | |
1265 } | |
1266 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1267 } | |
1268 | |
1269 | |
1270 static OrthancPluginErrorCode IsExistingResource(OrthancPluginDatabaseTransaction* transaction, | |
1271 uint8_t* target, | |
1272 int64_t resourceId) | |
1273 { | |
1274 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1275 | |
1276 try | |
1277 { | |
1278 t->GetOutput().Clear(); | |
1279 bool exists = t->GetBackend().IsExistingResource(resourceId); | |
1280 *target = (exists ? 1 : 0); | |
1281 return OrthancPluginErrorCode_Success; | |
1282 } | |
1283 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1284 } | |
1285 | |
1286 | |
1287 static OrthancPluginErrorCode IsProtectedPatient(OrthancPluginDatabaseTransaction* transaction, | |
1288 uint8_t* target, | |
1289 int64_t resourceId) | |
1290 { | |
1291 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1292 | |
1293 try | |
1294 { | |
1295 t->GetOutput().Clear(); | |
1296 bool isProtected = t->GetBackend().IsProtectedPatient(resourceId); | |
1297 *target = (isProtected ? 1 : 0); | |
1298 return OrthancPluginErrorCode_Success; | |
1299 } | |
1300 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1301 } | |
1302 | |
1303 | |
1304 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseTransaction* transaction, | |
1305 int64_t resourceId) | |
1306 { | |
1307 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1308 | |
1309 try | |
1310 { | |
1311 t->GetOutput().Clear(); | |
1312 | |
1313 std::list<int32_t> values; | |
1314 t->GetBackend().ListAvailableAttachments(values, resourceId); | |
1315 t->GetOutput().AnswerIntegers32(values); | |
1316 return OrthancPluginErrorCode_Success; | |
1317 } | |
1318 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1319 } | |
1320 | |
1321 | |
1322 static OrthancPluginErrorCode LogChange(OrthancPluginDatabaseTransaction* transaction, | |
1323 int32_t changeType, | |
1324 int64_t resourceId, | |
1325 OrthancPluginResourceType resourceType, | |
1326 const char* date) | |
1327 { | |
1328 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1329 | |
1330 try | |
1331 { | |
1332 t->GetOutput().Clear(); | |
1333 t->GetBackend().LogChange(changeType, resourceId, resourceType, date); | |
1334 return OrthancPluginErrorCode_Success; | |
1335 } | |
1336 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1337 } | |
1338 | |
1339 | |
1340 static OrthancPluginErrorCode LogExportedResource(OrthancPluginDatabaseTransaction* transaction, | |
1341 OrthancPluginResourceType resourceType, | |
1342 const char* publicId, | |
1343 const char* modality, | |
1344 const char* date, | |
1345 const char* patientId, | |
1346 const char* studyInstanceUid, | |
1347 const char* seriesInstanceUid, | |
1348 const char* sopInstanceUid) | |
1349 { | |
1350 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1351 | |
1352 try | |
1353 { | |
1354 OrthancPluginExportedResource exported; | |
1355 exported.seq = 0; | |
1356 exported.resourceType = resourceType; | |
1357 exported.publicId = publicId; | |
1358 exported.modality = modality; | |
1359 exported.date = date; | |
1360 exported.patientId = patientId; | |
1361 exported.studyInstanceUid = studyInstanceUid; | |
1362 exported.seriesInstanceUid = seriesInstanceUid; | |
1363 exported.sopInstanceUid = sopInstanceUid; | |
1364 | |
1365 t->GetOutput().Clear(); | |
1366 t->GetBackend().LogExportedResource(exported); | |
1367 return OrthancPluginErrorCode_Success; | |
1368 } | |
1369 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1370 } | |
1371 | |
1372 | |
1373 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseTransaction* transaction, | |
1374 int64_t resourceId, | |
1375 int32_t contentType) | |
1376 { | |
1377 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1378 | |
1379 try | |
1380 { | |
1381 t->GetOutput().Clear(); | |
1382 t->GetBackend().LookupAttachment(t->GetOutput(), resourceId, contentType); | |
1383 return OrthancPluginErrorCode_Success; | |
1384 } | |
1385 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1386 } | |
1387 | |
1388 | |
1389 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseTransaction* transaction, | |
1390 int32_t property) | |
1391 { | |
1392 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1393 | |
1394 try | |
1395 { | |
1396 t->GetOutput().Clear(); | |
1397 | |
1398 std::string s; | |
1399 if (t->GetBackend().LookupGlobalProperty(s, property)) | |
1400 { | |
1401 t->GetOutput().AnswerString(s); | |
1402 } | |
1403 | |
1404 return OrthancPluginErrorCode_Success; | |
1405 } | |
1406 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1407 } | |
1408 | |
1409 | |
1410 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseTransaction* transaction, | |
1411 int64_t id, | |
1412 int32_t metadata) | |
1413 { | |
1414 Transaction* t = reinterpret_cast<Transaction*>(transaction); | |
1415 | |
1416 try | |
1417 { | |
1418 t->GetOutput().Clear(); | |
1419 | |
1420 std::string s; | |
1421 if (t->GetBackend().LookupMetadata(s, id, metadata)) | |
1422 { | |
1423 t->GetOutput().AnswerString(s); | |
1424 } | |
1425 | |
1426 return OrthancPluginErrorCode_Success; | |
1427 } | |
1428 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1429 } | |
1430 | |
968 | 1431 |
969 static void RegisterV3(IDatabaseBackend& database) | 1432 static void RegisterV3(IDatabaseBackend& database) |
970 { | 1433 { |
971 OrthancPluginDatabaseBackendV3 params; | 1434 OrthancPluginDatabaseBackendV3 params; |
972 memset(¶ms, 0, sizeof(params)); | 1435 memset(¶ms, 0, sizeof(params)); |
1005 params.deleteResource = DeleteResource; | 1468 params.deleteResource = DeleteResource; |
1006 params.getAllMetadata = GetAllMetadata; | 1469 params.getAllMetadata = GetAllMetadata; |
1007 params.getAllPublicIds = GetAllPublicIds; | 1470 params.getAllPublicIds = GetAllPublicIds; |
1008 params.getAllPublicIdsWithLimit = GetAllPublicIdsWithLimit; | 1471 params.getAllPublicIdsWithLimit = GetAllPublicIdsWithLimit; |
1009 params.getChanges = GetChanges; | 1472 params.getChanges = GetChanges; |
1473 params.getChildrenInternalId = GetChildrenInternalId; | |
1474 params.getChildrenMetadata = GetChildrenMetadata; | |
1475 params.getChildrenPublicId = GetChildrenPublicId; | |
1476 params.getExportedResources = GetExportedResources; | |
1477 params.getLastChange = GetLastChange; | |
1478 params.getLastChangeIndex = GetLastChangeIndex; | |
1479 params.getLastExportedResource = GetLastExportedResource; | |
1480 params.getMainDicomTags = GetMainDicomTags; | |
1481 params.getPublicId = GetPublicId; | |
1482 params.getResourcesCount = GetResourcesCount; | |
1483 params.getResourceType = GetResourceType; | |
1484 params.getTotalCompressedSize = GetTotalCompressedSize; | |
1485 params.getTotalUncompressedSize = GetTotalUncompressedSize; | |
1486 params.isDiskSizeAbove = IsDiskSizeAbove; | |
1487 params.isExistingResource = IsExistingResource; | |
1488 params.isProtectedPatient = IsProtectedPatient; | |
1489 params.listAvailableAttachments = ListAvailableAttachments; | |
1490 params.logChange = LogChange; | |
1491 params.logExportedResource = LogExportedResource; | |
1492 params.lookupAttachment = LookupAttachment; | |
1493 params.lookupGlobalProperty = LookupGlobalProperty; | |
1494 params.lookupMetadata = LookupMetadata; | |
1010 | 1495 |
1011 OrthancPluginContext* context = database.GetContext(); | 1496 OrthancPluginContext* context = database.GetContext(); |
1012 | 1497 |
1013 if (OrthancPluginRegisterDatabaseBackendV3(context, ¶ms, sizeof(params), &database) != OrthancPluginErrorCode_Success) | 1498 if (OrthancPluginRegisterDatabaseBackendV3(context, ¶ms, sizeof(params), &database) != OrthancPluginErrorCode_Success) |
1014 { | 1499 { |