114#  define ORTHANC_PLUGINS_API __declspec(dllexport) 
  116#  define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default"))) 
  118#  define ORTHANC_PLUGINS_API 
  121#define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER     1 
  122#define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER     11 
  123#define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER  1 
  126#if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) 
  127#define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision)        \ 
  128  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major ||                      \ 
  129   (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major &&                    \ 
  130    (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor ||                    \ 
  131     (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor &&                  \ 
  132      ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision)))) 
  151#ifndef ORTHANC_PLUGIN_INLINE 
  152#  if __STDC_VERSION__ >= 199901L 
  154#    define ORTHANC_PLUGIN_INLINE static inline 
  155#  elif defined(__cplusplus) 
  157#    define ORTHANC_PLUGIN_INLINE static inline 
  158#  elif defined(__GNUC__) 
  160#    define ORTHANC_PLUGIN_INLINE static __inline 
  161#  elif defined(_MSC_VER) 
  163#    define ORTHANC_PLUGIN_INLINE static __inline 
  165#    error Your compiler is not known to support the "inline" keyword 
  311    _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
 
 
  319  ORTHANC_PLUGINS_API 
const char* OrthancPluginGetName();
 
  332    _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
 
 
  408    _OrthancPluginService_LogInfo = 1,
 
  409    _OrthancPluginService_LogWarning = 2,
 
  410    _OrthancPluginService_LogError = 3,
 
  411    _OrthancPluginService_GetOrthancPath = 4,
 
  412    _OrthancPluginService_GetOrthancDirectory = 5,
 
  413    _OrthancPluginService_GetConfigurationPath = 6,
 
  414    _OrthancPluginService_SetPluginProperty = 7,
 
  415    _OrthancPluginService_GetGlobalProperty = 8,
 
  416    _OrthancPluginService_SetGlobalProperty = 9,
 
  417    _OrthancPluginService_GetCommandLineArgumentsCount = 10,
 
  418    _OrthancPluginService_GetCommandLineArgument = 11,
 
  419    _OrthancPluginService_GetExpectedDatabaseVersion = 12,
 
  420    _OrthancPluginService_GetConfiguration = 13,
 
  421    _OrthancPluginService_BufferCompression = 14,
 
  422    _OrthancPluginService_ReadFile = 15,
 
  423    _OrthancPluginService_WriteFile = 16,
 
  424    _OrthancPluginService_GetErrorDescription = 17,
 
  425    _OrthancPluginService_CallHttpClient = 18,
 
  426    _OrthancPluginService_RegisterErrorCode = 19,
 
  427    _OrthancPluginService_RegisterDictionaryTag = 20,
 
  428    _OrthancPluginService_DicomBufferToJson = 21,
 
  429    _OrthancPluginService_DicomInstanceToJson = 22,
 
  430    _OrthancPluginService_CreateDicom = 23,
 
  431    _OrthancPluginService_ComputeMd5 = 24,
 
  432    _OrthancPluginService_ComputeSha1 = 25,
 
  433    _OrthancPluginService_LookupDictionary = 26,
 
  434    _OrthancPluginService_CallHttpClient2 = 27,
 
  435    _OrthancPluginService_GenerateUuid = 28,
 
  436    _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
 
  437    _OrthancPluginService_AutodetectMimeType = 30,
 
  438    _OrthancPluginService_SetMetricsValue = 31,
 
  439    _OrthancPluginService_EncodeDicomWebJson = 32,
 
  440    _OrthancPluginService_EncodeDicomWebXml = 33,
 
  441    _OrthancPluginService_ChunkedHttpClient = 34,    
 
  442    _OrthancPluginService_GetTagName = 35,           
 
  443    _OrthancPluginService_EncodeDicomWebJson2 = 36,  
 
  444    _OrthancPluginService_EncodeDicomWebXml2 = 37,   
 
  445    _OrthancPluginService_CreateMemoryBuffer = 38,   
 
  446    _OrthancPluginService_GenerateRestApiAuthorizationToken = 39,   
 
  447    _OrthancPluginService_CreateMemoryBuffer64 = 40, 
 
  448    _OrthancPluginService_CreateDicom2 = 41,         
 
  449    _OrthancPluginService_GetDatabaseServerIdentifier = 42,         
 
  452    _OrthancPluginService_RegisterRestCallback = 1000,
 
  453    _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
 
  454    _OrthancPluginService_RegisterStorageArea = 1002,
 
  455    _OrthancPluginService_RegisterOnChangeCallback = 1003,
 
  456    _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
 
  457    _OrthancPluginService_RegisterWorklistCallback = 1005,
 
  458    _OrthancPluginService_RegisterDecodeImageCallback = 1006,
 
  459    _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
 
  460    _OrthancPluginService_RegisterFindCallback = 1008,
 
  461    _OrthancPluginService_RegisterMoveCallback = 1009,
 
  462    _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
 
  463    _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
 
  464    _OrthancPluginService_RegisterChunkedRestCallback = 1012,  
 
  465    _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
 
  466    _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
 
  467    _OrthancPluginService_RegisterTranscoderCallback = 1015,   
 
  468    _OrthancPluginService_RegisterStorageArea2 = 1016,         
 
  469    _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017,  
 
  470    _OrthancPluginService_RegisterReceivedInstanceCallback = 1018,  
 
  471    _OrthancPluginService_RegisterWebDavCollection = 1019,     
 
  474    _OrthancPluginService_AnswerBuffer = 2000,
 
  475    _OrthancPluginService_CompressAndAnswerPngImage = 2001,  
 
  476    _OrthancPluginService_Redirect = 2002,
 
  477    _OrthancPluginService_SendHttpStatusCode = 2003,
 
  478    _OrthancPluginService_SendUnauthorized = 2004,
 
  479    _OrthancPluginService_SendMethodNotAllowed = 2005,
 
  480    _OrthancPluginService_SetCookie = 2006,
 
  481    _OrthancPluginService_SetHttpHeader = 2007,
 
  482    _OrthancPluginService_StartMultipartAnswer = 2008,
 
  483    _OrthancPluginService_SendMultipartItem = 2009,
 
  484    _OrthancPluginService_SendHttpStatus = 2010,
 
  485    _OrthancPluginService_CompressAndAnswerImage = 2011,
 
  486    _OrthancPluginService_SendMultipartItem2 = 2012,
 
  487    _OrthancPluginService_SetHttpErrorDetails = 2013,
 
  490    _OrthancPluginService_GetDicomForInstance = 3000,
 
  491    _OrthancPluginService_RestApiGet = 3001,
 
  492    _OrthancPluginService_RestApiPost = 3002,
 
  493    _OrthancPluginService_RestApiDelete = 3003,
 
  494    _OrthancPluginService_RestApiPut = 3004,
 
  495    _OrthancPluginService_LookupPatient = 3005,
 
  496    _OrthancPluginService_LookupStudy = 3006,
 
  497    _OrthancPluginService_LookupSeries = 3007,
 
  498    _OrthancPluginService_LookupInstance = 3008,
 
  499    _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
 
  500    _OrthancPluginService_RestApiGetAfterPlugins = 3010,
 
  501    _OrthancPluginService_RestApiPostAfterPlugins = 3011,
 
  502    _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
 
  503    _OrthancPluginService_RestApiPutAfterPlugins = 3013,
 
  504    _OrthancPluginService_ReconstructMainDicomTags = 3014,
 
  505    _OrthancPluginService_RestApiGet2 = 3015,
 
  506    _OrthancPluginService_CallRestApi = 3016,              
 
  509    _OrthancPluginService_GetInstanceRemoteAet = 4000,
 
  510    _OrthancPluginService_GetInstanceSize = 4001,
 
  511    _OrthancPluginService_GetInstanceData = 4002,
 
  512    _OrthancPluginService_GetInstanceJson = 4003,
 
  513    _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
 
  514    _OrthancPluginService_HasInstanceMetadata = 4005,
 
  515    _OrthancPluginService_GetInstanceMetadata = 4006,
 
  516    _OrthancPluginService_GetInstanceOrigin = 4007,
 
  517    _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
 
  518    _OrthancPluginService_HasInstancePixelData = 4009,
 
  519    _OrthancPluginService_CreateDicomInstance = 4010,      
 
  520    _OrthancPluginService_FreeDicomInstance = 4011,        
 
  521    _OrthancPluginService_GetInstanceFramesCount = 4012,   
 
  522    _OrthancPluginService_GetInstanceRawFrame = 4013,      
 
  523    _OrthancPluginService_GetInstanceDecodedFrame = 4014,  
 
  524    _OrthancPluginService_TranscodeDicomInstance = 4015,   
 
  525    _OrthancPluginService_SerializeDicomInstance = 4016,   
 
  526    _OrthancPluginService_GetInstanceAdvancedJson = 4017,  
 
  527    _OrthancPluginService_GetInstanceDicomWebJson = 4018,  
 
  528    _OrthancPluginService_GetInstanceDicomWebXml = 4019,   
 
  531    _OrthancPluginService_RegisterDatabaseBackend = 5000,    
 
  532    _OrthancPluginService_DatabaseAnswer = 5001,
 
  533    _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,  
 
  534    _OrthancPluginService_StorageAreaCreate = 5003,
 
  535    _OrthancPluginService_StorageAreaRead = 5004,
 
  536    _OrthancPluginService_StorageAreaRemove = 5005,
 
  537    _OrthancPluginService_RegisterDatabaseBackendV3 = 5006,  
 
  540    _OrthancPluginService_GetImagePixelFormat = 6000,
 
  541    _OrthancPluginService_GetImageWidth = 6001,
 
  542    _OrthancPluginService_GetImageHeight = 6002,
 
  543    _OrthancPluginService_GetImagePitch = 6003,
 
  544    _OrthancPluginService_GetImageBuffer = 6004,
 
  545    _OrthancPluginService_UncompressImage = 6005,
 
  546    _OrthancPluginService_FreeImage = 6006,
 
  547    _OrthancPluginService_CompressImage = 6007,
 
  548    _OrthancPluginService_ConvertPixelFormat = 6008,
 
  549    _OrthancPluginService_GetFontsCount = 6009,
 
  550    _OrthancPluginService_GetFontInfo = 6010,
 
  551    _OrthancPluginService_DrawText = 6011,
 
  552    _OrthancPluginService_CreateImage = 6012,
 
  553    _OrthancPluginService_CreateImageAccessor = 6013,
 
  554    _OrthancPluginService_DecodeDicomImage = 6014,
 
  557    _OrthancPluginService_WorklistAddAnswer = 7000,
 
  558    _OrthancPluginService_WorklistMarkIncomplete = 7001,
 
  559    _OrthancPluginService_WorklistIsMatch = 7002,
 
  560    _OrthancPluginService_WorklistGetDicomQuery = 7003,
 
  561    _OrthancPluginService_FindAddAnswer = 7004,
 
  562    _OrthancPluginService_FindMarkIncomplete = 7005,
 
  563    _OrthancPluginService_GetFindQuerySize = 7006,
 
  564    _OrthancPluginService_GetFindQueryTag = 7007,
 
  565    _OrthancPluginService_GetFindQueryTagName = 7008,
 
  566    _OrthancPluginService_GetFindQueryValue = 7009,
 
  567    _OrthancPluginService_CreateFindMatcher = 7010,
 
  568    _OrthancPluginService_FreeFindMatcher = 7011,
 
  569    _OrthancPluginService_FindMatcherIsMatch = 7012,
 
  572    _OrthancPluginService_GetPeers = 8000,
 
  573    _OrthancPluginService_FreePeers = 8001,
 
  574    _OrthancPluginService_GetPeersCount = 8003,
 
  575    _OrthancPluginService_GetPeerName = 8004,
 
  576    _OrthancPluginService_GetPeerUrl = 8005,
 
  577    _OrthancPluginService_CallPeerApi = 8006,
 
  578    _OrthancPluginService_GetPeerUserProperty = 8007,
 
  581    _OrthancPluginService_CreateJob = 9000,
 
  582    _OrthancPluginService_FreeJob = 9001,
 
  583    _OrthancPluginService_SubmitJob = 9002,
 
  584    _OrthancPluginService_RegisterJobsUnserializer = 9003,
 
  586    _OrthancPluginService_INTERNAL = 0x7fffffff
 
  587  } _OrthancPluginService;
 
  592    _OrthancPluginProperty_Description = 1,
 
  593    _OrthancPluginProperty_RootUri = 2,
 
  594    _OrthancPluginProperty_OrthancExplorer = 3,
 
  596    _OrthancPluginProperty_INTERNAL = 0x7fffffff
 
  597  } _OrthancPluginProperty;
 
  689    _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
 
 
  704    _OrthancPluginContentType_INTERNAL = 0x7fffffff
 
 
  720    _OrthancPluginResourceType_INTERNAL = 0x7fffffff
 
 
  751    _OrthancPluginChangeType_INTERNAL = 0x7fffffff
 
 
  766    _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
 
 
  780    _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
 
 
  818    _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
 
 
  833    _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
 
 
  844    OrthancPluginDicomToJsonFlags_None                  = 0,
 
  854    _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
 
 
  865    OrthancPluginCreateDicomFlags_None                  = 0,
 
  869    _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
 
 
  885    _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
 
 
  901    _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
 
 
  917    _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
 
 
 1020    _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
 
 
 1183    const char* instanceId);
 
 1194    const char* resourceId);
 
 1205    const uint32_t size,
 
 1206    uint32_t frameIndex);
 
 1227    const char*                      bulkDataUri);
 
 1245    const void* content,
 
 1317    uint64_t rangeStart);
 
 1353    const char*                       issuerAet,
 
 1354    const char*                       calledAet);
 
 1385    uint32_t                 headersCount,
 
 1386    const char* 
