Orthanc Plugin SDK
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
79 #pragma once
80 
81 
82 #include <stdio.h>
83 #include <string.h>
84 
85 #ifdef WIN32
86 #define ORTHANC_PLUGINS_API __declspec(dllexport)
87 #else
88 #define ORTHANC_PLUGINS_API
89 #endif
90 
91 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 0
92 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 9
93 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 1
94 
95 
96 
97 /********************************************************************
98  ** Check that function inlining is properly supported. The use of
99  ** inlining is required, to avoid the duplication of object code
100  ** between two compilation modules that would use the Orthanc Plugin
101  ** API.
102  ********************************************************************/
103 
104 /* If the auto-detection of the "inline" keyword below does not work
105  automatically and that your compiler is known to properly support
106  inlining, uncomment the following #define and adapt the definition
107  of "static inline". */
108 
109 /* #define ORTHANC_PLUGIN_INLINE static inline */
110 
111 #ifndef ORTHANC_PLUGIN_INLINE
112 # if __STDC_VERSION__ >= 199901L
113 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
114 # define ORTHANC_PLUGIN_INLINE static inline
115 # elif defined(__cplusplus)
116 /* This is C++ */
117 # define ORTHANC_PLUGIN_INLINE static inline
118 # elif defined(__GNUC__)
119 /* This is GCC running in C89 mode */
120 # define ORTHANC_PLUGIN_INLINE static __inline
121 # elif defined(_MSC_VER)
122 /* This is Visual Studio running in C89 mode */
123 # define ORTHANC_PLUGIN_INLINE static __inline
124 # else
125 # error Your compiler is not known to support the "inline" keyword
126 # endif
127 #endif
128 
129 
130 
131 /********************************************************************
132  ** Inclusion of standard libraries.
133  ********************************************************************/
134 
140 #include <stdint.h>
141 
142 #include <stdlib.h>
143 
144 
145 
146 /********************************************************************
147  ** Definition of the Orthanc Plugin API.
148  ********************************************************************/
149 
152 #ifdef __cplusplus
153 extern "C"
154 {
155 #endif
156 
161  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
162 
163 
167  typedef enum
168  {
174 
175 
179  typedef struct
180  {
185 
189  uint32_t groupsCount;
190 
194  const char* const* groups;
195 
199  uint32_t getCount;
200 
204  const char* const* getKeys;
205 
209  const char* const* getValues;
210 
214  const char* body;
215 
219  uint32_t bodySize;
220 
221 
222  /* --------------------------------------------------
223  New in version 0.8.1
224  -------------------------------------------------- */
225 
229  uint32_t headersCount;
230 
234  const char* const* headersKeys;
235 
239  const char* const* headersValues;
240 
242 
243 
244  typedef enum
245  {
246  /* Generic services */
247  _OrthancPluginService_LogInfo = 1,
248  _OrthancPluginService_LogWarning = 2,
249  _OrthancPluginService_LogError = 3,
250  _OrthancPluginService_GetOrthancPath = 4,
251  _OrthancPluginService_GetOrthancDirectory = 5,
252  _OrthancPluginService_GetConfigurationPath = 6,
253  _OrthancPluginService_SetPluginProperty = 7,
254  _OrthancPluginService_GetGlobalProperty = 8,
255  _OrthancPluginService_SetGlobalProperty = 9,
256  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
257  _OrthancPluginService_GetCommandLineArgument = 11,
258  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
259  _OrthancPluginService_GetConfiguration = 13,
260 
261  /* Registration of callbacks */
262  _OrthancPluginService_RegisterRestCallback = 1000,
263  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
264  _OrthancPluginService_RegisterStorageArea = 1002,
265  _OrthancPluginService_RegisterOnChangeCallback = 1003,
266 
267  /* Sending answers to REST calls */
268  _OrthancPluginService_AnswerBuffer = 2000,
269  _OrthancPluginService_CompressAndAnswerPngImage = 2001,
270  _OrthancPluginService_Redirect = 2002,
271  _OrthancPluginService_SendHttpStatusCode = 2003,
272  _OrthancPluginService_SendUnauthorized = 2004,
273  _OrthancPluginService_SendMethodNotAllowed = 2005,
274  _OrthancPluginService_SetCookie = 2006,
275  _OrthancPluginService_SetHttpHeader = 2007,
276  _OrthancPluginService_StartMultipartAnswer = 2008,
277  _OrthancPluginService_SendMultipartItem = 2009,
278 
279  /* Access to the Orthanc database and API */
280  _OrthancPluginService_GetDicomForInstance = 3000,
281  _OrthancPluginService_RestApiGet = 3001,
282  _OrthancPluginService_RestApiPost = 3002,
283  _OrthancPluginService_RestApiDelete = 3003,
284  _OrthancPluginService_RestApiPut = 3004,
285  _OrthancPluginService_LookupPatient = 3005,
286  _OrthancPluginService_LookupStudy = 3006,
287  _OrthancPluginService_LookupSeries = 3007,
288  _OrthancPluginService_LookupInstance = 3008,
289  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
290  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
291  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
292  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
293  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
294 
295  /* Access to DICOM instances */
296  _OrthancPluginService_GetInstanceRemoteAet = 4000,
297  _OrthancPluginService_GetInstanceSize = 4001,
298  _OrthancPluginService_GetInstanceData = 4002,
299  _OrthancPluginService_GetInstanceJson = 4003,
300  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
301  _OrthancPluginService_HasInstanceMetadata = 4005,
302  _OrthancPluginService_GetInstanceMetadata = 4006,
303 
304  /* Services for plugins implementing a database back-end */
305  _OrthancPluginService_RegisterDatabaseBackend = 5000,
306  _OrthancPluginService_DatabaseAnswer = 5001
307 
308  } _OrthancPluginService;
309 
310 
311  typedef enum
312  {
313  _OrthancPluginProperty_Description = 1,
314  _OrthancPluginProperty_RootUri = 2,
315  _OrthancPluginProperty_OrthancExplorer = 3
316  } _OrthancPluginProperty;
317 
318 
319 
323  typedef enum
324  {
332 
340 
348 
356 
365 
366 
367 
371  typedef enum
372  {
377 
378 
379 
383  typedef enum
384  {
390 
391 
392 
396  typedef enum
397  {
409 
410 
411 
419  typedef struct
420  {
424  void* data;
425 
429  uint32_t size;
431 
432 
433 
434 
438  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
439 
440 
441 
445  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
446 
447 
448 
452  typedef int32_t (*OrthancPluginRestCallback) (
453  OrthancPluginRestOutput* output,
454  const char* url,
455  const OrthancPluginHttpRequest* request);
456 
457 
458 
463  OrthancPluginDicomInstance* instance,
464  const char* instanceId);
465 
466 
467 
471  typedef int32_t (*OrthancPluginOnChangeCallback) (
472  OrthancPluginChangeType changeType,
473  OrthancPluginResourceType resourceType,
474  const char* resourceId);
475 
476 
477 
481  typedef void (*OrthancPluginFree) (void* buffer);
482 
483 
484 
496  typedef int32_t (*OrthancPluginStorageCreate) (
497  const char* uuid,
498  const void* content,
499  int64_t size,
501 
502 
503 
515  typedef int32_t (*OrthancPluginStorageRead) (
516  void** content,
517  int64_t* size,
518  const char* uuid,
520 
521 
522 
532  typedef int32_t (*OrthancPluginStorageRemove) (
533  const char* uuid,
535 
536 
537 
541  typedef struct _OrthancPluginContext_t
542  {
543  void* pluginsManager;
544  const char* orthancVersion;
545  OrthancPluginFree Free;
546  int32_t (*InvokeService) (struct _OrthancPluginContext_t* context,
547  _OrthancPluginService service,
548  const void* params);
550 
551 
552 
561  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
562  OrthancPluginContext* context,
563  char* str)
564  {
565  if (str != NULL)
566  {
567  context->Free(str);
568  }
569  }
570 
571 
584  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
585  OrthancPluginContext* context)
586  {
587  int major, minor, revision;
588 
589  /* Assume compatibility with the mainline */
590  if (!strcmp(context->orthancVersion, "mainline"))
591  {
592  return 1;
593  }
594 
595  /* Parse the version of the Orthanc core */
596  if (
597 #ifdef _MSC_VER
598  sscanf_s
599 #else
600  sscanf
601 #endif
602  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
603  {
604  return 0;
605  }
606 
607  /* Check the major number of the version */
608 
609  if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
610  {
611  return 1;
612  }
613 
614  if (major < ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
615  {
616  return 0;
617  }
618 
619  /* Check the minor number of the version */
620 
621  if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
622  {
623  return 1;
624  }
625 
626  if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
627  {
628  return 0;
629  }
630 
631  /* Check the revision number of the version */
632 
633  if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER)
634  {
635  return 1;
636  }
637  else
638  {
639  return 0;
640  }
641  }
642 
643 
652  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
653  OrthancPluginContext* context,
655  {
656  context->Free(buffer->data);
657  }
658 
659 
668  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
669  OrthancPluginContext* context,
670  const char* message)
671  {
672  context->InvokeService(context, _OrthancPluginService_LogError, message);
673  }
674 
675 
684  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
685  OrthancPluginContext* context,
686  const char* message)
687  {
688  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
689  }
690 
691 
700  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
701  OrthancPluginContext* context,
702  const char* message)
703  {
704  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
705  }
706 
707 
708 
709  typedef struct
710  {
711  const char* pathRegularExpression;
712  OrthancPluginRestCallback callback;
713  } _OrthancPluginRestCallback;
714 
727  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
728  OrthancPluginContext* context,
729  const char* pathRegularExpression,
730  OrthancPluginRestCallback callback)
731  {
732  _OrthancPluginRestCallback params;
733  params.pathRegularExpression = pathRegularExpression;
734  params.callback = callback;
735  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
736  }
737 
738 
739 
740  typedef struct
741  {
743  } _OrthancPluginOnStoredInstanceCallback;
744 
755  OrthancPluginContext* context,
757  {
758  _OrthancPluginOnStoredInstanceCallback params;
759  params.callback = callback;
760 
761  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
762  }
763 
764 
765 
766  typedef struct
767  {
768  OrthancPluginRestOutput* output;
769  const char* answer;
770  uint32_t answerSize;
771  const char* mimeType;
772  } _OrthancPluginAnswerBuffer;
773 
785  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
786  OrthancPluginContext* context,
787  OrthancPluginRestOutput* output,
788  const char* answer,
789  uint32_t answerSize,
790  const char* mimeType)
791  {
792  _OrthancPluginAnswerBuffer params;
793  params.output = output;
794  params.answer = answer;
795  params.answerSize = answerSize;
796  params.mimeType = mimeType;
797  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
798  }
799 
800 
801  typedef struct
802  {
803  OrthancPluginRestOutput* output;
805  uint32_t width;
806  uint32_t height;
807  uint32_t pitch;
808  const void* buffer;
809  } _OrthancPluginCompressAndAnswerPngImage;
810 
828  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
829  OrthancPluginContext* context,
830  OrthancPluginRestOutput* output,
832  uint32_t width,
833  uint32_t height,
834  uint32_t pitch,
835  const void* buffer)
836  {
837  _OrthancPluginCompressAndAnswerPngImage params;
838  params.output = output;
839  params.format = format;
840  params.width = width;
841  params.height = height;
842  params.pitch = pitch;
843  params.buffer = buffer;
844  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerPngImage, &params);
845  }
846 
847 
848 
849  typedef struct
850  {
852  const char* instanceId;
853  } _OrthancPluginGetDicomForInstance;
854 
866  ORTHANC_PLUGIN_INLINE int OrthancPluginGetDicomForInstance(
867  OrthancPluginContext* context,
869  const char* instanceId)
870  {
871  _OrthancPluginGetDicomForInstance params;
872  params.target = target;
873  params.instanceId = instanceId;
874  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
875  }
876 
877 
878 
879  typedef struct
880  {
882  const char* uri;
883  } _OrthancPluginRestApiGet;
884 
896  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiGet(
897  OrthancPluginContext* context,
899  const char* uri)
900  {
901  _OrthancPluginRestApiGet params;
902  params.target = target;
903  params.uri = uri;
904  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
905  }
906 
907 
908 
923  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiGetAfterPlugins(
924  OrthancPluginContext* context,
926  const char* uri)
927  {
928  _OrthancPluginRestApiGet params;
929  params.target = target;
930  params.uri = uri;
931  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
932  }
933 
934 
935 
936  typedef struct
937  {
939  const char* uri;
940  const char* body;
941  uint32_t bodySize;
942  } _OrthancPluginRestApiPostPut;
943 
957  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPost(
958  OrthancPluginContext* context,
960  const char* uri,
961  const char* body,
962  uint32_t bodySize)
963  {
964  _OrthancPluginRestApiPostPut params;
965  params.target = target;
966  params.uri = uri;
967  params.body = body;
968  params.bodySize = bodySize;
969  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
970  }
971 
972 
989  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPostAfterPlugins(
990  OrthancPluginContext* context,
992  const char* uri,
993  const char* body,
994  uint32_t bodySize)
995  {
996  _OrthancPluginRestApiPostPut params;
997  params.target = target;
998  params.uri = uri;
999  params.body = body;
1000  params.bodySize = bodySize;
1001  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
1002  }
1003 
1004 
1005 
1015  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiDelete(
1016  OrthancPluginContext* context,
1017  const char* uri)
1018  {
1019  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
1020  }
1021 
1022 
1035  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiDeleteAfterPlugins(
1036  OrthancPluginContext* context,
1037  const char* uri)
1038  {
1039  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
1040  }
1041 
1042 
1043 
1057  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPut(
1058  OrthancPluginContext* context,
1059  OrthancPluginMemoryBuffer* target,
1060  const char* uri,
1061  const char* body,
1062  uint32_t bodySize)
1063  {
1064  _OrthancPluginRestApiPostPut params;
1065  params.target = target;
1066  params.uri = uri;
1067  params.body = body;
1068  params.bodySize = bodySize;
1069  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
1070  }
1071 
1072 
1073 
1090  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPutAfterPlugins(
1091  OrthancPluginContext* context,
1092  OrthancPluginMemoryBuffer* target,
1093  const char* uri,
1094  const char* body,
1095  uint32_t bodySize)
1096  {
1097  _OrthancPluginRestApiPostPut params;
1098  params.target = target;
1099  params.uri = uri;
1100  params.body = body;
1101  params.bodySize = bodySize;
1102  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
1103  }
1104 
1105 
1106 
1107  typedef struct
1108  {
1109  OrthancPluginRestOutput* output;
1110  const char* argument;
1111  } _OrthancPluginOutputPlusArgument;
1112 
1123  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
1124  OrthancPluginContext* context,
1125  OrthancPluginRestOutput* output,
1126  const char* redirection)
1127  {
1128  _OrthancPluginOutputPlusArgument params;
1129  params.output = output;
1130  params.argument = redirection;
1131  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
1132  }
1133 
1134 
1135 
1136  typedef struct
1137  {
1138  char** result;
1139  const char* argument;
1140  } _OrthancPluginRetrieveDynamicString;
1141 
1154  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
1155  OrthancPluginContext* context,
1156  const char* patientID)
1157  {
1158  char* result;
1159 
1160  _OrthancPluginRetrieveDynamicString params;
1161  params.result = &result;
1162  params.argument = patientID;
1163 
1164  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params))
1165  {
1166  /* Error */
1167  return NULL;
1168  }
1169  else
1170  {
1171  return result;
1172  }
1173  }
1174 
1175 
1188  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
1189  OrthancPluginContext* context,
1190  const char* studyUID)
1191  {
1192  char* result;
1193 
1194  _OrthancPluginRetrieveDynamicString params;
1195  params.result = &result;
1196  params.argument = studyUID;
1197 
1198  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params))
1199  {
1200  /* Error */
1201  return NULL;
1202  }
1203  else
1204  {
1205  return result;
1206  }
1207  }
1208 
1209 
1222  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
1223  OrthancPluginContext* context,
1224  const char* accessionNumber)
1225  {
1226  char* result;
1227 
1228  _OrthancPluginRetrieveDynamicString params;
1229  params.result = &result;
1230  params.argument = accessionNumber;
1231 
1232  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params))
1233  {
1234  /* Error */
1235  return NULL;
1236  }
1237  else
1238  {
1239  return result;
1240  }
1241  }
1242 
1243 
1256  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
1257  OrthancPluginContext* context,
1258  const char* seriesUID)
1259  {
1260  char* result;
1261 
1262  _OrthancPluginRetrieveDynamicString params;
1263  params.result = &result;
1264  params.argument = seriesUID;
1265 
1266  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params))
1267  {
1268  /* Error */
1269  return NULL;
1270  }
1271  else
1272  {
1273  return result;
1274  }
1275  }
1276 
1277 
1290  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
1291  OrthancPluginContext* context,
1292  const char* sopInstanceUID)
1293  {
1294  char* result;
1295 
1296  _OrthancPluginRetrieveDynamicString params;
1297  params.result = &result;
1298  params.argument = sopInstanceUID;
1299 
1300  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params))
1301  {
1302  /* Error */
1303  return NULL;
1304  }
1305  else
1306  {
1307  return result;
1308  }
1309  }
1310 
1311 
1312 
1313  typedef struct
1314  {
1315  OrthancPluginRestOutput* output;
1316  uint16_t status;
1317  } _OrthancPluginSendHttpStatusCode;
1318 
1333  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
1334  OrthancPluginContext* context,
1335  OrthancPluginRestOutput* output,
1336  uint16_t status)
1337  {
1338  _OrthancPluginSendHttpStatusCode params;
1339  params.output = output;
1340  params.status = status;
1341  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
1342  }
1343 
1344 
1355  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
1356  OrthancPluginContext* context,
1357  OrthancPluginRestOutput* output,
1358  const char* realm)
1359  {
1360  _OrthancPluginOutputPlusArgument params;
1361  params.output = output;
1362  params.argument = realm;
1363  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
1364  }
1365 
1366 
1377  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
1378  OrthancPluginContext* context,
1379  OrthancPluginRestOutput* output,
1380  const char* allowedMethods)
1381  {
1382  _OrthancPluginOutputPlusArgument params;
1383  params.output = output;
1384  params.argument = allowedMethods;
1385  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
1386  }
1387 
1388 
1389  typedef struct
1390  {
1391  OrthancPluginRestOutput* output;
1392  const char* key;
1393  const char* value;
1394  } _OrthancPluginSetHttpHeader;
1395 
1406  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
1407  OrthancPluginContext* context,
1408  OrthancPluginRestOutput* output,
1409  const char* cookie,
1410  const char* value)
1411  {
1412  _OrthancPluginSetHttpHeader params;
1413  params.output = output;
1414  params.key = cookie;
1415  params.value = value;
1416  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
1417  }
1418 
1419 
1430  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
1431  OrthancPluginContext* context,
1432  OrthancPluginRestOutput* output,
1433  const char* key,
1434  const char* value)
1435  {
1436  _OrthancPluginSetHttpHeader params;
1437  params.output = output;
1438  params.key = key;
1439  params.value = value;
1440  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
1441  }
1442 
1443 
1444  typedef struct
1445  {
1446  char** resultStringToFree;
1447  const char** resultString;
1448  int64_t* resultInt64;
1449  const char* key;
1450  OrthancPluginDicomInstance* instance;
1451  } _OrthancPluginAccessDicomInstance;
1452 
1453 
1464  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
1465  OrthancPluginContext* context,
1466  OrthancPluginDicomInstance* instance)
1467  {
1468  const char* result;
1469 
1470  _OrthancPluginAccessDicomInstance params;
1471  memset(&params, 0, sizeof(params));
1472  params.resultString = &result;
1473  params.instance = instance;
1474 
1475  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params))
1476  {
1477  /* Error */
1478  return NULL;
1479  }
1480  else
1481  {
1482  return result;
1483  }
1484  }
1485 
1486 
1496  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
1497  OrthancPluginContext* context,
1498  OrthancPluginDicomInstance* instance)
1499  {
1500  int64_t size;
1501 
1502  _OrthancPluginAccessDicomInstance params;
1503  memset(&params, 0, sizeof(params));
1504  params.resultInt64 = &size;
1505  params.instance = instance;
1506 
1507  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params))
1508  {
1509  /* Error */
1510  return -1;
1511  }
1512  else
1513  {
1514  return size;
1515  }
1516  }
1517 
1518 
1528  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
1529  OrthancPluginContext* context,
1530  OrthancPluginDicomInstance* instance)
1531  {
1532  const char* result;
1533 
1534  _OrthancPluginAccessDicomInstance params;
1535  memset(&params, 0, sizeof(params));
1536  params.resultString = &result;
1537  params.instance = instance;
1538 
1539  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params))
1540  {
1541  /* Error */
1542  return NULL;
1543  }
1544  else
1545  {
1546  return result;
1547  }
1548  }
1549 
1550 
1563  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
1564  OrthancPluginContext* context,
1565  OrthancPluginDicomInstance* instance)
1566  {
1567  char* result;
1568 
1569  _OrthancPluginAccessDicomInstance params;
1570  memset(&params, 0, sizeof(params));
1571  params.resultStringToFree = &result;
1572  params.instance = instance;
1573 
1574  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params))
1575  {
1576  /* Error */
1577  return NULL;
1578  }
1579  else
1580  {
1581  return result;
1582  }
1583  }
1584 
1585 
1600  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
1601  OrthancPluginContext* context,
1602  OrthancPluginDicomInstance* instance)
1603  {
1604  char* result;
1605 
1606  _OrthancPluginAccessDicomInstance params;
1607  memset(&params, 0, sizeof(params));
1608  params.resultStringToFree = &result;
1609  params.instance = instance;
1610 
1611  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params))
1612  {
1613  /* Error */
1614  return NULL;
1615  }
1616  else
1617  {
1618  return result;
1619  }
1620  }
1621 
1622 
1638  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
1639  OrthancPluginContext* context,
1640  OrthancPluginDicomInstance* instance,
1641  const char* metadata)
1642  {
1643  int64_t result;
1644 
1645  _OrthancPluginAccessDicomInstance params;
1646  memset(&params, 0, sizeof(params));
1647  params.resultInt64 = &result;
1648  params.instance = instance;
1649  params.key = metadata;
1650 
1651  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params))
1652  {
1653  /* Error */
1654  return -1;
1655  }
1656  else
1657  {
1658  return (result != 0);
1659  }
1660  }
1661 
1662 
1675  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
1676  OrthancPluginContext* context,
1677  OrthancPluginDicomInstance* instance,
1678  const char* metadata)
1679  {
1680  const char* result;
1681 
1682  _OrthancPluginAccessDicomInstance params;
1683  memset(&params, 0, sizeof(params));
1684  params.resultString = &result;
1685  params.instance = instance;
1686  params.key = metadata;
1687 
1688  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params))
1689  {
1690  /* Error */
1691  return NULL;
1692  }
1693  else
1694  {
1695  return result;
1696  }
1697  }
1698 
1699 
1700 
1701  typedef struct
1702  {
1706  OrthancPluginFree free;
1707  } _OrthancPluginRegisterStorageArea;
1708 
1722  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
1723  OrthancPluginContext* context,
1727  {
1728  _OrthancPluginRegisterStorageArea params;
1729  params.create = create;
1730  params.read = read;
1731  params.remove = remove;
1732 
1733 #ifdef __cplusplus
1734  params.free = ::free;
1735 #else
1736  params.free = free;
1737 #endif
1738 
1739  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
1740  }
1741 
1742 
1743 
1754  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
1755  {
1756  char* result;
1757 
1758  _OrthancPluginRetrieveDynamicString params;
1759  params.result = &result;
1760  params.argument = NULL;
1761 
1762  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params))
1763  {
1764  /* Error */
1765  return NULL;
1766  }
1767  else
1768  {
1769  return result;
1770  }
1771  }
1772 
1773 
1784  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
1785  {
1786  char* result;
1787 
1788  _OrthancPluginRetrieveDynamicString params;
1789  params.result = &result;
1790  params.argument = NULL;
1791 
1792  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params))
1793  {
1794  /* Error */
1795  return NULL;
1796  }
1797  else
1798  {
1799  return result;
1800  }
1801  }
1802 
1803 
1819  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
1820  {
1821  char* result;
1822 
1823  _OrthancPluginRetrieveDynamicString params;
1824  params.result = &result;
1825  params.argument = NULL;
1826 
1827  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params))
1828  {
1829  /* Error */
1830  return NULL;
1831  }
1832  else
1833  {
1834  return result;
1835  }
1836  }
1837 
1838 
1839 
1840  typedef struct
1841  {
1843  } _OrthancPluginOnChangeCallback;
1844 
1854  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
1855  OrthancPluginContext* context,
1857  {
1858  _OrthancPluginOnChangeCallback params;
1859  params.callback = callback;
1860 
1861  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
1862  }
1863 
1864 
1865 
1866  typedef struct
1867  {
1868  const char* plugin;
1869  _OrthancPluginProperty property;
1870  const char* value;
1871  } _OrthancPluginSetPluginProperty;
1872 
1873 
1885  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
1886  OrthancPluginContext* context,
1887  const char* uri)
1888  {
1889  _OrthancPluginSetPluginProperty params;
1890  params.plugin = OrthancPluginGetName();
1891  params.property = _OrthancPluginProperty_RootUri;
1892  params.value = uri;
1893 
1894  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
1895  }
1896 
1897 
1907  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
1908  OrthancPluginContext* context,
1909  const char* description)
1910  {
1911  _OrthancPluginSetPluginProperty params;
1912  params.plugin = OrthancPluginGetName();
1913  params.property = _OrthancPluginProperty_Description;
1914  params.value = description;
1915 
1916  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
1917  }
1918 
1919 
1929  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
1930  OrthancPluginContext* context,
1931  const char* javascript)
1932  {
1933  _OrthancPluginSetPluginProperty params;
1934  params.plugin = OrthancPluginGetName();
1935  params.property = _OrthancPluginProperty_OrthancExplorer;
1936  params.value = javascript;
1937 
1938  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
1939  }
1940 
1941 
1942  typedef struct
1943  {
1944  char** result;
1945  int32_t property;
1946  const char* value;
1947  } _OrthancPluginGlobalProperty;
1948 
1949 
1962  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
1963  OrthancPluginContext* context,
1964  int32_t property,
1965  const char* defaultValue)
1966  {
1967  char* result;
1968 
1969  _OrthancPluginGlobalProperty params;
1970  params.result = &result;
1971  params.property = property;
1972  params.value = defaultValue;
1973 
1974  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params))
1975  {
1976  /* Error */
1977  return NULL;
1978  }
1979  else
1980  {
1981  return result;
1982  }
1983  }
1984 
1985 
2000  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginSetGlobalProperty(
2001  OrthancPluginContext* context,
2002  int32_t property,
2003  const char* value)
2004  {
2005  _OrthancPluginGlobalProperty params;
2006  params.result = NULL;
2007  params.property = property;
2008  params.value = value;
2009 
2010  if (context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params))
2011  {
2012  /* Error */
2013  return -1;
2014  }
2015  else
2016  {
2017  return 0;
2018  }
2019  }
2020 
2021 
2022 
2023  typedef struct
2024  {
2025  int32_t *resultInt32;
2026  uint32_t *resultUint32;
2027  int64_t *resultInt64;
2028  uint64_t *resultUint64;
2029  } _OrthancPluginReturnSingleValue;
2030 
2039  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
2040  OrthancPluginContext* context)
2041  {
2042  uint32_t count = 0;
2043 
2044  _OrthancPluginReturnSingleValue params;
2045  memset(&params, 0, sizeof(params));
2046  params.resultUint32 = &count;
2047 
2048  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params))
2049  {
2050  /* Error */
2051  return 0;
2052  }
2053  else
2054  {
2055  return count;
2056  }
2057  }
2058 
2059 
2060 
2073  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
2074  OrthancPluginContext* context,
2075  uint32_t argument)
2076  {
2077  char* result;
2078 
2079  _OrthancPluginGlobalProperty params;
2080  params.result = &result;
2081  params.property = (int32_t) argument;
2082  params.value = NULL;
2083 
2084  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params))
2085  {
2086  /* Error */
2087  return NULL;
2088  }
2089  else
2090  {
2091  return result;
2092  }
2093  }
2094 
2095 
2104  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
2105  OrthancPluginContext* context)
2106  {
2107  uint32_t count = 0;
2108 
2109  _OrthancPluginReturnSingleValue params;
2110  memset(&params, 0, sizeof(params));
2111  params.resultUint32 = &count;
2112 
2113  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params))
2114  {
2115  /* Error */
2116  return 0;
2117  }
2118  else
2119  {
2120  return count;
2121  }
2122  }
2123 
2124 
2125 
2137  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
2138  {
2139  char* result;
2140 
2141  _OrthancPluginRetrieveDynamicString params;
2142  params.result = &result;
2143  params.argument = NULL;
2144 
2145  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params))
2146  {
2147  /* Error */
2148  return NULL;
2149  }
2150  else
2151  {
2152  return result;
2153  }
2154  }
2155 
2156 
2157 
2158  typedef struct
2159  {
2160  OrthancPluginRestOutput* output;
2161  const char* subType;
2162  const char* contentType;
2163  } _OrthancPluginStartMultipartAnswer;
2164 
2177  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginStartMultipartAnswer(
2178  OrthancPluginContext* context,
2179  OrthancPluginRestOutput* output,
2180  const char* subType,
2181  const char* contentType)
2182  {
2183  _OrthancPluginStartMultipartAnswer params;
2184  params.output = output;
2185  params.subType = subType;
2186  params.contentType = contentType;
2187  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
2188  }
2189 
2190 
2204  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginSendMultipartItem(
2205  OrthancPluginContext* context,
2206  OrthancPluginRestOutput* output,
2207  const char* answer,
2208  uint32_t answerSize)
2209  {
2210  _OrthancPluginAnswerBuffer params;
2211  params.output = output;
2212  params.answer = answer;
2213  params.answerSize = answerSize;
2214  params.mimeType = NULL;
2215  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
2216  }
2217 
2218 #ifdef __cplusplus
2219 }
2220 #endif
2221 
2222 
int32_t(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:532
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:1377
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:1962
The parameters of a REST request.
Definition: OrthancCPlugin.h:179
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:1854
Definition: OrthancCPlugin.h:374
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:754
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:239
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:234
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:199
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:1123
int32_t(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:496
int OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:957
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:1333
Definition: OrthancCPlugin.h:400
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:1464
void OrthancPluginCompressAndAnswerPngImage(OrthancPluginContext *context, OrthancPluginRestOutput *output, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer)
Answer to a REST request with a PNG image.
Definition: OrthancCPlugin.h:828
OrthancPluginContentType
Definition: OrthancCPlugin.h:371
Definition: OrthancCPlugin.h:403
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:700
int32_t(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:515
Definition: OrthancCPlugin.h:169
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:668
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:2137
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:652
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:1754
OrthancPluginResourceType
Definition: OrthancCPlugin.h:383
int32_t(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:452
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:1355
OrthancPluginChangeType
Definition: OrthancCPlugin.h:396
int OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1015
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:1430
int OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:866
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:1784
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:339
int OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1035
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:1222
int32_t OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:2177
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:1885
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:424
Definition: OrthancCPlugin.h:401
Color image in RGB24 format.
Definition: OrthancCPlugin.h:355
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:1638
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:229
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:1600
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:1929
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:167
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:445
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:2073
Definition: OrthancCPlugin.h:407
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
Definition: OrthancCPlugin.h:399
Definition: OrthancCPlugin.h:385
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:438
int32_t OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:2000
int OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1057
int OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1090
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:209
int OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:989
Definition: OrthancCPlugin.h:171
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:1819
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:214
Definition: OrthancCPlugin.h:172
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:1154
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:363
Definition: OrthancCPlugin.h:386
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:1406
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:204
Definition: OrthancCPlugin.h:398
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:194
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:2039
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:429
int OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:896
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:189
int32_t(* OrthancPluginOnStoredInstanceCallback)(OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc receives a DICOM instance.
Definition: OrthancCPlugin.h:462
Definition: OrthancCPlugin.h:406
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:323
Definition: OrthancCPlugin.h:387
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:727
int32_t OrthancPluginSendMultipartItem(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize)
Send an item as a part of some HTTP multipart answer.
Definition: OrthancCPlugin.h:2204
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:331
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:219
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:785
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition: OrthancCPlugin.h:1675
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:2104
Definition: OrthancCPlugin.h:405
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:1722
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:561
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:481
Definition: OrthancCPlugin.h:402
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:1496
Definition: OrthancCPlugin.h:388
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:1563
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:347
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:184
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:1528
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:419
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:1907
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:584
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:684
Definition: OrthancCPlugin.h:375
Definition: OrthancCPlugin.h:170
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:1188
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:1256
Definition: OrthancCPlugin.h:373
Definition: OrthancCPlugin.h:404
int OrthancPluginRestApiGetAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:923
int32_t(* OrthancPluginOnChangeCallback)(OrthancPluginChangeType changeType, OrthancPluginResourceType resourceType, const char *resourceId)
Signature of a callback function that is triggered when a change happens to some DICOM resource...
Definition: OrthancCPlugin.h:471
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:1290