30#include "OrthancCPlugin.h" 
   59    _OrthancPluginDatabaseAnswerType_None = 0,
 
   62    _OrthancPluginDatabaseAnswerType_DeletedAttachment = 1,
 
   63    _OrthancPluginDatabaseAnswerType_DeletedResource = 2,
 
   64    _OrthancPluginDatabaseAnswerType_RemainingAncestor = 3,
 
   67    _OrthancPluginDatabaseAnswerType_Attachment = 10,
 
   68    _OrthancPluginDatabaseAnswerType_Change = 11,
 
   69    _OrthancPluginDatabaseAnswerType_DicomTag = 12,
 
   70    _OrthancPluginDatabaseAnswerType_ExportedResource = 13,
 
   71    _OrthancPluginDatabaseAnswerType_Int32 = 14,
 
   72    _OrthancPluginDatabaseAnswerType_Int64 = 15,
 
   73    _OrthancPluginDatabaseAnswerType_Resource = 16,
 
   74    _OrthancPluginDatabaseAnswerType_String = 17,
 
   75    _OrthancPluginDatabaseAnswerType_MatchingResource = 18,  
 
   76    _OrthancPluginDatabaseAnswerType_Metadata = 19,          
 
   78    _OrthancPluginDatabaseAnswerType_INTERNAL = 0x7fffffff
 
   79  } _OrthancPluginDatabaseAnswerType;
 
   86    uint64_t    uncompressedSize;
 
   87    const char* uncompressedHash;
 
   88    int32_t     compressionType;
 
   89    uint64_t    compressedSize;
 
   90    const char* compressedHash;
 
   91  } OrthancPluginAttachment;
 
   98  } OrthancPluginDicomTag;
 
  105    const char*                publicId;
 
  107  } OrthancPluginChange;
 
  113    const char*                publicId;
 
  114    const char*                modality;
 
  116    const char*                patientId;
 
  117    const char*                studyInstanceUid;
 
  118    const char*                seriesInstanceUid;
 
  119    const char*                sopInstanceUid;
 
  120  } OrthancPluginExportedResource;
 
  127    uint8_t                      isIdentifierTag;
 
  128    uint8_t                      isCaseSensitive;
 
  131    uint32_t                     valuesCount;
 
  132    const char* 