const*       headersKeys,
 
 1387    const char* 
const*       headersValues);
 
 1420    uint32_t                 headersCount,
 
 1421    const char* 
const*       headersKeys,
 
 1422    const char* 
const*       headersValues,
 
 1423    uint32_t                 getArgumentsCount,
 
 1424    const char* 
const*       getArgumentsKeys,
 
 1425    const char* 
const*       getArgumentsValues);
 
 1446    const char*                   issuerAet,
 
 1447    const char*                   calledAet);
 
 1486  typedef void* (*OrthancPluginMoveCallback) (
 
 1488    const char*                patientId,
 
 1489    const char*                accessionNumber,
 
 1490    const char*                studyInstanceUid,
 
 1491    const char*                seriesInstanceUid,
 
 1492    const char*                sopInstanceUid,
 
 1493    const char*                originatorAet,
 
 1494    const char*                sourceAet,
 
 1495    const char*                targetAet,
 
 1496    uint16_t                   originatorId);
 
 1581  typedef const char* (*OrthancPluginJobGetContent) (
void* job);
 
 1599  typedef const char* (*OrthancPluginJobGetSerialized) (
void* job);
 
 1672                                                              const char* serialized);
 
 1720    uint32_t                            levelDepth,
 
 1721    const uint16_t*                     levelTagGroup,
 
 1722    const uint16_t*                     levelTagElement,
 
 1723    const uint32_t*                     levelIndex,
 
 1725    uint16_t                            tagElement,
 
 1758    uint32_t                            levelDepth,
 
 1759    const uint16_t*                     levelTagGroup,
 
 1760    const uint16_t*                     levelTagElement,
 
 1761    const uint32_t*                     levelIndex,
 
 1763    uint16_t                            tagElement,
 
 1772  typedef struct _OrthancPluginContext_t
 
 1774    void*                     pluginsManager;
 
 1775    const char*               orthancVersion;
 
 1778                                              _OrthancPluginService service,
 
 1779                                              const void* params);
 
 1840    int expectedRevision)
 
 1842    int major, minor, revision;
 
 1846        sizeof(int32_t) != 
sizeof(_OrthancPluginService) ||
 
 1847        sizeof(int32_t) != 
