Mercurial > hg > orthanc-databases
comparison Resources/Orthanc/Sdk-0.9.5/orthanc/OrthancCDatabasePlugin.h @ 0:7cea966b6829
initial commit
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Wed, 04 Jul 2018 08:16:29 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:7cea966b6829 |
---|---|
1 /** | |
2 * @ingroup CInterface | |
3 **/ | |
4 | |
5 /** | |
6 * Orthanc - A Lightweight, RESTful DICOM Store | |
7 * Copyright (C) 2012-2015 Sebastien Jodogne, Medical Physics | |
8 * Department, University Hospital of Liege, Belgium | |
9 * | |
10 * This program is free software: you can redistribute it and/or | |
11 * modify it under the terms of the GNU General Public License as | |
12 * published by the Free Software Foundation, either version 3 of the | |
13 * License, or (at your option) any later version. | |
14 * | |
15 * In addition, as a special exception, the copyright holders of this | |
16 * program give permission to link the code of its release with the | |
17 * OpenSSL project's "OpenSSL" library (or with modified versions of it | |
18 * that use the same license as the "OpenSSL" library), and distribute | |
19 * the linked executables. You must obey the GNU General Public License | |
20 * in all respects for all of the code used other than "OpenSSL". If you | |
21 * modify file(s) with this exception, you may extend this exception to | |
22 * your version of the file(s), but you are not obligated to do so. If | |
23 * you do not wish to do so, delete this exception statement from your | |
24 * version. If you delete this exception statement from all source files | |
25 * in the program, then also delete it here. | |
26 * | |
27 * This program is distributed in the hope that it will be useful, but | |
28 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
30 * General Public License for more details. | |
31 * | |
32 * You should have received a copy of the GNU General Public License | |
33 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
34 **/ | |
35 | |
36 | |
37 | |
38 #pragma once | |
39 | |
40 #include "OrthancCPlugin.h" | |
41 | |
42 | |
43 /** @{ */ | |
44 | |
45 #ifdef __cplusplus | |
46 extern "C" | |
47 { | |
48 #endif | |
49 | |
50 | |
51 /** | |
52 * Opaque structure that represents the context of a custom database engine. | |
53 * @ingroup Callbacks | |
54 **/ | |
55 typedef struct _OrthancPluginDatabaseContext_t OrthancPluginDatabaseContext; | |
56 | |
57 | |
58 /*<! @cond Doxygen_Suppress */ | |
59 typedef enum | |
60 { | |
61 _OrthancPluginDatabaseAnswerType_None = 0, | |
62 | |
63 /* Events */ | |
64 _OrthancPluginDatabaseAnswerType_DeletedAttachment = 1, | |
65 _OrthancPluginDatabaseAnswerType_DeletedResource = 2, | |
66 _OrthancPluginDatabaseAnswerType_RemainingAncestor = 3, | |
67 | |
68 /* Return value */ | |
69 _OrthancPluginDatabaseAnswerType_Attachment = 10, | |
70 _OrthancPluginDatabaseAnswerType_Change = 11, | |
71 _OrthancPluginDatabaseAnswerType_DicomTag = 12, | |
72 _OrthancPluginDatabaseAnswerType_ExportedResource = 13, | |
73 _OrthancPluginDatabaseAnswerType_Int32 = 14, | |
74 _OrthancPluginDatabaseAnswerType_Int64 = 15, | |
75 _OrthancPluginDatabaseAnswerType_Resource = 16, | |
76 _OrthancPluginDatabaseAnswerType_String = 17, | |
77 | |
78 _OrthancPluginDatabaseAnswerType_INTERNAL = 0x7fffffff | |
79 } _OrthancPluginDatabaseAnswerType; | |
80 | |
81 | |
82 typedef struct | |
83 { | |
84 const char* uuid; | |
85 int32_t contentType; | |
86 uint64_t uncompressedSize; | |
87 const char* uncompressedHash; | |
88 int32_t compressionType; | |
89 uint64_t compressedSize; | |
90 const char* compressedHash; | |
91 } OrthancPluginAttachment; | |
92 | |
93 typedef struct | |
94 { | |
95 uint16_t group; | |
96 uint16_t element; | |
97 const char* value; | |
98 } OrthancPluginDicomTag; | |
99 | |
100 typedef struct | |
101 { | |
102 int64_t seq; | |
103 int32_t changeType; | |
104 OrthancPluginResourceType resourceType; | |
105 const char* publicId; | |
106 const char* date; | |
107 } OrthancPluginChange; | |
108 | |
109 typedef struct | |
110 { | |
111 int64_t seq; | |
112 OrthancPluginResourceType resourceType; | |
113 const char* publicId; | |
114 const char* modality; | |
115 const char* date; | |
116 const char* patientId; | |
117 const char* studyInstanceUid; | |
118 const char* seriesInstanceUid; | |
119 const char* sopInstanceUid; | |
120 } OrthancPluginExportedResource; | |
121 | |
122 | |
123 typedef struct | |
124 { | |
125 OrthancPluginDatabaseContext* database; | |
126 _OrthancPluginDatabaseAnswerType type; | |
127 int32_t valueInt32; | |
128 uint32_t valueUint32; | |
129 int64_t valueInt64; | |
130 const char *valueString; | |
131 const void *valueGeneric; | |
132 } _OrthancPluginDatabaseAnswer; | |
133 | |
134 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerString( | |
135 OrthancPluginContext* context, | |
136 OrthancPluginDatabaseContext* database, | |
137 const char* value) | |
138 { | |
139 _OrthancPluginDatabaseAnswer params; | |
140 memset(¶ms, 0, sizeof(params)); | |
141 params.database = database; | |
142 params.type = _OrthancPluginDatabaseAnswerType_String; | |
143 params.valueString = value; | |
144 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
145 } | |
146 | |
147 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerChange( | |
148 OrthancPluginContext* context, | |
149 OrthancPluginDatabaseContext* database, | |
150 const OrthancPluginChange* change) | |
151 { | |
152 _OrthancPluginDatabaseAnswer params; | |
153 memset(¶ms, 0, sizeof(params)); | |
154 | |
155 params.database = database; | |
156 params.type = _OrthancPluginDatabaseAnswerType_Change; | |
157 params.valueUint32 = 0; | |
158 params.valueGeneric = change; | |
159 | |
160 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
161 } | |
162 | |
163 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerChangesDone( | |
164 OrthancPluginContext* context, | |
165 OrthancPluginDatabaseContext* database) | |
166 { | |
167 _OrthancPluginDatabaseAnswer params; | |
168 memset(¶ms, 0, sizeof(params)); | |
169 | |
170 params.database = database; | |
171 params.type = _OrthancPluginDatabaseAnswerType_Change; | |
172 params.valueUint32 = 1; | |
173 params.valueGeneric = NULL; | |
174 | |
175 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
176 } | |
177 | |
178 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerInt32( | |
179 OrthancPluginContext* context, | |
180 OrthancPluginDatabaseContext* database, | |
181 int32_t value) | |
182 { | |
183 _OrthancPluginDatabaseAnswer params; | |
184 memset(¶ms, 0, sizeof(params)); | |
185 params.database = database; | |
186 params.type = _OrthancPluginDatabaseAnswerType_Int32; | |
187 params.valueInt32 = value; | |
188 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
189 } | |
190 | |
191 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerInt64( | |
192 OrthancPluginContext* context, | |
193 OrthancPluginDatabaseContext* database, | |
194 int64_t value) | |
195 { | |
196 _OrthancPluginDatabaseAnswer params; | |
197 memset(¶ms, 0, sizeof(params)); | |
198 params.database = database; | |
199 params.type = _OrthancPluginDatabaseAnswerType_Int64; | |
200 params.valueInt64 = value; | |
201 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
202 } | |
203 | |
204 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerExportedResource( | |
205 OrthancPluginContext* context, | |
206 OrthancPluginDatabaseContext* database, | |
207 const OrthancPluginExportedResource* exported) | |
208 { | |
209 _OrthancPluginDatabaseAnswer params; | |
210 memset(¶ms, 0, sizeof(params)); | |
211 | |
212 params.database = database; | |
213 params.type = _OrthancPluginDatabaseAnswerType_ExportedResource; | |
214 params.valueUint32 = 0; | |
215 params.valueGeneric = exported; | |
216 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
217 } | |
218 | |
219 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerExportedResourcesDone( | |
220 OrthancPluginContext* context, | |
221 OrthancPluginDatabaseContext* database) | |
222 { | |
223 _OrthancPluginDatabaseAnswer params; | |
224 memset(¶ms, 0, sizeof(params)); | |
225 | |
226 params.database = database; | |
227 params.type = _OrthancPluginDatabaseAnswerType_ExportedResource; | |
228 params.valueUint32 = 1; | |
229 params.valueGeneric = NULL; | |
230 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
231 } | |
232 | |
233 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerDicomTag( | |
234 OrthancPluginContext* context, | |
235 OrthancPluginDatabaseContext* database, | |
236 const OrthancPluginDicomTag* tag) | |
237 { | |
238 _OrthancPluginDatabaseAnswer params; | |
239 memset(¶ms, 0, sizeof(params)); | |
240 params.database = database; | |
241 params.type = _OrthancPluginDatabaseAnswerType_DicomTag; | |
242 params.valueGeneric = tag; | |
243 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
244 } | |
245 | |
246 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerAttachment( | |
247 OrthancPluginContext* context, | |
248 OrthancPluginDatabaseContext* database, | |
249 const OrthancPluginAttachment* attachment) | |
250 { | |
251 _OrthancPluginDatabaseAnswer params; | |
252 memset(¶ms, 0, sizeof(params)); | |
253 params.database = database; | |
254 params.type = _OrthancPluginDatabaseAnswerType_Attachment; | |
255 params.valueGeneric = attachment; | |
256 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
257 } | |
258 | |
259 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerResource( | |
260 OrthancPluginContext* context, | |
261 OrthancPluginDatabaseContext* database, | |
262 int64_t id, | |
263 OrthancPluginResourceType resourceType) | |
264 { | |
265 _OrthancPluginDatabaseAnswer params; | |
266 memset(¶ms, 0, sizeof(params)); | |
267 params.database = database; | |
268 params.type = _OrthancPluginDatabaseAnswerType_Resource; | |
269 params.valueInt64 = id; | |
270 params.valueInt32 = (int32_t) resourceType; | |
271 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
272 } | |
273 | |
274 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseSignalDeletedAttachment( | |
275 OrthancPluginContext* context, | |
276 OrthancPluginDatabaseContext* database, | |
277 const OrthancPluginAttachment* attachment) | |
278 { | |
279 _OrthancPluginDatabaseAnswer params; | |
280 memset(¶ms, 0, sizeof(params)); | |
281 params.database = database; | |
282 params.type = _OrthancPluginDatabaseAnswerType_DeletedAttachment; | |
283 params.valueGeneric = attachment; | |
284 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
285 } | |
286 | |
287 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseSignalDeletedResource( | |
288 OrthancPluginContext* context, | |
289 OrthancPluginDatabaseContext* database, | |
290 const char* publicId, | |
291 OrthancPluginResourceType resourceType) | |
292 { | |
293 _OrthancPluginDatabaseAnswer params; | |
294 memset(¶ms, 0, sizeof(params)); | |
295 params.database = database; | |
296 params.type = _OrthancPluginDatabaseAnswerType_DeletedResource; | |
297 params.valueString = publicId; | |
298 params.valueInt32 = (int32_t) resourceType; | |
299 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
300 } | |
301 | |
302 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseSignalRemainingAncestor( | |
303 OrthancPluginContext* context, | |
304 OrthancPluginDatabaseContext* database, | |
305 const char* ancestorId, | |
306 OrthancPluginResourceType ancestorType) | |
307 { | |
308 _OrthancPluginDatabaseAnswer params; | |
309 memset(¶ms, 0, sizeof(params)); | |
310 params.database = database; | |
311 params.type = _OrthancPluginDatabaseAnswerType_RemainingAncestor; | |
312 params.valueString = ancestorId; | |
313 params.valueInt32 = (int32_t) ancestorType; | |
314 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms); | |
315 } | |
316 | |
317 | |
318 | |
319 | |
320 | |
321 typedef struct | |
322 { | |
323 OrthancPluginErrorCode (*addAttachment) ( | |
324 /* inputs */ | |
325 void* payload, | |
326 int64_t id, | |
327 const OrthancPluginAttachment* attachment); | |
328 | |
329 OrthancPluginErrorCode (*attachChild) ( | |
330 /* inputs */ | |
331 void* payload, | |
332 int64_t parent, | |
333 int64_t child); | |
334 | |
335 OrthancPluginErrorCode (*clearChanges) ( | |
336 /* inputs */ | |
337 void* payload); | |
338 | |
339 OrthancPluginErrorCode (*clearExportedResources) ( | |
340 /* inputs */ | |
341 void* payload); | |
342 | |
343 OrthancPluginErrorCode (*createResource) ( | |
344 /* outputs */ | |
345 int64_t* id, | |
346 /* inputs */ | |
347 void* payload, | |
348 const char* publicId, | |
349 OrthancPluginResourceType resourceType); | |
350 | |
351 OrthancPluginErrorCode (*deleteAttachment) ( | |
352 /* inputs */ | |
353 void* payload, | |
354 int64_t id, | |
355 int32_t contentType); | |
356 | |
357 OrthancPluginErrorCode (*deleteMetadata) ( | |
358 /* inputs */ | |
359 void* payload, | |
360 int64_t id, | |
361 int32_t metadataType); | |
362 | |
363 OrthancPluginErrorCode (*deleteResource) ( | |
364 /* inputs */ | |
365 void* payload, | |
366 int64_t id); | |
367 | |
368 /* Output: Use OrthancPluginDatabaseAnswerString() */ | |
369 OrthancPluginErrorCode (*getAllPublicIds) ( | |
370 /* outputs */ | |
371 OrthancPluginDatabaseContext* context, | |
372 /* inputs */ | |
373 void* payload, | |
374 OrthancPluginResourceType resourceType); | |
375 | |
376 /* Output: Use OrthancPluginDatabaseAnswerChange() and | |
377 * OrthancPluginDatabaseAnswerChangesDone() */ | |
378 OrthancPluginErrorCode (*getChanges) ( | |
379 /* outputs */ | |
380 OrthancPluginDatabaseContext* context, | |
381 /* inputs */ | |
382 void* payload, | |
383 int64_t since, | |
384 uint32_t maxResult); | |
385 | |
386 /* Output: Use OrthancPluginDatabaseAnswerInt64() */ | |
387 OrthancPluginErrorCode (*getChildrenInternalId) ( | |
388 /* outputs */ | |
389 OrthancPluginDatabaseContext* context, | |
390 /* inputs */ | |
391 void* payload, | |
392 int64_t id); | |
393 | |
394 /* Output: Use OrthancPluginDatabaseAnswerString() */ | |
395 OrthancPluginErrorCode (*getChildrenPublicId) ( | |
396 /* outputs */ | |
397 OrthancPluginDatabaseContext* context, | |
398 /* inputs */ | |
399 void* payload, | |
400 int64_t id); | |
401 | |
402 /* Output: Use OrthancPluginDatabaseAnswerExportedResource() and | |
403 * OrthancPluginDatabaseAnswerExportedResourcesDone() */ | |
404 OrthancPluginErrorCode (*getExportedResources) ( | |
405 /* outputs */ | |
406 OrthancPluginDatabaseContext* context, | |
407 /* inputs */ | |
408 void* payload, | |
409 int64_t since, | |
410 uint32_t maxResult); | |
411 | |
412 /* Output: Use OrthancPluginDatabaseAnswerChange() */ | |
413 OrthancPluginErrorCode (*getLastChange) ( | |
414 /* outputs */ | |
415 OrthancPluginDatabaseContext* context, | |
416 /* inputs */ | |
417 void* payload); | |
418 | |
419 /* Output: Use OrthancPluginDatabaseAnswerExportedResource() */ | |
420 OrthancPluginErrorCode (*getLastExportedResource) ( | |
421 /* outputs */ | |
422 OrthancPluginDatabaseContext* context, | |
423 /* inputs */ | |
424 void* payload); | |
425 | |
426 /* Output: Use OrthancPluginDatabaseAnswerDicomTag() */ | |
427 OrthancPluginErrorCode (*getMainDicomTags) ( | |
428 /* outputs */ | |
429 OrthancPluginDatabaseContext* context, | |
430 /* inputs */ | |
431 void* payload, | |
432 int64_t id); | |
433 | |
434 /* Output: Use OrthancPluginDatabaseAnswerString() */ | |
435 OrthancPluginErrorCode (*getPublicId) ( | |
436 /* outputs */ | |
437 OrthancPluginDatabaseContext* context, | |
438 /* inputs */ | |
439 void* payload, | |
440 int64_t id); | |
441 | |
442 OrthancPluginErrorCode (*getResourceCount) ( | |
443 /* outputs */ | |
444 uint64_t* target, | |
445 /* inputs */ | |
446 void* payload, | |
447 OrthancPluginResourceType resourceType); | |
448 | |
449 OrthancPluginErrorCode (*getResourceType) ( | |
450 /* outputs */ | |
451 OrthancPluginResourceType* resourceType, | |
452 /* inputs */ | |
453 void* payload, | |
454 int64_t id); | |
455 | |
456 OrthancPluginErrorCode (*getTotalCompressedSize) ( | |
457 /* outputs */ | |
458 uint64_t* target, | |
459 /* inputs */ | |
460 void* payload); | |
461 | |
462 OrthancPluginErrorCode (*getTotalUncompressedSize) ( | |
463 /* outputs */ | |
464 uint64_t* target, | |
465 /* inputs */ | |
466 void* payload); | |
467 | |
468 OrthancPluginErrorCode (*isExistingResource) ( | |
469 /* outputs */ | |
470 int32_t* existing, | |
471 /* inputs */ | |
472 void* payload, | |
473 int64_t id); | |
474 | |
475 OrthancPluginErrorCode (*isProtectedPatient) ( | |
476 /* outputs */ | |
477 int32_t* isProtected, | |
478 /* inputs */ | |
479 void* payload, | |
480 int64_t id); | |
481 | |
482 /* Output: Use OrthancPluginDatabaseAnswerInt32() */ | |
483 OrthancPluginErrorCode (*listAvailableMetadata) ( | |
484 /* outputs */ | |
485 OrthancPluginDatabaseContext* context, | |
486 /* inputs */ | |
487 void* payload, | |
488 int64_t id); | |
489 | |
490 /* Output: Use OrthancPluginDatabaseAnswerInt32() */ | |
491 OrthancPluginErrorCode (*listAvailableAttachments) ( | |
492 /* outputs */ | |
493 OrthancPluginDatabaseContext* context, | |
494 /* inputs */ | |
495 void* payload, | |
496 int64_t id); | |
497 | |
498 OrthancPluginErrorCode (*logChange) ( | |
499 /* inputs */ | |
500 void* payload, | |
501 const OrthancPluginChange* change); | |
502 | |
503 OrthancPluginErrorCode (*logExportedResource) ( | |
504 /* inputs */ | |
505 void* payload, | |
506 const OrthancPluginExportedResource* exported); | |
507 | |
508 /* Output: Use OrthancPluginDatabaseAnswerAttachment() */ | |
509 OrthancPluginErrorCode (*lookupAttachment) ( | |
510 /* outputs */ | |
511 OrthancPluginDatabaseContext* context, | |
512 /* inputs */ | |
513 void* payload, | |
514 int64_t id, | |
515 int32_t contentType); | |
516 | |
517 /* Output: Use OrthancPluginDatabaseAnswerString() */ | |
518 OrthancPluginErrorCode (*lookupGlobalProperty) ( | |
519 /* outputs */ | |
520 OrthancPluginDatabaseContext* context, | |
521 /* inputs */ | |
522 void* payload, | |
523 int32_t property); | |
524 | |
525 /* Use "OrthancPluginDatabaseExtensions::lookupIdentifier3" | |
526 instead of this function as of Orthanc 0.9.5 (db v6), can be set to NULL. | |
527 Output: Use OrthancPluginDatabaseAnswerInt64() */ | |
528 OrthancPluginErrorCode (*lookupIdentifier) ( | |
529 /* outputs */ | |
530 OrthancPluginDatabaseContext* context, | |
531 /* inputs */ | |
532 void* payload, | |
533 const OrthancPluginDicomTag* tag); | |
534 | |
535 /* Unused starting with Orthanc 0.9.5 (db v6), can be set to NULL. | |
536 Output: Use OrthancPluginDatabaseAnswerInt64() */ | |
537 OrthancPluginErrorCode (*lookupIdentifier2) ( | |
538 /* outputs */ | |
539 OrthancPluginDatabaseContext* context, | |
540 /* inputs */ | |
541 void* payload, | |
542 const char* value); | |
543 | |
544 /* Output: Use OrthancPluginDatabaseAnswerString() */ | |
545 OrthancPluginErrorCode (*lookupMetadata) ( | |
546 /* outputs */ | |
547 OrthancPluginDatabaseContext* context, | |
548 /* inputs */ | |
549 void* payload, | |
550 int64_t id, | |
551 int32_t metadata); | |
552 | |
553 /* Output: Use OrthancPluginDatabaseAnswerInt64() */ | |
554 OrthancPluginErrorCode (*lookupParent) ( | |
555 /* outputs */ | |
556 OrthancPluginDatabaseContext* context, | |
557 /* inputs */ | |
558 void* payload, | |
559 int64_t id); | |
560 | |
561 /* Output: Use OrthancPluginDatabaseAnswerResource() */ | |
562 OrthancPluginErrorCode (*lookupResource) ( | |
563 /* outputs */ | |
564 OrthancPluginDatabaseContext* context, | |
565 /* inputs */ | |
566 void* payload, | |
567 const char* publicId); | |
568 | |
569 /* Output: Use OrthancPluginDatabaseAnswerInt64() */ | |
570 OrthancPluginErrorCode (*selectPatientToRecycle) ( | |
571 /* outputs */ | |
572 OrthancPluginDatabaseContext* context, | |
573 /* inputs */ | |
574 void* payload); | |
575 | |
576 /* Output: Use OrthancPluginDatabaseAnswerInt64() */ | |
577 OrthancPluginErrorCode (*selectPatientToRecycle2) ( | |
578 /* outputs */ | |
579 OrthancPluginDatabaseContext* context, | |
580 /* inputs */ | |
581 void* payload, | |
582 int64_t patientIdToAvoid); | |
583 | |
584 OrthancPluginErrorCode (*setGlobalProperty) ( | |
585 /* inputs */ | |
586 void* payload, | |
587 int32_t property, | |
588 const char* value); | |
589 | |
590 OrthancPluginErrorCode (*setMainDicomTag) ( | |
591 /* inputs */ | |
592 void* payload, | |
593 int64_t id, | |
594 const OrthancPluginDicomTag* tag); | |
595 | |
596 OrthancPluginErrorCode (*setIdentifierTag) ( | |
597 /* inputs */ | |
598 void* payload, | |
599 int64_t id, | |
600 const OrthancPluginDicomTag* tag); | |
601 | |
602 OrthancPluginErrorCode (*setMetadata) ( | |
603 /* inputs */ | |
604 void* payload, | |
605 int64_t id, | |
606 int32_t metadata, | |
607 const char* value); | |
608 | |
609 OrthancPluginErrorCode (*setProtectedPatient) ( | |
610 /* inputs */ | |
611 void* payload, | |
612 int64_t id, | |
613 int32_t isProtected); | |
614 | |
615 OrthancPluginErrorCode (*startTransaction) ( | |
616 /* inputs */ | |
617 void* payload); | |
618 | |
619 OrthancPluginErrorCode (*rollbackTransaction) ( | |
620 /* inputs */ | |
621 void* payload); | |
622 | |
623 OrthancPluginErrorCode (*commitTransaction) ( | |
624 /* inputs */ | |
625 void* payload); | |
626 | |
627 OrthancPluginErrorCode (*open) ( | |
628 /* inputs */ | |
629 void* payload); | |
630 | |
631 OrthancPluginErrorCode (*close) ( | |
632 /* inputs */ | |
633 void* payload); | |
634 | |
635 } OrthancPluginDatabaseBackend; | |
636 | |
637 | |
638 typedef struct | |
639 { | |
640 /* Output: Use OrthancPluginDatabaseAnswerString() */ | |
641 OrthancPluginErrorCode (*getAllPublicIdsWithLimit) ( | |
642 /* outputs */ | |
643 OrthancPluginDatabaseContext* context, | |
644 /* inputs */ | |
645 void* payload, | |
646 OrthancPluginResourceType resourceType, | |
647 uint64_t since, | |
648 uint64_t limit); | |
649 | |
650 OrthancPluginErrorCode (*getDatabaseVersion) ( | |
651 /* outputs */ | |
652 uint32_t* version, | |
653 /* inputs */ | |
654 void* payload); | |
655 | |
656 OrthancPluginErrorCode (*upgradeDatabase) ( | |
657 /* inputs */ | |
658 void* payload, | |
659 uint32_t targetVersion, | |
660 OrthancPluginStorageArea* storageArea); | |
661 | |
662 OrthancPluginErrorCode (*clearMainDicomTags) ( | |
663 /* inputs */ | |
664 void* payload, | |
665 int64_t id); | |
666 | |
667 /* Output: Use OrthancPluginDatabaseAnswerInt64() */ | |
668 OrthancPluginErrorCode (*getAllInternalIds) ( | |
669 /* outputs */ | |
670 OrthancPluginDatabaseContext* context, | |
671 /* inputs */ | |
672 void* payload, | |
673 OrthancPluginResourceType resourceType); | |
674 | |
675 /* Output: Use OrthancPluginDatabaseAnswerInt64() */ | |
676 OrthancPluginErrorCode (*lookupIdentifier3) ( | |
677 /* outputs */ | |
678 OrthancPluginDatabaseContext* context, | |
679 /* inputs */ | |
680 void* payload, | |
681 OrthancPluginResourceType resourceType, | |
682 const OrthancPluginDicomTag* tag, | |
683 OrthancPluginIdentifierConstraint constraint); | |
684 } OrthancPluginDatabaseExtensions; | |
685 | |
686 /*<! @endcond */ | |
687 | |
688 | |
689 typedef struct | |
690 { | |
691 OrthancPluginDatabaseContext** result; | |
692 const OrthancPluginDatabaseBackend* backend; | |
693 void* payload; | |
694 } _OrthancPluginRegisterDatabaseBackend; | |
695 | |
696 /** | |
697 * Register a custom database back-end. | |
698 * | |
699 * Instead of manually filling the OrthancPluginDatabaseBackend | |
700 * structure, you should instead implement a concrete C++ class | |
701 * deriving from ::OrthancPlugins::IDatabaseBackend, and register it | |
702 * using ::OrthancPlugins::DatabaseBackendAdapter::Register(). | |
703 * | |
704 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). | |
705 * @param backend The callbacks of the custom database engine. | |
706 * @param payload Pointer containing private information for the database engine. | |
707 * @return The context of the database engine (it must not be manually freed). | |
708 * @ingroup Callbacks | |
709 * @deprecated | |
710 * @see OrthancPluginRegisterDatabaseBackendV2 | |
711 **/ | |
712 ORTHANC_PLUGIN_INLINE OrthancPluginDatabaseContext* OrthancPluginRegisterDatabaseBackend( | |
713 OrthancPluginContext* context, | |
714 const OrthancPluginDatabaseBackend* backend, | |
715 void* payload) | |
716 { | |
717 OrthancPluginDatabaseContext* result = NULL; | |
718 _OrthancPluginRegisterDatabaseBackend params; | |
719 | |
720 if (sizeof(int32_t) != sizeof(_OrthancPluginDatabaseAnswerType)) | |
721 { | |
722 return NULL; | |
723 } | |
724 | |
725 memset(¶ms, 0, sizeof(params)); | |
726 params.backend = backend; | |
727 params.result = &result; | |
728 params.payload = payload; | |
729 | |
730 if (context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackend, ¶ms) || | |
731 result == NULL) | |
732 { | |
733 /* Error */ | |
734 return NULL; | |
735 } | |
736 else | |
737 { | |
738 return result; | |
739 } | |
740 } | |
741 | |
742 | |
743 typedef struct | |
744 { | |
745 OrthancPluginDatabaseContext** result; | |
746 const OrthancPluginDatabaseBackend* backend; | |
747 void* payload; | |
748 const OrthancPluginDatabaseExtensions* extensions; | |
749 uint32_t extensionsSize; | |
750 } _OrthancPluginRegisterDatabaseBackendV2; | |
751 | |
752 | |
753 /** | |
754 * Register a custom database back-end. | |
755 * | |
756 * Instead of manually filling the OrthancPluginDatabaseBackendV2 | |
757 * structure, you should instead implement a concrete C++ class | |
758 * deriving from ::OrthancPlugins::IDatabaseBackend, and register it | |
759 * using ::OrthancPlugins::DatabaseBackendAdapter::Register(). | |
760 * | |
761 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). | |
762 * @param backend The callbacks of the custom database engine. | |
763 * @param payload Pointer containing private information for the database engine. | |
764 * @param extensions Extensions to the base database SDK that was shipped until Orthanc 0.9.3. | |
765 * @return The context of the database engine (it must not be manually freed). | |
766 * @ingroup Callbacks | |
767 **/ | |
768 ORTHANC_PLUGIN_INLINE OrthancPluginDatabaseContext* OrthancPluginRegisterDatabaseBackendV2( | |
769 OrthancPluginContext* context, | |
770 const OrthancPluginDatabaseBackend* backend, | |
771 const OrthancPluginDatabaseExtensions* extensions, | |
772 void* payload) | |
773 { | |
774 OrthancPluginDatabaseContext* result = NULL; | |
775 _OrthancPluginRegisterDatabaseBackendV2 params; | |
776 | |
777 if (sizeof(int32_t) != sizeof(_OrthancPluginDatabaseAnswerType)) | |
778 { | |
779 return NULL; | |
780 } | |
781 | |
782 memset(¶ms, 0, sizeof(params)); | |
783 params.backend = backend; | |
784 params.result = &result; | |
785 params.payload = payload; | |
786 params.extensions = extensions; | |
787 params.extensionsSize = sizeof(OrthancPluginDatabaseExtensions); | |
788 | |
789 if (context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV2, ¶ms) || | |
790 result == NULL) | |
791 { | |
792 /* Error */ | |
793 return NULL; | |
794 } | |
795 else | |
796 { | |
797 return result; | |
798 } | |
799 } | |
800 | |
801 | |
802 #ifdef __cplusplus | |
803 } | |
804 #endif | |
805 | |
806 | |
807 /** @} */ | |
808 |