const*           values;
 
  133  } OrthancPluginDatabaseConstraint;
 
  137    const char*  resourceId;
 
  138    const char*  someInstanceId;  
 
  139  } OrthancPluginMatchingResource;
 
  144    uint8_t  isNewInstance;
 
  148    uint8_t  isNewPatient;
 
  154  } OrthancPluginCreateInstanceResult;
 
  162  } OrthancPluginResourcesContentTags;
 
  169  } OrthancPluginResourcesContentMetadata;
 
  175    _OrthancPluginDatabaseAnswerType  type;
 
  177    uint32_t     valueUint32;
 
  179    const char  *valueString;
 
  180    const void  *valueGeneric;
 
  181  } _OrthancPluginDatabaseAnswer;
 
  183  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerString(
 
  188    _OrthancPluginDatabaseAnswer params;
 
  189    memset(¶ms, 0, 
sizeof(params));
 
  190    params.database = database;
 
  191    params.type = _OrthancPluginDatabaseAnswerType_String;
 
  192    params.valueString = value;
 
  193    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  196  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerChange(
 
  199    const OrthancPluginChange*     change)
 
  201    _OrthancPluginDatabaseAnswer params;
 
  202    memset(¶ms, 0, 
sizeof(params));
 
  204    params.database = database;
 
  205    params.type = _OrthancPluginDatabaseAnswerType_Change;
 
  206    params.valueUint32 = 0;
 
  207    params.valueGeneric = change;
 
  209    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  212  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerChangesDone(
 
  216    _OrthancPluginDatabaseAnswer params;
 
  217    memset(¶ms, 0, 
sizeof(params));
 
  219    params.database = database;
 
  220    params.type = _OrthancPluginDatabaseAnswerType_Change;
 
  221    params.valueUint32 = 1;
 
  222    params.valueGeneric = NULL;
 
  224    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  227  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerInt32(
 
  232    _OrthancPluginDatabaseAnswer params;
 
  233    memset(¶ms, 0, 
sizeof(params));
 
  234    params.database = database;
 
  235    params.type = _OrthancPluginDatabaseAnswerType_Int32;
 
  236    params.valueInt32 = value;
 
  237    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  240  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerInt64(
 
  245    _OrthancPluginDatabaseAnswer params;
 
  246    memset(¶ms, 0, 
sizeof(params));
 
  247    params.database = database;
 
  248    params.type = _OrthancPluginDatabaseAnswerType_Int64;
 
  249    params.valueInt64 = value;
 
  250    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  253  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerExportedResource(
 
  256    const OrthancPluginExportedResource*  exported)
 
  258    _OrthancPluginDatabaseAnswer params;
 
  259    memset(¶ms, 0, 
sizeof(params));
 
  261    params.database = database;
 
  262    params.type = _OrthancPluginDatabaseAnswerType_ExportedResource;
 
  263    params.valueUint32 = 0;
 
  264    params.valueGeneric = exported;
 
  265    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  268  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerExportedResourcesDone(
 
  272    _OrthancPluginDatabaseAnswer params;
 
  273    memset(¶ms, 0, 
sizeof(params));
 
  275    params.database = database;
 
  276    params.type = _OrthancPluginDatabaseAnswerType_ExportedResource;
 
  277    params.valueUint32 = 1;
 
  278    params.valueGeneric = NULL;
 
  279    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  282  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerDicomTag(
 
  285    const OrthancPluginDicomTag*   tag)
 
  287    _OrthancPluginDatabaseAnswer params;
 
  288    memset(¶ms, 0, 
sizeof(params));
 
  289    params.database = database;
 
  290    params.type = _OrthancPluginDatabaseAnswerType_DicomTag;
 
  291    params.valueGeneric = tag;
 
  292    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  295  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerAttachment(
 
  298    const OrthancPluginAttachment* attachment)
 
  300    _OrthancPluginDatabaseAnswer params;
 
  301    memset(¶ms, 0, 
sizeof(params));
 
  302    params.database = database;
 
  303    params.type = _OrthancPluginDatabaseAnswerType_Attachment;
 
  304    params.valueGeneric = attachment;
 
  305    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  308  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerResource(
 
  314    _OrthancPluginDatabaseAnswer params;
 
  315    memset(¶ms, 0, 
sizeof(params));
 
  316    params.database = database;
 
  317    params.type = _OrthancPluginDatabaseAnswerType_Resource;
 
  318    params.valueInt64 = id;
 
  319    params.valueInt32 = (int32_t) resourceType;
 
  320    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  323  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerMatchingResource(
 
  326    const OrthancPluginMatchingResource*  match)
 
  328    _OrthancPluginDatabaseAnswer params;
 
  329    memset(¶ms, 0, 
sizeof(params));
 
  330    params.database = database;
 
  331    params.type = _OrthancPluginDatabaseAnswerType_MatchingResource;
 
  332    params.valueGeneric = match;
 
  333    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  336  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseAnswerMetadata(
 
  343    OrthancPluginResourcesContentMetadata metadata;
 
  344    _OrthancPluginDatabaseAnswer params;
 
  345    metadata.resource = resourceId;
 
  346    metadata.metadata = type;
 
  347    metadata.value = value;
 
  348    memset(¶ms, 0, 
sizeof(params));
 
  349    params.database = database;
 
  350    params.type = _OrthancPluginDatabaseAnswerType_Metadata;
 
  351    params.valueGeneric = &metadata;
 
  352    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  355  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseSignalDeletedAttachment(
 
  358    const OrthancPluginAttachment* attachment)
 
  360    _OrthancPluginDatabaseAnswer params;
 
  361    memset(¶ms, 0, 
sizeof(params));
 
  362    params.database = database;
 
  363    params.type = _OrthancPluginDatabaseAnswerType_DeletedAttachment;
 
  364    params.valueGeneric = attachment;
 
  365    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  368  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseSignalDeletedResource(
 
  371    const char*                    publicId,
 
  374    _OrthancPluginDatabaseAnswer params;
 
  375    memset(¶ms, 0, 
sizeof(params));
 
  376    params.database = database;
 
  377    params.type = _OrthancPluginDatabaseAnswerType_DeletedResource;
 
  378    params.valueString = publicId;
 
  379    params.valueInt32 = (int32_t) resourceType;
 
  380    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  383  ORTHANC_PLUGIN_INLINE 
void OrthancPluginDatabaseSignalRemainingAncestor(
 
  386    const char*                    ancestorId,
 
  389    _OrthancPluginDatabaseAnswer params;
 
  390    memset(¶ms, 0, 
sizeof(params));
 
  391    params.database = database;
 
  392    params.type = _OrthancPluginDatabaseAnswerType_RemainingAncestor;
 
  393    params.valueString = ancestorId;
 
  394    params.valueInt32 = (int32_t) ancestorType;
 
  395    context->InvokeService(context, _OrthancPluginService_DatabaseAnswer, ¶ms);
 
  408      const OrthancPluginAttachment* attachment);
 
  429      const char* publicId,
 
  436      int32_t contentType);
 
  442      int32_t metadataType);
 
  558      int32_t* isProtected,
 
  582      const OrthancPluginChange* change);
 
  587      const OrthancPluginExportedResource* exported);
 
  596      int32_t contentType);
 
  614      const OrthancPluginDicomTag* tag);
 
  648      const char* publicId);
 
  663      int64_t patientIdToAvoid);
 
  675      const OrthancPluginDicomTag* tag);
 
  681      const OrthancPluginDicomTag* tag);
 
  694      int32_t isProtected);
 
  716  } OrthancPluginDatabaseBackend;
 
  744      uint32_t targetVersion,
 
  767      const OrthancPluginDicomTag* tag,
 
  798      uint32_t constraintsCount,
 
  799      const OrthancPluginDatabaseConstraint* constraints,
 
  802      uint8_t requestSomeInstance);
 
  806      OrthancPluginCreateInstanceResult* output,
 
  809      const char* hashPatient,
 
  810      const char* hashStudy,
 
  811      const char* hashSeries,
 
  812      const char* hashInstance);
 
  817      uint32_t countIdentifierTags,
 
  818      const OrthancPluginResourcesContentTags* identifierTags,
 
  819      uint32_t countMainDicomTags,
 
  820      const OrthancPluginResourcesContentTags* mainDicomTags,
 
  821      uint32_t countMetadata,
 
  822      const OrthancPluginResourcesContentMetadata* metadata);
 
  868      const char* publicId);
 
  870  } OrthancPluginDatabaseExtensions;
 
  878    const OrthancPluginDatabaseBackend*  backend;
 
  880  } _OrthancPluginRegisterDatabaseBackend;
 
  895    const OrthancPluginDatabaseBackend*  backend,
 
  899    _OrthancPluginRegisterDatabaseBackend params;
 
  901    if (
sizeof(int32_t) != 
sizeof(_OrthancPluginDatabaseAnswerType))
 
  906    memset(¶ms, 0, 
sizeof(params));
 
  907    params.backend = backend;
 
  908    params.result = &result;
 
  909    params.payload = payload;
 
  911    if (context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackend, ¶ms) ||
 
 
  927    const OrthancPluginDatabaseBackend*     backend;
 
  929    const OrthancPluginDatabaseExtensions*  extensions;
 
  930    uint32_t                                extensionsSize;
 
  931  } _OrthancPluginRegisterDatabaseBackendV2;
 
  946    const OrthancPluginDatabaseBackend*     backend,
 
  947    const OrthancPluginDatabaseExtensions*  extensions,
 
  951    _OrthancPluginRegisterDatabaseBackendV2 params;
 
  953    if (
sizeof(int32_t) != 
sizeof(_OrthancPluginDatabaseAnswerType))
 
  958    memset(¶ms, 0, 
sizeof(params));
 
  959    params.backend = backend;
 
  960    params.result = &result;
 
  961    params.payload = payload;
 
  962    params.extensions = extensions;
 
  963    params.extensionsSize = 