sizeof(_OrthancPluginProperty) ||
 
 1872    if (!strcmp(context->orthancVersion, 
"mainline"))
 
 1884      (context->orthancVersion, 
"%4d.%4d.%4d", &major, &minor, &revision) != 3)
 
 1891    if (major > expectedMajor)
 
 1896    if (major < expectedMajor)
 
 1903    if (minor > expectedMinor)
 
 1908    if (minor < expectedMinor)
 
 1915    if (revision >= expectedRevision)
 
 
 1947      ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
 
 1948      ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
 
 1949      ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
 
 
 1965    context->Free(buffer->
data);
 
 
 1981    context->Free(buffer->
data);
 
 
 1995    const char* message)
 
 1997    context->InvokeService(context, _OrthancPluginService_LogError, message);
 
 
 2011    const char* message)
 
 2013    context->InvokeService(context, _OrthancPluginService_LogWarning, message);
 
 
 2027    const char* message)
 
 2029    context->InvokeService(context, _OrthancPluginService_LogInfo, message);
 
 
 2036    const char* pathRegularExpression;
 
 2038  } _OrthancPluginRestCallback;
 
 2063    const char*               pathRegularExpression,
 
 2066    _OrthancPluginRestCallback params;
 
 2067    params.pathRegularExpression = pathRegularExpression;
 
 2068    params.callback = callback;
 
 2069    context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, ¶ms);
 
 
 2103    const char*               pathRegularExpression,
 
 2106    _OrthancPluginRestCallback params;
 
 2107    params.pathRegularExpression = pathRegularExpression;
 
 2108    params.callback = callback;
 
 2109    context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, ¶ms);
 
 
 2117  } _OrthancPluginOnStoredInstanceCallback;
 
 2143    _OrthancPluginOnStoredInstanceCallback params;
 
 2144    params.callback = callback;
 
 2146    context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, ¶ms);
 
 
 2155    uint32_t                 answerSize;
 
 2156    const char*              mimeType;
 
 2157  } _OrthancPluginAnswerBuffer;
 
 2175    uint32_t                 answerSize,
 
 2176    const char*              mimeType)
 
 2178    _OrthancPluginAnswerBuffer params;
 
 2179    params.output = output;
 
 2180    params.answer = answer;
 
 2181    params.answerSize = answerSize;
 
 2182    params.mimeType = mimeType;
 
 2183    context->InvokeService(context, _OrthancPluginService_AnswerBuffer, ¶ms);
 
 
 2195  } _OrthancPluginCompressAndAnswerPngImage;
 
 2207  } _OrthancPluginCompressAndAnswerImage;
 
 2237    _OrthancPluginCompressAndAnswerImage params;
 
 2238    params.output = output;
 
 2240    params.pixelFormat = format;
 
 2241    params.width = width;
 
 2242    params.height = height;
 
 2243    params.pitch = pitch;
 
 2244    params.buffer = buffer;
 
 2246    context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
 
 
 2254    const char*                 instanceId;
 
 2255  } _OrthancPluginGetDicomForInstance;
 
 2272    const char*                 instanceId)
 
 2274    _OrthancPluginGetDicomForInstance params;
 
 2275    params.target = target;
 
 2276    params.instanceId = instanceId;
 
 2277    return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, ¶ms);
 
 
 2286  } _OrthancPluginRestApiGet;
 
 2307    _OrthancPluginRestApiGet params;
 
 2308    params.target = target;
 
 2310    return context->InvokeService(context, _OrthancPluginService_RestApiGet, ¶ms);
 
 
 2337    _OrthancPluginRestApiGet params;
 
 2338    params.target = target;
 
 2340    return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, ¶ms);
 
 
 2351  } _OrthancPluginRestApiPostPut;
 
 2376    _OrthancPluginRestApiPostPut params;
 
 2377    params.target = target;
 
 2380    params.bodySize = bodySize;
 
 2381    return context->InvokeService(context, _OrthancPluginService_RestApiPost, ¶ms);
 
 
 2411    _OrthancPluginRestApiPostPut params;
 
 2412    params.target = target;
 
 2415    params.bodySize = bodySize;
 
 2416    return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, ¶ms);
 
 
 2437    return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
 
 
 2460    return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
 
 
 2488    _OrthancPluginRestApiPostPut params;
 
 2489    params.target = target;
 
 2492    params.bodySize = bodySize;
 
 2493    return context->InvokeService(context, _OrthancPluginService_RestApiPut, ¶ms);
 
 
 2524    _OrthancPluginRestApiPostPut params;
 
 2525    params.target = target;
 
 2528    params.bodySize = bodySize;
 
 2529    return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, ¶ms);
 
 
 2537    const char*              argument;
 
 2538  } _OrthancPluginOutputPlusArgument;
 
 2554    const char*              redirection)
 
 2556    _OrthancPluginOutputPlusArgument params;
 
 2557    params.output = output;
 
 2558    params.argument = redirection;
 
 2559    context->InvokeService(context, _OrthancPluginService_Redirect, ¶ms);
 
 
 2567    const char*  argument;
 
 2568  } _OrthancPluginRetrieveDynamicString;
 
 2585    const char*            patientID)
 
 2589    _OrthancPluginRetrieveDynamicString params;
 
 2590    params.result = &result;
 
 2591    params.argument = patientID;
 
 
 2620    const char*            studyUID)
 
 2624    _OrthancPluginRetrieveDynamicString params;
 
 2625    params.result = &result;
 
 2626    params.argument = studyUID;
 
 
 2655    const char*            accessionNumber)
 
 2659    _OrthancPluginRetrieveDynamicString params;
 
 2660    params.result = &result;
 
 2661    params.argument = accessionNumber;
 
 
 2690    const char*            seriesUID)
 
 2694    _OrthancPluginRetrieveDynamicString params;
 
 2695    params.result = &result;
 
 2696    params.argument = seriesUID;
 
 
 2725    const char*            sopInstanceUID)
 
 2729    _OrthancPluginRetrieveDynamicString params;
 
 2730    params.result = &result;
 
 2731    params.argument = sopInstanceUID;
 
 
 2750  } _OrthancPluginSendHttpStatusCode;
 
 2773    _OrthancPluginSendHttpStatusCode params;
 
 2774    params.output = output;
 
 2775    params.status = status;
 
 2776    context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, ¶ms);
 
 
 2796    _OrthancPluginOutputPlusArgument params;
 
 2797    params.output = output;
 
 2798    params.argument = realm;
 
 2799    context->InvokeService(context, _OrthancPluginService_SendUnauthorized, ¶ms);
 
 
 2817    const char*              allowedMethods)
 
 2819    _OrthancPluginOutputPlusArgument params;
 
 2820    params.output = output;
 
 2821    params.argument = allowedMethods;
 
 2822    context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, ¶ms);
 
 
 2831  } _OrthancPluginSetHttpHeader;
 
 2850    _OrthancPluginSetHttpHeader params;
 
 2851    params.output = output;
 
 2852    params.key = cookie;
 
 2853    params.value = value;
 
 2854    context->InvokeService(context, _OrthancPluginService_SetCookie, ¶ms);
 
 
 2875    _OrthancPluginSetHttpHeader params;
 
 2876    params.output = output;
 
 2878    params.value = value;
 
 2879    context->InvokeService(context, _OrthancPluginService_SetHttpHeader, ¶ms);
 
 
 2885    char**                             resultStringToFree;
 
 2886    const char**                       resultString;
 
 2887    int64_t*                           resultInt64;
 
 2891  } _OrthancPluginAccessDicomInstance;
 
 2911    _OrthancPluginAccessDicomInstance params;
 
 2912    memset(¶ms, 0, 
sizeof(params));
 
 2913    params.resultString = &result;
 
 2914    params.instance = instance;
 
 
 2944    _OrthancPluginAccessDicomInstance params;
 
 2945    memset(¶ms, 0, 
sizeof(params));
 
 2946    params.resultInt64 = &size;
 
 2947    params.instance = instance;
 
 
 2977    _OrthancPluginAccessDicomInstance params;
 
 2978    memset(¶ms, 0, 
sizeof(params));
 
 2979    params.resultString = &result;
 
 2980    params.instance = instance;
 
 
 3013    _OrthancPluginAccessDicomInstance params;
 
 3014    memset(¶ms, 0, 
sizeof(params));
 
 3015    params.resultStringToFree = &result;
 
 3016    params.instance = instance;
 
 
 3051    _OrthancPluginAccessDicomInstance params;
 
 3052    memset(¶ms, 0, 
sizeof(params));
 
 3053    params.resultStringToFree = &result;
 
 3054    params.instance = instance;
 
 
 3087    const char*                        metadata)
 
 3091    _OrthancPluginAccessDicomInstance params;
 
 3092    memset(¶ms, 0, 
sizeof(params));
 
 3093    params.resultInt64 = &result;
 
 3094    params.instance = instance;
 
 3095    params.key = metadata;
 
 3104      return (result != 0);
 
 
 3128    const char*                        metadata)
 
 3132    _OrthancPluginAccessDicomInstance params;
 
 3133    memset(¶ms, 0, 
sizeof(params));
 
 3134    params.resultString = &result;
 
 3135    params.instance = instance;
 
 3136    params.key = metadata;
 
 
 3157  } _OrthancPluginRegisterStorageArea;
 
 3180    _OrthancPluginRegisterStorageArea params;
 
 3181    params.create = create;
 
 3183    params.remove = remove;
 
 3186    params.free = ::free;
 
 3191    context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, ¶ms);
 
 
 3210    _OrthancPluginRetrieveDynamicString params;
 
 3211    params.result = &result;
 
 3212    params.argument = NULL;
 
 
 3240    _OrthancPluginRetrieveDynamicString params;
 
 3241    params.result = &result;
 
 3242    params.argument = NULL;
 
 
 3275    _OrthancPluginRetrieveDynamicString params;
 
 3276    params.result = &result;
 
 3277    params.argument = NULL;
 
 
 3295  } _OrthancPluginOnChangeCallback;
 
 3321    _OrthancPluginOnChangeCallback params;
 
 3322    params.callback = callback;
 
 3324    context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, ¶ms);
 
 
 3332    _OrthancPluginProperty property;
 
 3334  } _OrthancPluginSetPluginProperty;
 
 3352    _OrthancPluginSetPluginProperty params;
 
 3353    params.plugin = OrthancPluginGetName();
 
 3354    params.property = _OrthancPluginProperty_RootUri;
 
 3357    context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
 
 
 3372    const char*            description)
 
 3374    _OrthancPluginSetPluginProperty params;
 
 3375    params.plugin = OrthancPluginGetName();
 
 3376    params.property = _OrthancPluginProperty_Description;
 
 3377    params.value = description;
 
 3379    context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
 
 
 3394    const char*            javascript)
 
 3396    _OrthancPluginSetPluginProperty params;
 
 3397    params.plugin = OrthancPluginGetName();
 
 3398    params.property = _OrthancPluginProperty_OrthancExplorer;
 
 3399    params.value = javascript;
 
 3401    context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
 
 
 3410  } _OrthancPluginGlobalProperty;
 
 3429    const char*            defaultValue)
 
 3433    _OrthancPluginGlobalProperty params;
 
 3434    params.result = &result;
 
 3435    params.property = property;
 
 3436    params.value = defaultValue;
 
 
 3470    _OrthancPluginGlobalProperty params;
 
 3471    params.result = NULL;
 
 3472    params.property = property;
 
 3473    params.value = value;
 
 3475    return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, ¶ms);
 
 
 3482    int32_t   *resultInt32;
 
 3483    uint32_t  *resultUint32;
 
 3484    int64_t   *resultInt64;
 
 3485    uint64_t  *resultUint64;
 
 3486  } _OrthancPluginReturnSingleValue;
 
 3501    _OrthancPluginReturnSingleValue params;
 
 3502    memset(¶ms, 0, 
sizeof(params));
 
 3503    params.resultUint32 = &count;
 
 
 3536    _OrthancPluginGlobalProperty params;
 
 3537    params.result = &result;
 
 3538    params.property = (int32_t) argument;
 
 3539    params.value = NULL;
 
 
 3567    _OrthancPluginReturnSingleValue params;
 
 3568    memset(¶ms, 0, 
sizeof(params));
 
 3569    params.resultUint32 = &count;
 
 
 3599    _OrthancPluginRetrieveDynamicString params;
 
 3600    params.result = &result;
 
 3601    params.argument = NULL;
 
 
 3619    const char*              subType;
 
 3620    const char*              contentType;
 
 3621  } _OrthancPluginStartMultipartAnswer;
 
 3639    const char*              subType,
 
 3640    const char*              contentType)
 
 3642    _OrthancPluginStartMultipartAnswer params;
 
 3643    params.output = output;
 
 3644    params.subType = subType;
 
 3645    params.contentType = contentType;
 
 3646    return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, ¶ms);
 
 
 3669    uint32_t                 answerSize)
 
 3671    _OrthancPluginAnswerBuffer params;
 
 3672    params.output = output;
 
 3673    params.answer = answer;
 
 3674    params.answerSize = answerSize;
 
 3675    params.mimeType = NULL;
 
 3676    return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, ¶ms);
 
 
 3688  } _OrthancPluginBufferCompression;
 
 3715    _OrthancPluginBufferCompression params;
 
 3716    params.target = target;
 
 3717    params.source = source;
 
 3719    params.compression = compression;
 
 3720    params.uncompress = uncompress;
 
 3722    return context->InvokeService(context, _OrthancPluginService_BufferCompression, ¶ms);
 
 
 3731  } _OrthancPluginReadFile;
 
 3749    _OrthancPluginReadFile params;
 
 3750    params.target = target;
 
 3752    return context->InvokeService(context, _OrthancPluginService_ReadFile, ¶ms);
 
 
 3762  } _OrthancPluginWriteFile;
 
 3781    _OrthancPluginWriteFile params;
 
 3785    return context->InvokeService(context, _OrthancPluginService_WriteFile, ¶ms);
 
 
 3792    const char**            target;
 
 3794  } _OrthancPluginGetErrorDescription;
 
 3810    const char* result = NULL;
 
 3812    _OrthancPluginGetErrorDescription params;
 
 3813    params.target = &result;
 
 3814    params.error = error;
 
 3819      return "Unknown error code";
 
 
 3835  } _OrthancPluginSendHttpStatus;
 
 3866    _OrthancPluginSendHttpStatus params;
 
 3867    params.output = output;
 
 3868    params.status = status;
 
 3870    params.bodySize = bodySize;
 
 3871    context->InvokeService(context, _OrthancPluginService_SendHttpStatus, ¶ms);
 
 
 3879    uint32_t*                  resultUint32;
 
 3881    void**                     resultBuffer;
 
 3882  } _OrthancPluginGetImageInfo;
 
 3901    _OrthancPluginGetImageInfo params;
 
 3902    memset(¶ms, 0, 
sizeof(params));
 
 3903    params.image = image;
 
 3904    params.resultPixelFormat = ⌖
 
 
 3934    _OrthancPluginGetImageInfo params;
 
 3935    memset(¶ms, 0, 
sizeof(params));
 
 3936    params.image = image;
 
 3937    params.resultUint32 = &width;
 
 
 3967    _OrthancPluginGetImageInfo params;
 
 3968    memset(¶ms, 0, 
sizeof(params));
 
 3969    params.image = image;
 
 3970    params.resultUint32 = &height;
 
 
 4002    _OrthancPluginGetImageInfo params;
 
 4003    memset(¶ms, 0, 
sizeof(params));
 
 4004    params.image = image;
 
 4005    params.resultUint32 = &pitch;
 
 
 4034    void* target = NULL;
 
 4036    _OrthancPluginGetImageInfo params;
 
 4037    memset(¶ms, 0, 
sizeof(params));
 
 4038    params.resultBuffer = ⌖
 
 4039    params.image = image;
 
 
 4058  } _OrthancPluginUncompressImage;
 
 4081    _OrthancPluginUncompressImage params;
 
 4082    memset(¶ms, 0, 
sizeof(params));
 
 4083    params.target = ⌖
 
 4086    params.format = format;
 
 
 4104  } _OrthancPluginFreeImage;
 
 4119    _OrthancPluginFreeImage params;
 
 4120    params.image = image;
 
 4122    context->InvokeService(context, _OrthancPluginService_FreeImage, ¶ms);
 
 
 4138  } _OrthancPluginCompressImage;
 
 4169    _OrthancPluginCompressImage params;
 
 4170    memset(¶ms, 0, 
sizeof(params));
 
 4171    params.target = target;
 
 4173    params.pixelFormat = format;
 
 4174    params.width = width;
 
 4175    params.height = height;
 
 4176    params.pitch = pitch;
 
 4177    params.buffer = buffer;
 
 4180    return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
 
 
 4215    _OrthancPluginCompressImage params;
 
 4216    memset(¶ms, 0, 
sizeof(params));
 
 4217    params.target = target;
 
 4219    params.pixelFormat = format;
 
 4220    params.width = width;
 
 4221    params.height = height;
 
 4222    params.pitch = pitch;
 
 4223    params.buffer = buffer;
 
 4224    params.quality = quality;
 
 4226    return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
 
 
 4262    _OrthancPluginCompressAndAnswerImage params;
 
 4263    params.output = output;
 
 4265    params.pixelFormat = format;
 
 4266    params.width = width;
 
 4267    params.height = height;
 
 4268    params.pitch = pitch;
 
 4269    params.buffer = buffer;
 
 4270    params.quality = quality;
 
 4271    context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
 
 
 4282    const char*                 username;
 
 4283    const char*                 password;
 
 4286  } _OrthancPluginCallHttpClient;
 
 4309    const char*                 username,
 
 4310    const char*                 password)
 
 4312    _OrthancPluginCallHttpClient params;
 
 4313    memset(¶ms, 0, 
sizeof(params));
 
 4315    params.target = target;
 
 4318    params.username = username;
 
 4319    params.password = password;
 
 4321    return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
 
 
 4349    const char*                 username,
 
 4350    const char*                 password)
 
 4352    _OrthancPluginCallHttpClient params;
 
 4353    memset(¶ms, 0, 
sizeof(params));
 
 4355    params.target = target;
 
 4359    params.bodySize = bodySize;
 
 4360    params.username = username;
 
 4361    params.password = password;
 
 4363    return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
 
 
 4391    const char*                 username,
 
 4392    const char*                 password)
 
 4394    _OrthancPluginCallHttpClient params;
 
 4395    memset(¶ms, 0, 
sizeof(params));
 
 4397    params.target = target;
 
 4401    params.bodySize = bodySize;
 
 4402    params.username = username;
 
 4403    params.password = password;
 
 4405    return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
 
 
 4426    const char*                 username,
 
 4427    const char*                 password)
 
 4429    _OrthancPluginCallHttpClient params;
 
 4430    memset(¶ms, 0, 
sizeof(params));
 
 4434    params.username = username;
 
 4435    params.password = password;
 
 4437    return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
 
 
 4447  } _OrthancPluginConvertPixelFormat;
 
 4468    _OrthancPluginConvertPixelFormat params;
 
 4469    params.target = ⌖
 
 4470    params.source = source;
 
 4471    params.targetFormat = targetFormat;
 
 
 4501    _OrthancPluginReturnSingleValue params;
 
 4502    memset(¶ms, 0, 
sizeof(params));
 
 4503    params.resultUint32 = &count;
 
 
 4524  } _OrthancPluginGetFontInfo;
 
 4540    const char* result = NULL;
 
 4542    _OrthancPluginGetFontInfo params;
 
 4543    memset(¶ms, 0, 
sizeof(params));
 
 4544    params.name = &result;
 
 4545    params.fontIndex = fontIndex;
 
 
 4574    _OrthancPluginGetFontInfo params;
 
 4575    memset(¶ms, 0, 
sizeof(params));
 
 4576    params.size = &result;
 
 4577    params.fontIndex = fontIndex;
 
 
 4595    const char*           utf8Text;
 
 4601  } _OrthancPluginDrawText;
 
 4625    const char*            utf8Text,
 
 4632    _OrthancPluginDrawText params;
 
 4633    memset(¶ms, 0, 
sizeof(params));
 
 4634    params.image = image;
 
 4635    params.fontIndex = fontIndex;
 
 4636    params.utf8Text = utf8Text;
 
 4643    return context->InvokeService(context, _OrthancPluginService_DrawText, ¶ms);
 
 
 4652    const void*                 content;
 
 4655  } _OrthancPluginStorageAreaCreate;
 
 4679    const void*                 content,
 
 4683    _OrthancPluginStorageAreaCreate params;
 
 4684    params.storageArea = storageArea;
 
 4686    params.content = content;
 
 4690    return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, ¶ms);
 
 
 4700  } _OrthancPluginStorageAreaRead;
 
 4726    _OrthancPluginStorageAreaRead params;
 
 4727    params.target = target;
 
 4728    params.storageArea = storageArea;
 
 4732    return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, ¶ms);
 
 
 4741  } _OrthancPluginStorageAreaRemove;
 
 4764    _OrthancPluginStorageAreaRemove params;
 
 4765    params.storageArea = storageArea;
 
 4769    return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, ¶ms);
 
 
 4778    uint16_t                 httpStatus;
 
 4779    const char*              message;
 
 4780  } _OrthancPluginRegisterErrorCode;
 
 4800    uint16_t                 httpStatus,
 
 4801    const char*              message)
 
 4805    _OrthancPluginRegisterErrorCode params;
 
 4806    params.target = ⌖
 
 4808    params.httpStatus = httpStatus;
 
 4809    params.message = message;
 
 
 4830    uint32_t                          minMultiplicity;
 
 4831    uint32_t                          maxMultiplicity;
 
 4832  } _OrthancPluginRegisterDictionaryTag;
 
 4859    uint32_t                          minMultiplicity,
 
 4860    uint32_t                          maxMultiplicity)
 
 4862    _OrthancPluginRegisterDictionaryTag params;
 
 4863    params.group = group;
 
 4864    params.element = element;
 
 4867    params.minMultiplicity = minMultiplicity;
 
 4868    params.maxMultiplicity = maxMultiplicity;
 
 4870    return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, ¶ms);
 
 
 4881    uint32_t                          minMultiplicity;
 
 4882    uint32_t                          maxMultiplicity;
 
 4883    const char*                       privateCreator;
 
 4884  } _OrthancPluginRegisterPrivateDictionaryTag;
 
 4912    uint32_t                          minMultiplicity,
 
 4913    uint32_t                          maxMultiplicity,
 
 4914    const char*                       privateCreator)
 
 4916    _OrthancPluginRegisterPrivateDictionaryTag params;
 
 4917    params.group = group;
 
 4918    params.element = element;
 
 4921    params.minMultiplicity = minMultiplicity;
 
 4922    params.maxMultiplicity = maxMultiplicity;
 
 4923    params.privateCreator = privateCreator;
 
 4925    return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, ¶ms);
 
 
 4934  } _OrthancPluginReconstructMainDicomTags;
 
 4955    _OrthancPluginReconstructMainDicomTags params;
 
 4956    params.level = level;
 
 4957    params.storageArea = storageArea;
 
 4959    return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, ¶ms);
 
 
 4966    const char*                     instanceId;
 
 4971    uint32_t                        maxStringLength;
 
 4972  } _OrthancPluginDicomToJson;
 
 5000    uint32_t                        maxStringLength)
 
 5004    _OrthancPluginDicomToJson params;
 
 5005    memset(¶ms, 0, 
sizeof(params));
 
 5006    params.result = &result;
 
 5007    params.buffer = buffer;
 
 5009    params.format = format;
 
 5010    params.flags = flags;
 
 5011    params.maxStringLength = maxStringLength;
 
 
 5045    const char*                     instanceId,
 
 5048    uint32_t                        maxStringLength)
 
 5052    _OrthancPluginDicomToJson params;
 
 5053    memset(¶ms, 0, 
sizeof(params));
 
 5054    params.result = &result;
 
 5055    params.instanceId = instanceId;
 
 5056    params.format = format;
 
 5057    params.flags = flags;
 
 5058    params.maxStringLength = maxStringLength;
 
 
 5076    uint32_t                    headersCount;
 
 5077    const char* 
