Mercurial > hg > orthanc-databases

comparison Resources/Orthanc/Sdk-0.9.5/orthanc/OrthancCDatabasePlugin.h @ 0:7cea966b6829

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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(&params, 0, sizeof(params));
141 params.database = database;
142 params.type = _OrthancPluginDatabaseAnswerType_String;
143 params.valueString = value;
144 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, &params);
145 }
146
147 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerChange(
148 OrthancPluginContext* context,
149 OrthancPluginDatabaseContext* database,
150 const OrthancPluginChange* change)
151 {
152 _OrthancPluginDatabaseAnswer params;
153 memset(&params, 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, &params);
161 }
162
163 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerChangesDone(
164 OrthancPluginContext* context,
165 OrthancPluginDatabaseContext* database)
166 {
167 _OrthancPluginDatabaseAnswer params;
168 memset(&params, 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, &params);
176 }
177
178 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerInt32(
179 OrthancPluginContext* context,
180 OrthancPluginDatabaseContext* database,
181 int32_t value)
182 {
183 _OrthancPluginDatabaseAnswer params;
184 memset(&params, 0, sizeof(params));
185 params.database = database;
186 params.type = _OrthancPluginDatabaseAnswerType_Int32;
187 params.valueInt32 = value;
188 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, &params);
189 }
190
191 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerInt64(
192 OrthancPluginContext* context,
193 OrthancPluginDatabaseContext* database,
194 int64_t value)
195 {
196 _OrthancPluginDatabaseAnswer params;
197 memset(&params, 0, sizeof(params));
198 params.database = database;
199 params.type = _OrthancPluginDatabaseAnswerType_Int64;
200 params.valueInt64 = value;
201 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, &params);
202 }
203
204 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerExportedResource(
205 OrthancPluginContext* context,
206 OrthancPluginDatabaseContext* database,
207 const OrthancPluginExportedResource* exported)
208 {
209 _OrthancPluginDatabaseAnswer params;
210 memset(&params, 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, &params);
217 }
218
219 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerExportedResourcesDone(
220 OrthancPluginContext* context,
221 OrthancPluginDatabaseContext* database)
222 {
223 _OrthancPluginDatabaseAnswer params;
224 memset(&params, 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, &params);
231 }
232
233 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerDicomTag(
234 OrthancPluginContext* context,
235 OrthancPluginDatabaseContext* database,
236 const OrthancPluginDicomTag* tag)
237 {
238 _OrthancPluginDatabaseAnswer params;
239 memset(&params, 0, sizeof(params));
240 params.database = database;
241 params.type = _OrthancPluginDatabaseAnswerType_DicomTag;
242 params.valueGeneric = tag;
243 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, &params);
244 }
245
246 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseAnswerAttachment(
247 OrthancPluginContext* context,
248 OrthancPluginDatabaseContext* database,
249 const OrthancPluginAttachment* attachment)
250 {
251 _OrthancPluginDatabaseAnswer params;
252 memset(&params, 0, sizeof(params));
253 params.database = database;
254 params.type = _OrthancPluginDatabaseAnswerType_Attachment;
255 params.valueGeneric = attachment;
256 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, &params);
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(&params, 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, &params);
272 }
273
274 ORTHANC_PLUGIN_INLINE void OrthancPluginDatabaseSignalDeletedAttachment(
275 OrthancPluginContext* context,
276 OrthancPluginDatabaseContext* database,
277 const OrthancPluginAttachment* attachment)
278 {
279 _OrthancPluginDatabaseAnswer params;
280 memset(&params, 0, sizeof(params));
281 params.database = database;
282 params.type = _OrthancPluginDatabaseAnswerType_DeletedAttachment;
283 params.valueGeneric = attachment;
284 context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, &params);
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(&params, 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, &params);
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(&params, 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, &params);
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(&params, 0, sizeof(params));
726 params.backend = backend;
727 params.result = &result;
728 params.payload = payload;
729
730 if (context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackend, &params) ||
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(&params, 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, &params) ||
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