sizeof(OrthancPluginDatabaseExtensions);
 
  965    if (context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV2, ¶ms) ||
 
 
  986    OrthancPluginDatabaseTransactionType_ReadOnly = 1,
 
  987    OrthancPluginDatabaseTransactionType_ReadWrite = 2,
 
  988    OrthancPluginDatabaseTransactionType_INTERNAL = 0x7fffffff
 
  989  } OrthancPluginDatabaseTransactionType;
 
  994    OrthancPluginDatabaseEventType_DeletedAttachment = 1,
 
  995    OrthancPluginDatabaseEventType_DeletedResource = 2,
 
  996    OrthancPluginDatabaseEventType_RemainingAncestor = 3,
 
  997    OrthancPluginDatabaseEventType_INTERNAL = 0x7fffffff
 
  998  } OrthancPluginDatabaseEventType;
 
 1003    OrthancPluginDatabaseEventType type;
 
 1011        const char*                publicId;
 
 1015      OrthancPluginAttachment  attachment;
 
 1019  } OrthancPluginDatabaseEvent;
 
 1032                                                    OrthancPluginAttachment* target ,
 
 1036                                                OrthancPluginChange* target ,
 
 1046                                                          OrthancPluginExportedResource* target ,
 
 1058                                                          OrthancPluginMatchingResource* target ,
 
 1063                                                  const char** value ,
 
 1067                                                const char** target ,
 
 1074                                         OrthancPluginDatabaseEvent* 