const*          headersKeys;
 
 5078    const char* 
const*          headersValues;
 
 5079    int32_t                     afterPlugins;
 
 5080  } _OrthancPluginRestApiGet2;
 
 5105    uint32_t                    headersCount,
 
 5106    const char* 
const*          headersKeys,
 
 5107    const char* 
const*          headersValues,
 
 5108    int32_t                     afterPlugins)
 
 5110    _OrthancPluginRestApiGet2 params;
 
 5111    params.target = target;
 
 5113    params.headersCount = headersCount;
 
 5114    params.headersKeys = headersKeys;
 
 5115    params.headersValues = headersValues;
 
 5116    params.afterPlugins = afterPlugins;
 
 5118    return context->InvokeService(context, _OrthancPluginService_RestApiGet2, ¶ms);
 
 
 5126  } _OrthancPluginWorklistCallback;
 
 5143    _OrthancPluginWorklistCallback params;
 
 5144    params.callback = callback;
 
 5146    return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, ¶ms);
 
 
 5157  } _OrthancPluginWorklistAnswersOperation;
 
 5182    _OrthancPluginWorklistAnswersOperation params;
 
 5183    params.answers = answers;
 
 5184    params.query = query;
 
 5185    params.dicom = dicom;
 
 5188    return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, ¶ms);
 
 
 5209    _OrthancPluginWorklistAnswersOperation params;
 
 5210    params.answers = answers;
 
 5211    params.query = NULL;
 
 5212    params.dicom = NULL;
 
 5215    return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, ¶ms);
 
 
 5226  } _OrthancPluginWorklistQueryOperation;
 
 5249    int32_t isMatch = 0;
 
 5251    _OrthancPluginWorklistQueryOperation params;
 
 5252    params.query = query;
 
 5253    params.dicom = dicom;
 
 5255    params.isMatch = &isMatch;
 
 5256    params.target = NULL;
 
 
 5287    _OrthancPluginWorklistQueryOperation params;
 
 5288    params.query = query;
 
 5289    params.dicom = NULL;
 
 5291    params.isMatch = NULL;
 
 5292    params.target = target;
 
 5294    return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, ¶ms);
 
 
 5314    _OrthancPluginAccessDicomInstance params;
 
 5315    memset(¶ms, 0, 
sizeof(params));
 
 5316    params.resultOrigin = &origin;
 
 5317    params.instance = instance;
 
 
 5337  } _OrthancPluginCreateDicom;
 
 5371    _OrthancPluginCreateDicom params;
 
 5372    params.target = target;
 
 5374    params.pixelData = pixelData;
 
 5375    params.flags = flags;
 
 5377    return context->InvokeService(context, _OrthancPluginService_CreateDicom, ¶ms);
 
 
 5384  } _OrthancPluginDecodeImageCallback;
 
 5404    _OrthancPluginDecodeImageCallback params;
 
 5405    params.callback = callback;
 
 5407    return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, ¶ms);
 
 
 5420    const void*                constBuffer;
 
 5421    uint32_t                   bufferSize;
 
 5422    uint32_t                   frameIndex;
 
 5423  } _OrthancPluginCreateImage;
 
 5446    _OrthancPluginCreateImage params;
 
 5447    memset(¶ms, 0, 
sizeof(params));
 
 5448    params.target = ⌖
 
 5449    params.format = format;
 
 5450    params.width = width;
 
 5451    params.height = height;
 
 
 5491    _OrthancPluginCreateImage params;
 
 5492    memset(¶ms, 0, 
sizeof(params));
 
 5493    params.target = ⌖
 
 5494    params.format = format;
 
 5495    params.width = width;
 
 5496    params.height = height;
 
 5497    params.pitch = pitch;
 
 5498    params.buffer = buffer;
 
 
 5530    uint32_t               bufferSize,
 
 5531    uint32_t               frameIndex)
 
 5535    _OrthancPluginCreateImage params;
 
 5536    memset(¶ms, 0, 
sizeof(params));
 
 5537    params.target = ⌖
 
 5538    params.constBuffer = buffer;
 
 5539    params.bufferSize = bufferSize;
 
 5540    params.frameIndex = frameIndex;
 
 
 5559  } _OrthancPluginComputeHash;
 
 5580    _OrthancPluginComputeHash params;
 
 5581    params.result = &result;
 
 5582    params.buffer = buffer;
 
 
 5616    _OrthancPluginComputeHash params;
 
 5617    params.result = &result;
 
 5618    params.buffer = buffer;
 
 
 5638  } _OrthancPluginLookupDictionary;
 
 5660    _OrthancPluginLookupDictionary params;
 
 5661    params.target = target;
 
 5663    return context->InvokeService(context, _OrthancPluginService_LookupDictionary, ¶ms);
 
 
 5672    uint32_t                 answerSize;
 
 5673    uint32_t                 headersCount;
 
 5674    const char* 
const*       headersKeys;
 
 5675    const char* 
const*       headersValues;
 
 5676  } _OrthancPluginSendMultipartItem2;
 
 5702    uint32_t                 answerSize,
 
 5703    uint32_t                 headersCount,
 
 5704    const char* 
const*       headersKeys,
 
 5705    const char* 
const*       headersValues)
 
 5707    _OrthancPluginSendMultipartItem2 params;
 
 5708    params.output = output;
 
 5709    params.answer = answer;
 
 5710    params.answerSize = answerSize;
 
 5711    params.headersCount = headersCount;
 
 5712    params.headersKeys = headersKeys;
 
 5713    params.headersValues = headersValues;    
 
 5715    return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, ¶ms);
 
 
 5722  } _OrthancPluginIncomingHttpRequestFilter;
 
 5740    _OrthancPluginIncomingHttpRequestFilter params;
 
 5741    params.callback = callback;
 
 5743    return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, ¶ms);
 
 
 5752    uint16_t*                   httpStatus;
 
 5755    uint32_t                    headersCount;
 
 5756    const char* 
const*          headersKeys;
 
 5757    const char* 
const*          headersValues;
 
 5760    const char*                 username;
 
 5761    const char*                 password;
 
 5763    const char*                 certificateFile;
 
 5764    const char*                 certificateKeyFile;
 
 5765    const char*                 certificateKeyPassword;
 
 5767  } _OrthancPluginCallHttpClient2;
 
 5815    uint16_t*                   httpStatus,
 
 5818    uint32_t                    headersCount,
 
 5819    const char* 
const*          headersKeys,
 
 5820    const char* 
const*          headersValues,
 
 5823    const char*                 username,
 
 5824    const char*                 password,
 
 5826    const char*                 certificateFile,
 
 5827    const char*                 certificateKeyFile,
 
 5828    const char*                 certificateKeyPassword,
 
 5831    _OrthancPluginCallHttpClient2 params;
 
 5832    memset(¶ms, 0, 
sizeof(params));
 
 5834    params.answerBody = answerBody;
 
 5835    params.answerHeaders = answerHeaders;
 
 5836    params.httpStatus = httpStatus;
 
 5837    params.method = method;
 
 5839    params.headersCount = headersCount;
 
 5840    params.headersKeys = headersKeys;
 
 5841    params.headersValues = headersValues;
 
 5843    params.bodySize = bodySize;
 
 5844    params.username = username;
 
 5845    params.password = password;
 
 5846    params.timeout = timeout;
 
 5847    params.certificateFile = certificateFile;
 
 5848    params.certificateKeyFile = certificateKeyFile;
 
 5849    params.certificateKeyPassword = certificateKeyPassword;
 
 5850    params.pkcs11 = pkcs11;
 
 5852    return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, ¶ms);
 
 
 5871    _OrthancPluginRetrieveDynamicString params;
 
 5872    params.result = &result;
 
 5873    params.argument = NULL;
 
 
 5892  } _OrthancPluginFindCallback;
 
 5909    _OrthancPluginFindCallback params;
 
 5910    params.callback = callback;
 
 5912    return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, ¶ms);
 
 
 5923    uint32_t                      *resultUint32;
 
 5924    uint16_t                      *resultGroup;
 
 5925    uint16_t                      *resultElement;
 
 5926    char                         **resultString;
 
 5927  } _OrthancPluginFindOperation;
 
 5950    _OrthancPluginFindOperation params;
 
 5951    memset(¶ms, 0, 
sizeof(params));
 
 5952    params.answers = answers;
 
 5953    params.dicom = dicom;
 
 5956    return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, ¶ms);
 
 
 5977    _OrthancPluginFindOperation params;
 
 5978    memset(¶ms, 0, 
sizeof(params));
 
 5979    params.answers = answers;
 
 5981    return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, ¶ms);
 
 
 6003    _OrthancPluginFindOperation params;
 
 6004    memset(¶ms, 0, 
sizeof(params));
 
 6005    params.query = query;
 
 6006    params.resultUint32 = &count;
 
 
 6041    _OrthancPluginFindOperation params;
 
 6042    memset(¶ms, 0, 
sizeof(params));
 
 6043    params.query = query;
 
 6044    params.index = index;
 
 6045    params.resultGroup = group;
 
 6046    params.resultElement = element;
 
 6048    return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, ¶ms);
 
 
 6072    _OrthancPluginFindOperation params;
 
 6073    memset(¶ms, 0, 
sizeof(params));
 
 6074    params.query = query;
 
 6075    params.index = index;
 
 6076    params.resultString = &result;
 
 
 6110    _OrthancPluginFindOperation params;
 
 6111    memset(¶ms, 0, 
sizeof(params));
 
 6112    params.query = query;
 
 6113    params.index = index;
 
 6114    params.resultString = &result;
 
 
 6136  } _OrthancPluginMoveCallback;
 
 6158    _OrthancPluginMoveCallback params;
 
 6159    params.callback = callback;
 
 6160    params.getMoveSize = getMoveSize;
 
 6161    params.applyMove = applyMove;
 
 6162    params.freeMove = freeMove;
 
 6164    return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, ¶ms);
 
 
 6174  } _OrthancPluginCreateFindMatcher;
 
 6197    _OrthancPluginCreateFindMatcher params;
 
 6198    memset(¶ms, 0, 
sizeof(params));
 
 6199    params.target = ⌖
 
 6200    params.query = query;
 
 
 6217  } _OrthancPluginFreeFindMatcher;
 
 6232    _OrthancPluginFreeFindMatcher params;
 
 6233    params.matcher = matcher;
 
 6235    context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, ¶ms);
 
 
 6245  } _OrthancPluginFindMatcherIsMatch;
 
 6267    int32_t isMatch = 0;
 
 6269    _OrthancPluginFindMatcherIsMatch params;
 
 6270    params.matcher = matcher;
 
 6271    params.dicom = dicom;
 
 6273    params.isMatch = &isMatch;
 
 
 6290  } _OrthancPluginIncomingHttpRequestFilter2;
 
 6307    _OrthancPluginIncomingHttpRequestFilter2 params;
 
 6308    params.callback = callback;
 
 6310    return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, ¶ms);
 
 
 6318  } _OrthancPluginGetPeers;
 
 6336    _OrthancPluginGetPeers params;
 
 6337    memset(¶ms, 0, 
sizeof(params));
 
 6338    params.peers = &peers;
 
 
 6354  } _OrthancPluginFreePeers;
 
 6369    _OrthancPluginFreePeers params;
 
 6370    params.peers = peers;
 
 6372    context->InvokeService(context, _OrthancPluginService_FreePeers, ¶ms);
 
 
 6380  } _OrthancPluginGetPeersCount;
 
 6399    uint32_t target = 0;
 
 6401    _OrthancPluginGetPeersCount params;
 
 6402    memset(¶ms, 0, 
sizeof(params));
 
 6403    params.target = ⌖
 
 6404    params.peers = peers;
 
 
 6420    const char**               target;
 
 6423    const char*                userProperty;
 
 6424  } _OrthancPluginGetPeerProperty;
 
 6448    const char* target = NULL;
 
 6450    _OrthancPluginGetPeerProperty params;
 
 6451    memset(¶ms, 0, 
sizeof(params));
 
 6452    params.target = ⌖
 
 6453    params.peers = peers;
 
 6454    params.peerIndex = peerIndex;
 
 6455    params.userProperty = NULL;
 
 
 6489    const char* target = NULL;
 
 6491    _OrthancPluginGetPeerProperty params;
 
 6492    memset(¶ms, 0, 
sizeof(params));
 
 6493    params.target = ⌖
 
 6494    params.peers = peers;
 
 6495    params.peerIndex = peerIndex;
 
 6496    params.userProperty = NULL;
 
 
 6534    const char*                userProperty)
 
 6536    const char* target = NULL;
 
 6538    _OrthancPluginGetPeerProperty params;
 
 6539    memset(¶ms, 0, 
sizeof(params));
 
 6540    params.target = ⌖
 
 6541    params.peers = peers;
 
 6542    params.peerIndex = peerIndex;
 
 6543    params.userProperty = userProperty;
 
 
 6562    uint16_t*                   httpStatus;
 
 6567    uint32_t                    additionalHeadersCount;
 
 6568    const char* 
const*          additionalHeadersKeys;
 
 6569    const char* 
const*          additionalHeadersValues;
 
 6573  } _OrthancPluginCallPeerApi;
 
 6615    uint16_t*                   httpStatus,
 
 6620    uint32_t                    additionalHeadersCount,
 
 6621    const char* 
const*          additionalHeadersKeys,
 
 6622    const char* 
const*          additionalHeadersValues,
 
 6627    _OrthancPluginCallPeerApi params;
 
 6628    memset(¶ms, 0, 
sizeof(params));
 
 6630    params.answerBody = answerBody;
 
 6631    params.answerHeaders = answerHeaders;
 
 6632    params.httpStatus = httpStatus;
 
 6633    params.peers = peers;
 
 6634    params.peerIndex = peerIndex;
 
 6635    params.method = method;
 
 6637    params.additionalHeadersCount = additionalHeadersCount;
 
 6638    params.additionalHeadersKeys = additionalHeadersKeys;
 
 6639    params.additionalHeadersValues = additionalHeadersValues;
 
 6641    params.bodySize = bodySize;
 
 6642    params.timeout = timeout;
 
 6644    return context->InvokeService(context, _OrthancPluginService_CallPeerApi, ¶ms);
 
 
 6663  } _OrthancPluginCreateJob;
 
 6710    _OrthancPluginCreateJob params;
 
 6711    memset(¶ms, 0, 
sizeof(params));
 
 6713    params.target = ⌖
 
 6715    params.finalize = finalize;
 
 6717    params.getProgress = getProgress;
 
 6718    params.getContent = getContent;
 
 6719    params.getSerialized = getSerialized;
 
 6722    params.reset = reset;
 
 
 6740  } _OrthancPluginFreeJob;
 
 6755    _OrthancPluginFreeJob params;
 
 6758    context->InvokeService(context, _OrthancPluginService_FreeJob, ¶ms);
 
 
 6768  } _OrthancPluginSubmitJob;
 
 6788    char* resultId = NULL;
 
 6790    _OrthancPluginSubmitJob params;
 
 6791    memset(¶ms, 0, 
sizeof(params));
 
 6793    params.resultId = &resultId;
 
 6795    params.priority = priority;
 
 
 6814  } _OrthancPluginJobsUnserializer;
 
 6832    _OrthancPluginJobsUnserializer params;
 
 6833    params.unserializer = unserializer;
 
 6835    context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, ¶ms);
 
 
 6843    const char*              details;
 
 6845  } _OrthancPluginSetHttpErrorDetails;
 
 6867    const char*              details,
 
 6870    _OrthancPluginSetHttpErrorDetails params;
 
 6871    params.output = output;
 
 6872    params.details = details;
 
 6874    context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, ¶ms);
 
 
 6881    const char** result;
 
 6882    const char*  argument;
 
 6883  } _OrthancPluginRetrieveStaticString;
 
 6900    const char* result = NULL;
 
 6902    _OrthancPluginRetrieveStaticString params;
 
 6903    params.result = &result;
 
 6904    params.argument = path;
 
 
 6924  } _OrthancPluginSetMetricsValue;
 
 6946    _OrthancPluginSetMetricsValue params;
 
 6948    params.value = value;
 
 6950    context->InvokeService(context, _OrthancPluginService_SetMetricsValue, ¶ms);
 
 
 6958  } _OrthancPluginRegisterRefreshMetricsCallback;
 
 6974    _OrthancPluginRegisterRefreshMetricsCallback params;
 
 6975    params.callback = callback;
 
 6976    context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, ¶ms);
 
 
 6988  } _OrthancPluginEncodeDicomWeb;
 
 7012    char* target = NULL;
 
 7014    _OrthancPluginEncodeDicomWeb params;
 
 7015    params.target = ⌖
 
 7016    params.dicom = dicom;
 
 7017    params.dicomSize = dicomSize;
 
 7018    params.callback = callback;
 
 
 7054    char* target = NULL;
 
 7056    _OrthancPluginEncodeDicomWeb params;
 
 7057    params.target = ⌖
 
 7058    params.dicom = dicom;
 
 7059    params.dicomSize = dicomSize;
 
 7060    params.callback = callback;
 
 
 7082  } _OrthancPluginEncodeDicomWeb2;
 
 7107    char* target = NULL;
 
 7109    _OrthancPluginEncodeDicomWeb2 params;
 
 7110    params.target = ⌖
 
 7111    params.dicom = dicom;
 
 7112    params.dicomSize = dicomSize;
 
 7113    params.callback = callback;
 
 7114    params.payload = payload;
 
 
 7151    char* target = NULL;
 
 7153    _OrthancPluginEncodeDicomWeb2 params;
 
 7154    params.target = ⌖
 
 7155    params.dicom = dicom;
 
 7156    params.dicomSize = dicomSize;
 
 7157    params.callback = callback;
 
 7158    params.payload = payload;
 
 
 7262  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (
void* request);
 
 7286    uint16_t*                                      httpStatus;
 
 7289    uint32_t                                       headersCount;
 
 7290    const char* 