event ,
 
 1098                                               uint32_t targetVersion);
 
 1102                                                OrthancPluginDatabaseTransactionType type);
 
 1115                                      int64_t fileSizeDelta);
 
 1120                                             const OrthancPluginAttachment* attachment,
 
 1128                                                  int64_t resourceId);
 
 1131                                              OrthancPluginCreateInstanceResult* target ,
 
 1132                                              const char* hashPatient,
 
 1133                                              const char* hashStudy,
 
 1134                                              const char* hashSeries,
 
 1135                                              const char* hashInstance);
 
 1139                                                int32_t contentType);
 
 1143                                              int32_t metadataType);
 
 1164                                          uint8_t* targetDone ,
 
 1166                                          uint32_t maxResults);
 
 1183                                                    uint8_t* targetDone ,
 
 1185                                                    uint32_t maxResults);
 
 1202                                           int64_t internalId);
 
 1210                                               uint64_t resourceId);
 
 1220                                               uint64_t threshold);
 
 1224                                                  int64_t resourceId);
 
 1228                                                  int64_t resourceId);
 
 1232                                                        int64_t internalId);
 
 1242                                                   const char* publicId,
 
 1243                                                   const char* modality,
 
 1245                                                   const char* patientId,
 
 1246                                                   const char* studyInstanceUid,
 
 1247                                                   const char* seriesInstanceUid,
 
 1248                                                   const char* sopInstanceUid);
 
 1254                                                int32_t contentType);
 
 1258                                                    const char* serverIdentifier,
 
 1268                                            uint8_t* isExisting ,
 
 1273                                              uint8_t* isExisting ,
 
 1276                                              const char* publicId);
 
 1280                                                uint32_t constraintsCount,
 
 1281                                                const OrthancPluginDatabaseConstraint* constraints,
 
 1284                                                uint8_t requestSomeInstanceId);
 
 1288                                                       uint8_t* isExisting ,
 
 1291                                                       const char* publicId);
 
 1294                                                      uint8_t* patientAvailable ,
 
 1295                                                      int64_t* patientId );
 
 1298                                                       uint8_t* patientAvailable ,
 
 1299                                                       int64_t* patientId ,
 
 1300                                                       int64_t patientIdToAvoid);
 
 1303                                                 const char* serverIdentifier,
 
 1316                                                   uint8_t isProtected);
 
 1319                                                    uint32_t countIdentifierTags,
 
 1320                                                    const OrthancPluginResourcesContentTags* identifierTags,
 
 1321                                                    uint32_t countMainDicomTags,
 
 1322                                                    const OrthancPluginResourcesContentTags* mainDicomTags,
 
 1323                                                    uint32_t countMetadata,
 
 1324                                                    const OrthancPluginResourcesContentMetadata* metadata);
 
 1327  } OrthancPluginDatabaseBackendV3;
 
 1334    const OrthancPluginDatabaseBackendV3*  backend;
 
 1335    uint32_t                               backendSize;
 
 1336    uint32_t                               maxDatabaseRetries;
 
 1338  } _OrthancPluginRegisterDatabaseBackendV3;
 
 1343    const OrthancPluginDatabaseBackendV3*  backend,
 
 1344    uint32_t                               backendSize,
 
 1345    uint32_t                               maxDatabaseRetries,  
 
 1348    _OrthancPluginRegisterDatabaseBackendV3 params;
 
 1350    if (
sizeof(int32_t) != 
sizeof(_OrthancPluginDatabaseAnswerType))
 
 1355    memset(¶ms, 0, 
sizeof(params));
 
 1356    params.backend = backend;
 
 1357    params.backendSize = 
sizeof(OrthancPluginDatabaseBackendV3);
 
 1358    params.maxDatabaseRetries = maxDatabaseRetries;
 
 1359    params.database = database;
 
 1361    return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV3, ¶ms);
 
struct _OrthancPluginDatabaseTransaction_t OrthancPluginDatabaseTransaction
Definition OrthancCDatabasePlugin.h:53
OrthancPluginDatabaseContext * OrthancPluginRegisterDatabaseBackendV2(OrthancPluginContext *context, const OrthancPluginDatabaseBackend *backend, const OrthancPluginDatabaseExtensions *extensions, void *payload)
Definition OrthancCDatabasePlugin.h:944
struct _OrthancPluginDatabaseContext_t OrthancPluginDatabaseContext
Definition OrthancCDatabasePlugin.h:45
OrthancPluginDatabaseContext * OrthancPluginRegisterDatabaseBackend(OrthancPluginContext *context, const OrthancPluginDatabaseBackend *backend, void *payload)
Definition OrthancCDatabasePlugin.h:893
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition OrthancCPlugin.h:1097