const*                             headersKeys;
 
 7291    const char* 
const*                             headersValues;
 
 7297    const char*                                    username;
 
 7298    const char*                                    password;
 
 7300    const char*                                    certificateFile;
 
 7301    const char*                                    certificateKeyFile;
 
 7302    const char*                                    certificateKeyPassword;
 
 7304  } _OrthancPluginChunkedHttpClient;
 
 7362    uint16_t*                                      httpStatus,
 
 7365    uint32_t                                       headersCount,
 
 7366    const char* 
const*                             headersKeys,
 
 7367    const char* 
const*                             headersValues,
 
 7373    const char*                                    username,
 
 7374    const char*                                    password,
 
 7376    const char*                                    certificateFile,
 
 7377    const char*                                    certificateKeyFile,
 
 7378    const char*                                    certificateKeyPassword,
 
 7381    _OrthancPluginChunkedHttpClient params;
 
 7382    memset(¶ms, 0, 
sizeof(params));
 
 7385    params.httpStatus = httpStatus;
 
 7386    params.method = method;
 
 7388    params.headersCount = headersCount;
 
 7389    params.headersKeys = headersKeys;
 
 7390    params.headersValues = headersValues;
 
 7391    params.username = username;
 
 7392    params.password = password;
 
 7393    params.timeout = timeout;
 
 7394    params.certificateFile = certificateFile;
 
 7395    params.certificateKeyFile = certificateKeyFile;
 
 7396    params.certificateKeyPassword = certificateKeyPassword;
 
 7397    params.pkcs11 = pkcs11;
 
 7400    params.answer = answer;
 
 7401    params.answerAddChunk = answerAddChunk;
 
 7402    params.answerAddHeader = answerAddHeader;
 
 7403    params.request = request;
 
 7404    params.requestIsDone = requestIsDone;
 
 7405    params.requestChunkData = requestChunkData;
 
 7406    params.requestChunkSize = requestChunkSize;
 
 7407    params.requestNext = requestNext;
 
 7409    return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, ¶ms);
 
 
 7499    const char*                                      pathRegularExpression;
 
 7507  } _OrthancPluginChunkedRestCallback;
 
 7541    const char*                                      pathRegularExpression,
 
 7550    _OrthancPluginChunkedRestCallback params;
 
 7551    params.pathRegularExpression = pathRegularExpression;
 
 7552    params.getHandler = getHandler;
 
 7553    params.postHandler = postHandler;
 
 7554    params.deleteHandler = deleteHandler;
 
 7555    params.putHandler = putHandler;
 
 7556    params.addChunk = addChunk;
 
 7557    params.execute = execute;
 
 7558    params.finalize = finalize;
 
 7560    context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, ¶ms);
 
 
 7572    const char*  privateCreator;
 
 7573  } _OrthancPluginGetTagName;
 
 7594    const char*            privateCreator)
 
 7598    _OrthancPluginGetTagName params;
 
 7599    params.result = &result;
 
 7600    params.group = group;
 
 7601    params.element = element;
 
 7602    params.privateCreator = privateCreator;
 
 
 7648    const char*         transactionUid,
 
 7649    const char* 
const*  sopClassUids,
 
 7650    const char* 
const*  sopInstanceUids,
 
 7651    uint32_t            countInstances,
 
 7652    const char*         remoteAet,
 
 7653    const char*         calledAet);
 
 7691    const char* sopClassUid,
 
 7692    const char* sopInstanceUid);
 
 7700  } _OrthancPluginRegisterStorageCommitmentScpCallback;
 
 7721    _OrthancPluginRegisterStorageCommitmentScpCallback params;
 
 7722    params.factory = factory;
 
 7723    params.destructor = destructor;
 
 7724    params.lookup = lookup;
 
 7725    return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, ¶ms);
 
 
 7762  } _OrthancPluginIncomingDicomInstanceFilter;
 
 7780    _OrthancPluginIncomingDicomInstanceFilter params;
 
 7781    params.callback = callback;
 
 7783    return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, ¶ms);
 
 
 7818    uint16_t* dimseStatus ,
 
 7825  } _OrthancPluginIncomingCStoreInstanceFilter;
 
 7843    _OrthancPluginIncomingCStoreInstanceFilter params;
 
 7844    params.callback = callback;
 
 7846    return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, ¶ms);
 
 
 7886    const void* receivedDicomBuffer,
 
 7887    uint64_t receivedDicomBufferSize,
 
 7894  } _OrthancPluginReceivedInstanceCallback;
 
 7920    _OrthancPluginReceivedInstanceCallback params;
 
 7921    params.callback = callback;
 
 7923    return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, ¶ms);
 
 
 7945    _OrthancPluginAccessDicomInstance params;
 
 7946    memset(¶ms, 0, 
sizeof(params));
 
 7947    params.resultStringToFree = &result;
 
 7948    params.instance = instance;
 
 
 7978    int64_t hasPixelData;
 
 7980    _OrthancPluginAccessDicomInstance params;
 
 7981    memset(¶ms, 0, 
sizeof(params));
 
 7982    params.resultInt64 = &hasPixelData;
 
 7983    params.instance = instance;
 
 7994      return (hasPixelData != 0);
 
 
 8008    const char*                   transferSyntax;
 
 8009  } _OrthancPluginCreateDicomInstance;
 
 8031    _OrthancPluginCreateDicomInstance params;
 
 8032    params.target = ⌖
 
 8033    params.buffer = buffer;
 
 
 8050  } _OrthancPluginFreeDicomInstance;
 
 8066    _OrthancPluginFreeDicomInstance params;
 
 8067    params.dicom = dicom;
 
 8069    context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, ¶ms);
 
 
 8075    uint32_t*                             targetUint32;
 
 8078    char**                                targetStringToFree;
 
 8080    uint32_t                              frameIndex;
 
 8083    uint32_t                              maxStringLength;
 
 8085    void*                                 dicomWebPayload;
 
 8086  } _OrthancPluginAccessDicomInstance2;
 
 8105    _OrthancPluginAccessDicomInstance2 params;
 
 8106    memset(¶ms, 0, 
sizeof(params));
 
 8107    params.targetUint32 = &count;
 
 8108    params.instance = instance;
 
 
 8143    uint32_t                          frameIndex)
 
 8145    _OrthancPluginAccessDicomInstance2 params;
 
 8146    memset(¶ms, 0, 
sizeof(params));
 
 8147    params.targetBuffer = target;
 
 8148    params.instance = instance;
 
 8149    params.frameIndex = frameIndex;
 
 8151    return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, ¶ms);
 
 
 8170    uint32_t                          frameIndex)
 
 8174    _OrthancPluginAccessDicomInstance2 params;
 
 8175    memset(¶ms, 0, 
sizeof(params));
 
 8176    params.targetImage = ⌖
 
 8177    params.instance = instance;
 
 8178    params.frameIndex = frameIndex;
 
 
 8210    const char*            transferSyntax)
 
 8214    _OrthancPluginCreateDicomInstance params;
 
 8215    params.target = ⌖
 
 8216    params.buffer = buffer;
 
 8218    params.transferSyntax = transferSyntax;
 
 
 8249    _OrthancPluginAccessDicomInstance2 params;
 
 8250    memset(¶ms, 0, 
sizeof(params));
 
 8251    params.targetBuffer = target;
 
 8252    params.instance = instance;
 
 8254    return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, ¶ms);
 
 
 8281    uint32_t                           maxStringLength)
 
 8283    char* result = NULL;
 
 8285    _OrthancPluginAccessDicomInstance2 params;
 
 8286    memset(¶ms, 0, 
sizeof(params));
 
 8287    params.targetStringToFree = &result;
 
 8288    params.instance = instance;
 
 8289    params.format = format;
 
 8290    params.flags = flags;
 
 8291    params.maxStringLength = maxStringLength;
 
 
 8325    char* target = NULL;
 
 8327    _OrthancPluginAccessDicomInstance2 params;
 
 8328    params.targetStringToFree = ⌖
 
 8329    params.instance = instance;
 
 8330    params.dicomWebCallback = callback;
 
 8331    params.dicomWebPayload = payload;
 
 
 8365    char* target = NULL;
 
 8367    _OrthancPluginAccessDicomInstance2 params;
 
 8368    params.targetStringToFree = ⌖
 
 8369    params.instance = instance;
 
 8370    params.dicomWebCallback = callback;
 
 8371    params.dicomWebPayload = payload;
 
 
 8408    const char* 
const*         allowedSyntaxes,
 
 8409    uint32_t                   countSyntaxes,
 
 8410    uint8_t                    allowNewSopInstanceUid);
 
 8416  } _OrthancPluginTranscoderCallback;
 
 8435    _OrthancPluginTranscoderCallback params;
 
 8436    params.callback = callback;
 
 8438    return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, ¶ms);
 
 
 8447  } _OrthancPluginCreateMemoryBuffer;
 
 8471    _OrthancPluginCreateMemoryBuffer params;
 
 8472    params.target = target;
 
 8475    return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, ¶ms);
 
 
 8509    _OrthancPluginRetrieveDynamicString params;
 
 8510    params.result = &result;
 
 8511    params.argument = NULL;
 
 8513    if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
 
 
 8531  } _OrthancPluginCreateMemoryBuffer64;
 
 8555    _OrthancPluginCreateMemoryBuffer64 params;
 
 8556    params.target = target;
 
 8559    return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, ¶ms);
 
 
 8569  } _OrthancPluginRegisterStorageArea2;
 
 8594    _OrthancPluginRegisterStorageArea2 params;
 
 8595    params.create = create;
 
 8596    params.readWhole = readWhole;
 
 8597    params.readRange = readRange;
 
 8598    params.remove = remove;
 
 8599    context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, ¶ms);
 
 
 8606    _OrthancPluginCreateDicom  createDicom;
 
 8607    const char*                privateCreator;
 
 8608  } _OrthancPluginCreateDicom2;
 
 8640    const char*                    privateCreator)
 
 8642    _OrthancPluginCreateDicom2 params;
 
 8643    params.createDicom.target = target;
 
 8644    params.createDicom.json = json;
 
 8645    params.createDicom.pixelData = pixelData;
 
 8646    params.createDicom.flags = flags;
 
 8647    params.privateCreator = privateCreator;
 
 8649    return context->InvokeService(context, _OrthancPluginService_CreateDicom2, ¶ms);
 
 
 8661    uint16_t*                   httpStatus;
 
 8664    uint32_t                    headersCount;
 
 8665    const char* 
const*          headersKeys;
 
 8666    const char* 
const*          headersValues;
 
 8669    uint8_t                     afterPlugins;
 
 8670  } _OrthancPluginCallRestApi;
 
 8706    uint16_t*                   httpStatus,
 
 8709    uint32_t                    headersCount,
 
 8710    const char* 
const*          headersKeys,
 
 8711    const char* 
const*          headersValues,
 
 8714    uint8_t                     afterPlugins)
 
 8716    _OrthancPluginCallRestApi params;
 
 8717    memset(¶ms, 0, 
sizeof(params));
 
 8719    params.answerBody = answerBody;
 
 8720    params.answerHeaders = answerHeaders;
 
 8721    params.httpStatus = httpStatus;
 
 8722    params.method = method;
 
 8724    params.headersCount = headersCount;
 
 8725    params.headersKeys = headersKeys;
 
 8726    params.headersValues = headersValues;
 
 8728    params.bodySize = bodySize;
 
 8729    params.afterPlugins = afterPlugins;
 
 8731    return context->InvokeService(context, _OrthancPluginService_CallRestApi, ¶ms);
 
 
 8763    const char*                     mimeType,
 
 8764    const char*                     dateTime);
 
 8783    const char*                     dateTime);
 
 8811    const char*                     mimeType,
 
 8812    const char*                     dateTime);
 
 8829    uint8_t*                        isExisting, 
 
 8831    const char* 
const*              pathItems,
 
 8854    uint8_t*                        isExisting, 
 
 8859    const char* 
const*              pathItems,
 
 8883    const char* 
const*              pathItems,
 
 8903    uint8_t*                        isReadOnly, 
 
 8905    const char* 
const*              pathItems,
 
 8925    uint8_t*                        isReadOnly, 
 
 8927    const char* 
const*              pathItems,
 
 8945    uint8_t*                        isReadOnly, 
 
 8947    const char* 
const*              pathItems,
 
 8961  } _OrthancPluginRegisterWebDavCollection;
 
 8994    _OrthancPluginRegisterWebDavCollection params;
 
 8996    params.isExistingFolder = isExistingFolder;
 
 8997    params.listFolder = listFolder;
 
 8998    params.retrieveFile = retrieveFile;
 
 8999    params.storeFile = storeFile;
 
 9000    params.createFolder = createFolder;
 
 9001    params.deleteItem = deleteItem;
 
 9002    params.payload = payload;
 
 9004    return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, ¶ms);
 
 
 9021    _OrthancPluginRetrieveStaticString params;
 
 9022    params.result = &result;
 
 9023    params.argument = NULL;
 
 
OrthancPluginReceivedInstanceAction(* OrthancPluginReceivedInstanceCallback)(OrthancPluginMemoryBuffer64 *modifiedDicomBuffer, const void *receivedDicomBuffer, uint64_t receivedDicomBufferSize, OrthancPluginInstanceOrigin origin)
Callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-STORE or REST...
Definition OrthancCPlugin.h:7884
OrthancPluginErrorCode(* OrthancPluginWebDavAddFile)(OrthancPluginWebDavCollection *collection, const char *name, uint64_t size, const char *mimeType, const char *dateTime)
Declare a file while returning the content of a folder.
Definition OrthancCPlugin.h:8759
int OrthancPluginCheckVersionAdvanced(OrthancPluginContext *context, int expectedMajor, int expectedMinor, int expectedRevision)
Check that the version of the hosting Orthanc is above a given version.
Definition OrthancCPlugin.h:1836
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition OrthancCPlugin.h:3174
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition OrthancCPlugin.h:2139
void(* OrthancPluginDicomWebSetBinaryNode)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebBinaryMode mode, const char *bulkDataUri)
Signature of a function to set the content of a node encoding a binary DICOM tag, into a JSON or XML ...
Definition OrthancCPlugin.h:1224
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition OrthancCPlugin.h:5400
OrthancPluginChangeType
Definition OrthancCPlugin.h:730
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition OrthancCPlugin.h:1290
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition OrthancCPlugin.h:7839
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition OrthancCPlugin.h:1942
OrthancPluginErrorCode(* OrthancPluginDecodeImageCallback)(OrthancPluginImage **target, const void *dicom, const uint32_t size, uint32_t frameIndex)
Signature of a callback function to decode a DICOM instance as an image.
Definition OrthancCPlugin.h:1202
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition OrthancCPlugin.h:6970
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition OrthancCPlugin.h:8924
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition OrthancCPlugin.h:8740
void(* OrthancPluginDicomWebBinaryCallback)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebSetBinaryNode setter, uint32_t levelDepth, const uint16_t *levelTagGroup, const uint16_t *levelTagElement, const uint32_t *levelIndex, uint16_t tagGroup, uint16_t tagElement, OrthancPluginValueRepresentation vr)
Callback executed to encode a binary tag in DICOMweb.
Definition OrthancCPlugin.h:1717
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFileCallback)(OrthancPluginWebDavCollection *collection, OrthancPluginWebDavRetrieveFile retrieveFile, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for retrieving the content of a file.
Definition OrthancCPlugin.h:8879
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition OrthancCPlugin.h:7755
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition OrthancCPlugin.h:4758
OrthancPluginErrorCode(* OrthancPluginTranscoderCallback)(OrthancPluginMemoryBuffer *transcoded, const void *buffer, uint64_t size, const char *const *allowedSyntaxes, uint32_t countSyntaxes, uint8_t allowNewSopInstanceUid)
Signature of a callback function to transcode a DICOM instance.
Definition OrthancCPlugin.h:8404
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition OrthancCPlugin.h:6303
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFile)(OrthancPluginWebDavCollection *collection, const void *data, uint64_t size, const char *mimeType, const char *dateTime)
Retrieve the content of a file.
Definition OrthancCPlugin.h:8807
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition OrthancCPlugin.h:1270
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition OrthancCPlugin.h:2061
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition OrthancCPlugin.h:3562
OrthancPluginErrorCode OrthancPluginRegisterReceivedInstanceCallback(OrthancPluginContext *context, OrthancPluginReceivedInstanceCallback callback)
Register a callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-ST...
Definition OrthancCPlugin.h:7916
OrthancPluginErrorCode(* OrthancPluginWebDavListFolderCallback)(uint8_t *isExisting, OrthancPluginWebDavCollection *collection, OrthancPluginWebDavAddFile addFile, OrthancPluginWebDavAddFolder addFolder, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for listing the content of a folder.
Definition OrthancCPlugin.h:8853
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition OrthancCPlugin.h:1671
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition OrthancCPlugin.h:1073
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition OrthancCPlugin.h:3317
void OrthancPluginRegisterStorageArea2(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageReadWhole readWhole, OrthancPluginStorageReadRange readRange, OrthancPluginStorageRemove remove)
Register a custom storage area, with support for range request.
Definition OrthancCPlugin.h:8587
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition OrthancCPlugin.h:8780
OrthancPluginErrorCode OrthancPluginRegisterWebDavCollection(OrthancPluginContext *context, const char *uri, OrthancPluginWebDavIsExistingFolderCallback isExistingFolder, OrthancPluginWebDavListFolderCallback listFolder, OrthancPluginWebDavRetrieveFileCallback retrieveFile, OrthancPluginWebDavStoreFileCallback storeFile, OrthancPluginWebDavCreateFolderCallback createFolder, OrthancPluginWebDavDeleteItemCallback deleteItem, void *payload)
Register a WebDAV virtual filesystem.
Definition OrthancCPlugin.h:8983
int32_t(* OrthancPluginIncomingHttpRequestFilter2)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, uint32_t getArgumentsCount, const char *const *getArgumentsKeys, const char *const *getArgumentsValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition OrthancCPlugin.h:1416
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition OrthancCPlugin.h:1170
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition OrthancCPlugin.h:1689
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition OrthancCPlugin.h:8431
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(const OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc stores a new DICOM instance.
Definition OrthancCPlugin.h:1181
OrthancPluginErrorCode(* OrthancPluginWebDavStoreFileCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, const void *data, uint64_t size, void *payload)
Callback to store a file.
Definition OrthancCPlugin.h:8902
OrthancPluginErrorCode(* OrthancPluginWebDavDeleteItemCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to remove a file or a folder.
Definition OrthancCPlugin.h:8944
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition OrthancCPlugin.h:4950
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition OrthancCPlugin.h:1331
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition OrthancCPlugin.h:1243
void(* OrthancPluginDicomWebBinaryCallback2)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebSetBinaryNode setter, uint32_t levelDepth, const uint16_t *levelTagGroup, const uint16_t *levelTagElement, const uint32_t *levelIndex, uint16_t tagGroup, uint16_t tagElement, OrthancPluginValueRepresentation vr, void *payload)
Callback executed to encode a binary tag in DICOMweb.
Definition OrthancCPlugin.h:1755
OrthancPluginErrorCode(* 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:1191
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition OrthancCPlugin.h:7418
OrthancPluginErrorCode(* OrthancPluginWebDavIsExistingFolderCallback)(uint8_t *isExisting, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for testing the existence of a folder.
Definition OrthancCPlugin.h:8828
int32_t(* OrthancPluginIncomingHttpRequestFilter)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition OrthancCPlugin.h:1381
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition OrthancCPlugin.h:6828
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition OrthancCPlugin.h:1214
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition OrthancCPlugin.h:2101
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition OrthancCPlugin.h:4719
OrthancPluginErrorCode(* OrthancPluginStorageReadRange)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type, uint64_t rangeStart)
Callback for reading a range of a file from the storage area.
Definition OrthancCPlugin.h:1313
void OrthancPluginRegisterChunkedRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback getHandler, OrthancPluginServerChunkedRequestReaderFactory postHandler, OrthancPluginRestCallback deleteHandler, OrthancPluginServerChunkedRequestReaderFactory putHandler, OrthancPluginServerChunkedRequestReaderAddChunk addChunk, OrthancPluginServerChunkedRequestReaderExecute execute, OrthancPluginServerChunkedRequestReaderFinalize finalize)
Register a REST callback to handle chunked HTTP transfers.
Definition OrthancCPlugin.h:7539
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition OrthancCPlugin.h:7817
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition OrthancCPlugin.h:7776
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition OrthancCPlugin.h:5736
OrthancPluginErrorCode OrthancPluginStorageAreaCreate(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, const void *content, uint64_t size, OrthancPluginContentType type)
Create a file inside the storage area.
Definition OrthancCPlugin.h:4675
@ OrthancPluginChangeType_OrthancStopped
Definition OrthancCPlugin.h:742
@ OrthancPluginChangeType_OrthancStarted
Definition OrthancCPlugin.h:741
@ OrthancPluginChangeType_Deleted
Definition OrthancCPlugin.h:732
@ OrthancPluginChangeType_JobFailure
Definition OrthancCPlugin.h:749
@ OrthancPluginChangeType_NewInstance
Definition OrthancCPlugin.h:734
@ OrthancPluginChangeType_NewPatient
Definition OrthancCPlugin.h:735
@ OrthancPluginChangeType_JobSubmitted
Definition OrthancCPlugin.h:747
@ OrthancPluginChangeType_NewSeries
Definition OrthancCPlugin.h:736
@ OrthancPluginChangeType_StablePatient
Definition OrthancCPlugin.h:738
@ OrthancPluginChangeType_UpdatedPeers
Definition OrthancCPlugin.h:745
@ OrthancPluginChangeType_StableStudy
Definition OrthancCPlugin.h:740
@ OrthancPluginChangeType_CompletedSeries
Definition OrthancCPlugin.h:731
@ OrthancPluginChangeType_NewChildInstance
Definition OrthancCPlugin.h:733
@ OrthancPluginChangeType_UpdatedAttachment
Definition OrthancCPlugin.h:743
@ OrthancPluginChangeType_UpdatedMetadata
Definition OrthancCPlugin.h:744
@ OrthancPluginChangeType_StableSeries
Definition OrthancCPlugin.h:739
@ OrthancPluginChangeType_UpdatedModalities
Definition OrthancCPlugin.h:746
@ OrthancPluginChangeType_JobSuccess
Definition OrthancCPlugin.h:748
@ OrthancPluginChangeType_NewStudy
Definition OrthancCPlugin.h:737
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition OrthancCPlugin.h:5997
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition OrthancCPlugin.h:1121
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition OrthancCPlugin.h:1526
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition OrthancCPlugin.h:5973
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition OrthancCPlugin.h:7667
OrthancPluginErrorCode(* OrthancPluginWorklistCallback)(OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle the C-Find SCP requests for worklists.
Definition OrthancCPlugin.h:1350
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition OrthancCPlugin.h:6151
char * OrthancPluginGetFindQueryValue(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the value associated with one tag in a C-Find query.
Definition OrthancCPlugin.h:6103
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentFactory)(void **handler, const char *jobId, const char *transactionUid, const char *const *sopClassUids, const char *const *sopInstanceUids, uint32_t countInstances, const char *remoteAet, const char *calledAet)
Callback executed by the storage commitment SCP.
Definition OrthancCPlugin.h:7645
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition OrthancCPlugin.h:5905
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition OrthancCPlugin.h:5282
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentLookup)(OrthancPluginStorageCommitmentFailureReason *target, void *handler, const char *sopClassUid, const char *sopInstanceUid)
Callback to get the status of one DICOM instance in the storage commitment SCP.
Definition OrthancCPlugin.h:7688
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition OrthancCPlugin.h:5243
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition OrthancCPlugin.h:5944
OrthancPluginErrorCode OrthancPluginRegisterStorageCommitmentScpCallback(OrthancPluginContext *context, OrthancPluginStorageCommitmentFactory factory, OrthancPluginStorageCommitmentDestructor destructor, OrthancPluginStorageCommitmentLookup lookup)
Register a callback to handle incoming requests to the storage commitment SCP.
Definition OrthancCPlugin.h:7715
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition OrthancCPlugin.h:1129
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition OrthancCPlugin.h:1113
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition OrthancCPlugin.h:1443
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition OrthancCPlugin.h:1511
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition OrthancCPlugin.h:5139
char * OrthancPluginGetFindQueryTagName(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the symbolic name of one tag in a C-Find query.
Definition OrthancCPlugin.h:6065
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition OrthancCPlugin.h:5205
OrthancPluginErrorCode OrthancPluginGetFindQueryTag(OrthancPluginContext *context, uint16_t *group, uint16_t *element, const OrthancPluginFindQuery *query, uint32_t index)
Get one tag in a C-Find query.
Definition OrthancCPlugin.h:6034
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition OrthancCPlugin.h:1540
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition OrthancCPlugin.h:1105
void *(* OrthancPluginMoveCallback)(OrthancPluginResourceType resourceType, const char *patientId, const char *accessionNumber, const char *studyInstanceUid, const char *seriesInstanceUid, const char *sopInstanceUid, const char *originatorAet, const char *sourceAet, const char *targetAet, uint16_t originatorId)
Callback to handle incoming C-Move SCP requests.
Definition OrthancCPlugin.h:1486
OrthancPluginErrorCode OrthancPluginWorklistAddAnswer(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Add one answer to some modality worklist request.
Definition OrthancCPlugin.h:5175
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition OrthancCPlugin.h:7974
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition OrthancCPlugin.h:8359
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition OrthancCPlugin.h:1081
OrthancPluginErrorCode OrthancPluginGetInstanceRawFrame(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Get the raw content of a frame in a DICOM instance.
Definition OrthancCPlugin.h:8139
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition OrthancCPlugin.h:2905
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition OrthancCPlugin.h:3007
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition OrthancCPlugin.h:8206
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition OrthancCPlugin.h:8024
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition OrthancCPlugin.h:8099
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition OrthancCPlugin.h:5308
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition OrthancCPlugin.h:2938
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition OrthancCPlugin.h:8319
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition OrthancCPlugin.h:7939
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition OrthancCPlugin.h:3084
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition OrthancCPlugin.h:8062
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition OrthancCPlugin.h:8244
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition OrthancCPlugin.h:3125
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition OrthancCPlugin.h:3045
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition OrthancCPlugin.h:2971
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition OrthancCPlugin.h:8167
char * OrthancPluginGetInstanceAdvancedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition OrthancCPlugin.h:8276
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition OrthancCPlugin.h:4461
OrthancPluginPixelFormat
Definition OrthancCPlugin.h:606
OrthancPluginErrorCode OrthancPluginDrawText(OrthancPluginContext *context, OrthancPluginImage *image, uint32_t fontIndex, const char *utf8Text, int32_t x, int32_t y, uint8_t r, uint8_t g, uint8_t b)
Draw text on an image.
Definition OrthancCPlugin.h:4621
OrthancPluginErrorCode OrthancPluginCompressJpegImage(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer, uint8_t quality)
Encode a JPEG image.
Definition OrthancCPlugin.h:4205
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition OrthancCPlugin.h:3996
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition OrthancCPlugin.h:3895
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition OrthancCPlugin.h:5438
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition OrthancCPlugin.h:4496
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition OrthancCPlugin.h:3961
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition OrthancCPlugin.h:4030
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition OrthancCPlugin.h:4115
OrthancPluginErrorCode OrthancPluginCompressPngImage(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer)
Encode a PNG image.
Definition OrthancCPlugin.h:4160
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition OrthancCPlugin.h:5527
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition OrthancCPlugin.h:4073
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition OrthancCPlugin.h:4536
OrthancPluginImageFormat
Definition OrthancCPlugin.h:775
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition OrthancCPlugin.h:1097
OrthancPluginCompressionType
Definition OrthancCPlugin.h:760
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition OrthancCPlugin.h:3928
OrthancPluginErrorCode OrthancPluginBufferCompression(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const void *source, uint32_t size, OrthancPluginCompressionType compression, uint8_t uncompress)
Compress or decompress a buffer.
Definition OrthancCPlugin.h:3707
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition OrthancCPlugin.h:4568
OrthancPluginImage * OrthancPluginCreateImageAccessor(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, void *buffer)
Create an image pointing to a memory buffer.
Definition OrthancCPlugin.h:5481
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition OrthancCPlugin.h:1089
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition OrthancCPlugin.h:645
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition OrthancCPlugin.h:655
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition OrthancCPlugin.h:613
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition OrthancCPlugin.h:629
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition OrthancCPlugin.h:671
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition OrthancCPlugin.h:637
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition OrthancCPlugin.h:679
@ OrthancPluginPixelFormat_Unknown
Definition OrthancCPlugin.h:647
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition OrthancCPlugin.h:687
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition OrthancCPlugin.h:663
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition OrthancCPlugin.h:621
@ OrthancPluginImageFormat_Png
Definition OrthancCPlugin.h:776
@ OrthancPluginImageFormat_Jpeg
Definition OrthancCPlugin.h:777
@ OrthancPluginImageFormat_Dicom
Definition OrthancCPlugin.h:778
@ OrthancPluginCompressionType_Gzip
Definition OrthancCPlugin.h:763
@ OrthancPluginCompressionType_ZlibWithSize
Definition OrthancCPlugin.h:762
@ OrthancPluginCompressionType_Zlib
Definition OrthancCPlugin.h:761
@ OrthancPluginCompressionType_GzipWithSize
Definition OrthancCPlugin.h:764
OrthancPluginErrorCode OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition OrthancCPlugin.h:2369
OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition OrthancCPlugin.h:2404
OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition OrthancCPlugin.h:2517
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition OrthancCPlugin.h:2653
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition OrthancCPlugin.h:2688
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition OrthancCPlugin.h:3465
OrthancPluginErrorCode OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition OrthancCPlugin.h:2481
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition OrthancCPlugin.h:3426
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition OrthancCPlugin.h:2618
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition OrthancCPlugin.h:2302
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition OrthancCPlugin.h:2723
OrthancPluginErrorCode OrthancPluginRestApiGetAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the REST API, as tainted by the plugins.
Definition OrthancCPlugin.h:2332
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition OrthancCPlugin.h:2583
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition OrthancCPlugin.h:2433
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition OrthancCPlugin.h:2456
OrthancPluginErrorCode OrthancPluginCallRestApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const void *body, uint32_t bodySize, uint8_t afterPlugins)
Call the REST API of Orthanc with full flexibility.
Definition OrthancCPlugin.h:8702
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition OrthancCPlugin.h:8504
OrthancPluginErrorCode OrthancPluginRestApiGet2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, int32_t afterPlugins)
Make a GET call to the Orthanc REST API, with custom HTTP headers.
Definition OrthancCPlugin.h:5101
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition OrthancCPlugin.h:2269
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:2228
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition OrthancCPlugin.h:2791
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition OrthancCPlugin.h:6864
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition OrthancCPlugin.h:2814
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition OrthancCPlugin.h:2171
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition OrthancCPlugin.h:2768
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition OrthancCPlugin.h:2869
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition OrthancCPlugin.h:2844
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition OrthancCPlugin.h:2551
void OrthancPluginCompressAndAnswerJpegImage(OrthancPluginContext *context, OrthancPluginRestOutput *output, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer, uint8_t quality)
Answer to a REST request with a JPEG image.
Definition OrthancCPlugin.h:4252
OrthancPluginErrorCode OrthancPluginSendMultipartItem(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize)
Send an item as a part of some HTTP multipart answer.
Definition OrthancCPlugin.h:3665
OrthancPluginErrorCode OrthancPluginSendMultipartItem2(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Send an item as a part of some HTTP multipart answer, with custom headers.
Definition OrthancCPlugin.h:5698
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition OrthancCPlugin.h:3636
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const char *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition OrthancCPlugin.h:3859
An entry in the dictionary of DICOM tags.
Definition OrthancCPlugin.h:1788
uint32_t minMultiplicity
Definition OrthancCPlugin.h:1792
uint32_t maxMultiplicity
Definition OrthancCPlugin.h:1793
OrthancPluginValueRepresentation vr
Definition OrthancCPlugin.h:1791
uint16_t element
Definition OrthancCPlugin.h:1790
uint16_t group
Definition OrthancCPlugin.h:1789
The parameters of a REST request.
Definition OrthancCPlugin.h:341
const char *const  * getValues
For a GET request, the values of the GET parameters.
Definition OrthancCPlugin.h:370
const char *const  * groups
The matched values for the groups of the regular expression.
Definition OrthancCPlugin.h:355
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition OrthancCPlugin.h:380
uint32_t groupsCount
The number of groups of the regular expression.
Definition OrthancCPlugin.h:350
const char *const  * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition OrthancCPlugin.h:395
const void * body
For a PUT or POST request, the content of the body.
Definition OrthancCPlugin.h:375
const char *const  * getKeys
For a GET request, the keys of the GET parameters.
Definition OrthancCPlugin.h:365
uint32_t headersCount
The number of HTTP headers.
Definition OrthancCPlugin.h:390
OrthancPluginHttpMethod method
The HTTP method.
Definition OrthancCPlugin.h:345
uint32_t getCount
For a GET request, the number of GET parameters.
Definition OrthancCPlugin.h:360
const char *const  * headersValues
The values of the HTTP headers.
Definition OrthancCPlugin.h:400
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition OrthancCPlugin.h:1054
uint64_t size
The number of bytes in the buffer.
Definition OrthancCPlugin.h:1063
void * data
The content of the buffer.
Definition OrthancCPlugin.h:1058
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition OrthancCPlugin.h:1032
uint32_t size
The number of bytes in the buffer.
Definition OrthancCPlugin.h:1041
void * data
The content of the buffer.
Definition OrthancCPlugin.h:1036