Mercurial > hg > orthanc-databases

comparison Framework/Plugins/OrthancCppDatabasePlugin.h @ 200:30b210616f4f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
cont
author Sebastien Jodogne <s.jodogne@gmail.com>
date Thu, 18 Mar 2021 15:21:17 +0100
parents 8cae98f73d53
children 42990b2dd51b
comparison
equal deleted inserted replaced
199:8cae98f73d53 200:30b210616f4f
41 41
42 #include <OrthancException.h> 42 #include <OrthancException.h>
43 43
44 44
45 45
46 #define ORTHANC_PLUGINS_DATABASE_CATCH \ 46 #define ORTHANC_PLUGINS_DATABASE_CATCH \
47 catch (::Orthanc::OrthancException& e) \ 47 catch (::Orthanc::OrthancException& e) \
48 { \ 48 { \
49 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \ 49 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \
50 } \ 50 } \
51 catch (::std::runtime_error& e) \ 51 catch (::std::runtime_error& e) \
52 { \ 52 { \
53 LogError(backend, e); \ 53 LogError(backend, e); \
54 return OrthancPluginErrorCode_DatabasePlugin; \ 54 return OrthancPluginErrorCode_DatabasePlugin; \
55 } \ 55 } \
56 catch (...) \ 56 catch (...) \
57 { \ 57 { \
58 OrthancPluginLogError(backend->GetContext(), "Native exception"); \ 58 OrthancPluginLogError(backend->GetContext(), "Native exception"); \
59 return OrthancPluginErrorCode_DatabasePlugin; \ 59 return OrthancPluginErrorCode_DatabasePlugin; \
60 } 60 }
61 61
62 62
63 #include <stdexcept> 63 #include <stdexcept>
64 #include <list> 64 #include <list>
67 namespace OrthancPlugins 67 namespace OrthancPlugins
68 { 68 {
69 /** 69 /**
70 * @ingroup Callbacks 70 * @ingroup Callbacks
71 **/ 71 **/
72 class DatabaseBackendOutput : public boost::noncopyable 72
73 class IDatabaseBackendOutput : public boost::noncopyable
74 {
75 public:
76 virtual ~IDatabaseBackendOutput()
77 {
78 }
79
80 virtual void SignalDeletedAttachment(const std::string& uuid,
81 int32_t contentType,
82 uint64_t uncompressedSize,
83 const std::string& uncompressedHash,
84 int32_t compressionType,
85 uint64_t compressedSize,
86 const std::string& compressedHash) = 0;
87
88 virtual void SignalDeletedResource(const std::string& publicId,
89 OrthancPluginResourceType resourceType) = 0;
90
91 virtual void SignalRemainingAncestor(const std::string& ancestorId,
92 OrthancPluginResourceType ancestorType) = 0;
93
94 virtual void AnswerAttachment(const std::string& uuid,
95 int32_t contentType,
96 uint64_t uncompressedSize,
97 const std::string& uncompressedHash,
98 int32_t compressionType,
99 uint64_t compressedSize,
100 const std::string& compressedHash) = 0;
101
102 virtual void AnswerChange(int64_t seq,
103 int32_t changeType,
104 OrthancPluginResourceType resourceType,
105 const std::string& publicId,
106 const std::string& date) = 0;
107
108 virtual void AnswerDicomTag(uint16_t group,
109 uint16_t element,
110 const std::string& value) = 0;
111
112 virtual void AnswerExportedResource(int64_t seq,
113 OrthancPluginResourceType resourceType,
114 const std::string& publicId,
115 const std::string& modality,
116 const std::string& date,
117 const std::string& patientId,
118 const std::string& studyInstanceUid,
119 const std::string& seriesInstanceUid,
120 const std::string& sopInstanceUid) = 0;
121 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
122 virtual void AnswerMatchingResource(const std::string& resourceId) = 0;
123 #endif
124
125 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
126 virtual void AnswerMatchingResource(const std::string& resourceId,
127 const std::string& someInstanceId) = 0;
128 #endif
129 };
130
131
132 /**
133 * @ingroup Callbacks
134 **/
135 class IDatabaseBackend : public boost::noncopyable
136 {
137 private:
138 OrthancPluginContext* context_;
139 std::unique_ptr<IDatabaseBackendOutput> output_;
140
141 public:
142 // "context" can be NULL iff. running the unit tests
143 IDatabaseBackend() :
144 context_(NULL)
145 {
146 }
147
148 IDatabaseBackendOutput& GetOutput()
149 {
150 if (output_.get() == NULL)
151 {
152 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
153 }
154 else
155 {
156 return *output_;
157 }
158 }
159
160 OrthancPluginContext* GetContext() const
161 {
162 return context_;
163 }
164
165 // This takes the ownership of the "output"
166 void RegisterOutput(OrthancPluginContext* context,
167 IDatabaseBackendOutput* output)
168 {
169 context_ = context;
170 output_.reset(output);
171 }
172
173 virtual void Open() = 0;
174
175 virtual void Close() = 0;
176
177 virtual void AddAttachment(int64_t id,
178 const OrthancPluginAttachment& attachment) = 0;
179
180 virtual void AttachChild(int64_t parent,
181 int64_t child) = 0;
182
183 virtual void ClearChanges() = 0;
184
185 virtual void ClearExportedResources() = 0;
186
187 virtual int64_t CreateResource(const char* publicId,
188 OrthancPluginResourceType type) = 0;
189
190 virtual void DeleteAttachment(int64_t id,
191 int32_t attachment) = 0;
192
193 virtual void DeleteMetadata(int64_t id,
194 int32_t metadataType) = 0;
195
196 virtual void DeleteResource(int64_t id) = 0;
197
198 virtual void GetAllInternalIds(std::list<int64_t>& target,
199 OrthancPluginResourceType resourceType) = 0;
200
201 virtual void GetAllPublicIds(std::list<std::string>& target,
202 OrthancPluginResourceType resourceType) = 0;
203
204 virtual void GetAllPublicIds(std::list<std::string>& target,
205 OrthancPluginResourceType resourceType,
206 uint64_t since,
207 uint64_t limit) = 0;
208
209 /* Use GetOutput().AnswerChange() */
210 virtual void GetChanges(bool& done /*out*/,
211 int64_t since,
212 uint32_t maxResults) = 0;
213
214 virtual void GetChildrenInternalId(std::list<int64_t>& target /*out*/,
215 int64_t id) = 0;
216
217 virtual void GetChildrenPublicId(std::list<std::string>& target /*out*/,
218 int64_t id) = 0;
219
220 /* Use GetOutput().AnswerExportedResource() */
221 virtual void GetExportedResources(bool& done /*out*/,
222 int64_t since,
223 uint32_t maxResults) = 0;
224
225 /* Use GetOutput().AnswerChange() */
226 virtual void GetLastChange() = 0;
227
228 /* Use GetOutput().AnswerExportedResource() */
229 virtual void GetLastExportedResource() = 0;
230
231 /* Use GetOutput().AnswerDicomTag() */
232 virtual void GetMainDicomTags(int64_t id) = 0;
233
234 virtual std::string GetPublicId(int64_t resourceId) = 0;
235
236 virtual uint64_t GetResourceCount(OrthancPluginResourceType resourceType) = 0;
237
238 virtual OrthancPluginResourceType GetResourceType(int64_t resourceId) = 0;
239
240 virtual uint64_t GetTotalCompressedSize() = 0;
241
242 virtual uint64_t GetTotalUncompressedSize() = 0;
243
244 virtual bool IsExistingResource(int64_t internalId) = 0;
245
246 virtual bool IsProtectedPatient(int64_t internalId) = 0;
247
248 virtual void ListAvailableMetadata(std::list<int32_t>& target /*out*/,
249 int64_t id) = 0;
250
251 virtual void ListAvailableAttachments(std::list<int32_t>& target /*out*/,
252 int64_t id) = 0;
253
254 virtual void LogChange(const OrthancPluginChange& change) = 0;
255
256 virtual void LogExportedResource(const OrthancPluginExportedResource& resource) = 0;
257
258 /* Use GetOutput().AnswerAttachment() */
259 virtual bool LookupAttachment(int64_t id,
260 int32_t contentType) = 0;
261
262 virtual bool LookupGlobalProperty(std::string& target /*out*/,
263 int32_t property) = 0;
264
265 virtual void LookupIdentifier(std::list<int64_t>& target /*out*/,
266 OrthancPluginResourceType resourceType,
267 uint16_t group,
268 uint16_t element,
269 OrthancPluginIdentifierConstraint constraint,
270 const char* value) = 0;
271
272 virtual void LookupIdentifierRange(std::list<int64_t>& target /*out*/,
273 OrthancPluginResourceType resourceType,
274 uint16_t group,
275 uint16_t element,
276 const char* start,
277 const char* end) = 0;
278
279 virtual bool LookupMetadata(std::string& target /*out*/,
280 int64_t id,
281 int32_t metadataType) = 0;
282
283 virtual bool LookupParent(int64_t& parentId /*out*/,
284 int64_t resourceId) = 0;
285
286 virtual bool LookupResource(int64_t& id /*out*/,
287 OrthancPluginResourceType& type /*out*/,
288 const char* publicId) = 0;
289
290 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/) = 0;
291
292 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/,
293 int64_t patientIdToAvoid) = 0;
294
295 virtual void SetGlobalProperty(int32_t property,
296 const char* value) = 0;
297
298 virtual void SetMainDicomTag(int64_t id,
299 uint16_t group,
300 uint16_t element,
301 const char* value) = 0;
302
303 virtual void SetIdentifierTag(int64_t id,
304 uint16_t group,
305 uint16_t element,
306 const char* value) = 0;
307
308 virtual void SetMetadata(int64_t id,
309 int32_t metadataType,
310 const char* value) = 0;
311
312 virtual void SetProtectedPatient(int64_t internalId,
313 bool isProtected) = 0;
314
315 virtual void StartTransaction() = 0;
316
317 virtual void RollbackTransaction() = 0;
318
319 virtual void CommitTransaction() = 0;
320
321 virtual uint32_t GetDatabaseVersion() = 0;
322
323 /**
324 * Upgrade the database to the specified version of the database
325 * schema. The upgrade script is allowed to make calls to
326 * OrthancPluginReconstructMainDicomTags().
327 **/
328 virtual void UpgradeDatabase(uint32_t targetVersion,
329 OrthancPluginStorageArea* storageArea) = 0;
330
331 virtual void ClearMainDicomTags(int64_t internalId) = 0;
332
333 virtual bool HasCreateInstance() const
334 {
335 return false;
336 }
337
338 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
339 virtual void LookupResources(const std::vector<Orthanc::DatabaseConstraint>& lookup,
340 OrthancPluginResourceType queryLevel,
341 uint32_t limit,
342 bool requestSomeInstance) = 0;
343 #endif
344
345 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
346 virtual void CreateInstance(OrthancPluginCreateInstanceResult& result,
347 const char* hashPatient,
348 const char* hashStudy,
349 const char* hashSeries,
350 const char* hashInstance)
351 {
352 throw std::runtime_error("Not implemented");
353 }
354 #endif
355
356
357 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
358 virtual void SetResourcesContent(
359 uint32_t countIdentifierTags,
360 const OrthancPluginResourcesContentTags* identifierTags,
361 uint32_t countMainDicomTags,
362 const OrthancPluginResourcesContentTags* mainDicomTags,
363 uint32_t countMetadata,
364 const OrthancPluginResourcesContentMetadata* metadata) = 0;
365 #endif
366
367
368 virtual void GetChildrenMetadata(std::list<std::string>& target,
369 int64_t resourceId,
370 int32_t metadata) = 0;
371
372 virtual int64_t GetLastChangeIndex() = 0;
373
374 virtual void TagMostRecentPatient(int64_t patientId) = 0;
375
376 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1
377 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4)
378 // NB: "parentPublicId" must be cleared if the resource has no parent
379 virtual bool LookupResourceAndParent(int64_t& id,
380 OrthancPluginResourceType& type,
381 std::string& parentPublicId,
382 const char* publicId) = 0;
383 # endif
384 #endif
385
386 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1
387 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4)
388 virtual void GetAllMetadata(std::map<int32_t, std::string>& result,
389 int64_t id) = 0;
390 # endif
391 #endif
392 };
393
394
395
396 class DatabaseBackendOutputV2 : public IDatabaseBackendOutput
73 { 397 {
74 public: 398 public:
75 enum AllowedAnswers 399 enum AllowedAnswers
76 { 400 {
77 AllowedAnswers_All, 401 AllowedAnswers_All,
89 OrthancPluginContext* context_; 413 OrthancPluginContext* context_;
90 OrthancPluginDatabaseContext* database_; 414 OrthancPluginDatabaseContext* database_;
91 AllowedAnswers allowedAnswers_; 415 AllowedAnswers allowedAnswers_;
92 416
93 public: 417 public:
94 DatabaseBackendOutput(OrthancPluginContext* context, 418 DatabaseBackendOutputV2(OrthancPluginContext* context,
95 OrthancPluginDatabaseContext* database) : 419 OrthancPluginDatabaseContext* database) :
96 context_(context), 420 context_(context),
97 database_(database), 421 database_(database),
98 allowedAnswers_(AllowedAnswers_All /* for unit tests */) 422 allowedAnswers_(AllowedAnswers_All /* for unit tests */)
99 { 423 {
100 } 424 }
107 OrthancPluginDatabaseContext* GetDatabase() const 431 OrthancPluginDatabaseContext* GetDatabase() const
108 { 432 {
109 return database_; 433 return database_;
110 } 434 }
111 435
112 void SignalDeletedAttachment(const std::string& uuid, 436 virtual void SignalDeletedAttachment(const std::string& uuid,
113 int32_t contentType, 437 int32_t contentType,
114 uint64_t uncompressedSize, 438 uint64_t uncompressedSize,
115 const std::string& uncompressedHash, 439 const std::string& uncompressedHash,
116 int32_t compressionType, 440 int32_t compressionType,
117 uint64_t compressedSize, 441 uint64_t compressedSize,
118 const std::string& compressedHash) 442 const std::string& compressedHash) ORTHANC_OVERRIDE
119 { 443 {
120 OrthancPluginAttachment attachment; 444 OrthancPluginAttachment attachment;
121 attachment.uuid = uuid.c_str(); 445 attachment.uuid = uuid.c_str();
122 attachment.contentType = contentType; 446 attachment.contentType = contentType;
123 attachment.uncompressedSize = uncompressedSize; 447 attachment.uncompressedSize = uncompressedSize;
127 attachment.compressedHash = compressedHash.c_str(); 451 attachment.compressedHash = compressedHash.c_str();
128 452
129 OrthancPluginDatabaseSignalDeletedAttachment(context_, database_, &attachment); 453 OrthancPluginDatabaseSignalDeletedAttachment(context_, database_, &attachment);
130 } 454 }
131 455
132 void SignalDeletedResource(const std::string& publicId, 456 virtual void SignalDeletedResource(const std::string& publicId,
133 OrthancPluginResourceType resourceType) 457 OrthancPluginResourceType resourceType) ORTHANC_OVERRIDE
134 { 458 {
135 OrthancPluginDatabaseSignalDeletedResource(context_, database_, publicId.c_str(), resourceType); 459 OrthancPluginDatabaseSignalDeletedResource(context_, database_, publicId.c_str(), resourceType);
136 } 460 }
137 461
138 void SignalRemainingAncestor(const std::string& ancestorId, 462 virtual void SignalRemainingAncestor(const std::string& ancestorId,
139 OrthancPluginResourceType ancestorType) 463 OrthancPluginResourceType ancestorType) ORTHANC_OVERRIDE
140 { 464 {
141 OrthancPluginDatabaseSignalRemainingAncestor(context_, database_, ancestorId.c_str(), ancestorType); 465 OrthancPluginDatabaseSignalRemainingAncestor(context_, database_, ancestorId.c_str(), ancestorType);
142 } 466 }
143 467
144 void AnswerAttachment(const std::string& uuid, 468 virtual void AnswerAttachment(const std::string& uuid,
145 int32_t contentType, 469 int32_t contentType,
146 uint64_t uncompressedSize, 470 uint64_t uncompressedSize,
147 const std::string& uncompressedHash, 471 const std::string& uncompressedHash,
148 int32_t compressionType, 472 int32_t compressionType,
149 uint64_t compressedSize, 473 uint64_t compressedSize,
150 const std::string& compressedHash) 474 const std::string& compressedHash) ORTHANC_OVERRIDE
151 { 475 {
152 if (allowedAnswers_ != AllowedAnswers_All && 476 if (allowedAnswers_ != AllowedAnswers_All &&
153 allowedAnswers_ != AllowedAnswers_Attachment) 477 allowedAnswers_ != AllowedAnswers_Attachment)
154 { 478 {
155 throw std::runtime_error("Cannot answer with an attachment in the current state"); 479 throw std::runtime_error("Cannot answer with an attachment in the current state");
165 attachment.compressedHash = compressedHash.c_str(); 489 attachment.compressedHash = compressedHash.c_str();
166 490
167 OrthancPluginDatabaseAnswerAttachment(context_, database_, &attachment); 491 OrthancPluginDatabaseAnswerAttachment(context_, database_, &attachment);
168 } 492 }
169 493
170 void AnswerChange(int64_t seq, 494 virtual void AnswerChange(int64_t seq,
171 int32_t changeType, 495 int32_t changeType,
172 OrthancPluginResourceType resourceType, 496 OrthancPluginResourceType resourceType,
173 const std::string& publicId, 497 const std::string& publicId,
174 const std::string& date) 498 const std::string& date) ORTHANC_OVERRIDE
175 { 499 {
176 if (allowedAnswers_ != AllowedAnswers_All && 500 if (allowedAnswers_ != AllowedAnswers_All &&
177 allowedAnswers_ != AllowedAnswers_Change) 501 allowedAnswers_ != AllowedAnswers_Change)
178 { 502 {
179 throw std::runtime_error("Cannot answer with a change in the current state"); 503 throw std::runtime_error("Cannot answer with a change in the current state");
187 change.date = date.c_str(); 511 change.date = date.c_str();
188 512
189 OrthancPluginDatabaseAnswerChange(context_, database_, &change); 513 OrthancPluginDatabaseAnswerChange(context_, database_, &change);
190 } 514 }
191 515
192 void AnswerDicomTag(uint16_t group, 516 virtual void AnswerDicomTag(uint16_t group,
193 uint16_t element, 517 uint16_t element,
194 const std::string& value) 518 const std::string& value) ORTHANC_OVERRIDE
195 { 519 {
196 if (allowedAnswers_ != AllowedAnswers_All && 520 if (allowedAnswers_ != AllowedAnswers_All &&
197 allowedAnswers_ != AllowedAnswers_DicomTag) 521 allowedAnswers_ != AllowedAnswers_DicomTag)
198 { 522 {
199 throw std::runtime_error("Cannot answer with a DICOM tag in the current state"); 523 throw std::runtime_error("Cannot answer with a DICOM tag in the current state");
205 tag.value = value.c_str(); 529 tag.value = value.c_str();
206 530
207 OrthancPluginDatabaseAnswerDicomTag(context_, database_, &tag); 531 OrthancPluginDatabaseAnswerDicomTag(context_, database_, &tag);
208 } 532 }
209 533
210 void AnswerExportedResource(int64_t seq, 534 virtual void AnswerExportedResource(int64_t seq,
211 OrthancPluginResourceType resourceType, 535 OrthancPluginResourceType resourceType,
212 const std::string& publicId, 536 const std::string& publicId,
213 const std::string& modality, 537 const std::string& modality,
214 const std::string& date, 538 const std::string& date,
215 const std::string& patientId, 539 const std::string& patientId,
216 const std::string& studyInstanceUid, 540 const std::string& studyInstanceUid,
217 const std::string& seriesInstanceUid, 541 const std::string& seriesInstanceUid,
218 const std::string& sopInstanceUid) 542 const std::string& sopInstanceUid) ORTHANC_OVERRIDE
219 { 543 {
220 if (allowedAnswers_ != AllowedAnswers_All && 544 if (allowedAnswers_ != AllowedAnswers_All &&
221 allowedAnswers_ != AllowedAnswers_ExportedResource) 545 allowedAnswers_ != AllowedAnswers_ExportedResource)
222 { 546 {
223 throw std::runtime_error("Cannot answer with an exported resource in the current state"); 547 throw std::runtime_error("Cannot answer with an exported resource in the current state");
237 OrthancPluginDatabaseAnswerExportedResource(context_, database_, &exported); 561 OrthancPluginDatabaseAnswerExportedResource(context_, database_, &exported);
238 } 562 }
239 563
240 564
241 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 565 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
242 void AnswerMatchingResource(const std::string& resourceId) 566 virtual void AnswerMatchingResource(const std::string& resourceId) ORTHANC_OVERRIDE
243 { 567 {
244 if (allowedAnswers_ != AllowedAnswers_All && 568 if (allowedAnswers_ != AllowedAnswers_All &&
245 allowedAnswers_ != AllowedAnswers_MatchingResource) 569 allowedAnswers_ != AllowedAnswers_MatchingResource)
246 { 570 {
247 throw std::runtime_error("Cannot answer with an exported resource in the current state"); 571 throw std::runtime_error("Cannot answer with an exported resource in the current state");
255 } 579 }
256 #endif 580 #endif
257 581
258 582
259 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 583 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
260 void AnswerMatchingResource(const std::string& resourceId, 584 virtual void AnswerMatchingResource(const std::string& resourceId,
261 const std::string& someInstanceId) 585 const std::string& someInstanceId) ORTHANC_OVERRIDE
262 { 586 {
263 if (allowedAnswers_ != AllowedAnswers_All && 587 if (allowedAnswers_ != AllowedAnswers_All &&
264 allowedAnswers_ != AllowedAnswers_MatchingResource) 588 allowedAnswers_ != AllowedAnswers_MatchingResource)
265 { 589 {
266 throw std::runtime_error("Cannot answer with an exported resource in the current state"); 590 throw std::runtime_error("Cannot answer with an exported resource in the current state");
272 596
273 OrthancPluginDatabaseAnswerMatchingResource(context_, database_, &match); 597 OrthancPluginDatabaseAnswerMatchingResource(context_, database_, &match);
274 } 598 }
275 #endif 599 #endif
276 }; 600 };
277
278
279 /**
280 * @ingroup Callbacks
281 **/
282 class IDatabaseBackend : public boost::noncopyable
283 {
284 private:
285 OrthancPluginContext* context_;
286 DatabaseBackendOutput* output_;
287
288 void Finalize()
289 {
290 if (output_ != NULL)
291 {
292 delete output_;
293 output_ = NULL;
294 }
295 }
296
297 public:
298 // "context" can be NULL iff. running the unit tests
299 IDatabaseBackend() :
300 context_(NULL),
301 output_(NULL)
302 {
303 }
304
305 virtual ~IDatabaseBackend()
306 {
307 Finalize();
308 }
309
310 DatabaseBackendOutput& GetOutput()
311 {
312 return *output_;
313 }
314
315 OrthancPluginContext* GetContext() const
316 {
317 return context_;
318 }
319
320 // This takes the ownership
321 void RegisterOutput(OrthancPluginContext* context,
322 DatabaseBackendOutput* output)
323 {
324 Finalize();
325 context_ = context;
326 output_ = output;
327 }
328
329 virtual void Open() = 0;
330
331 virtual void Close() = 0;
332
333 virtual void AddAttachment(int64_t id,
334 const OrthancPluginAttachment& attachment) = 0;
335
336 virtual void AttachChild(int64_t parent,
337 int64_t child) = 0;
338
339 virtual void ClearChanges() = 0;
340
341 virtual void ClearExportedResources() = 0;
342
343 virtual int64_t CreateResource(const char* publicId,
344 OrthancPluginResourceType type) = 0;
345
346 virtual void DeleteAttachment(int64_t id,
347 int32_t attachment) = 0;
348
349 virtual void DeleteMetadata(int64_t id,
350 int32_t metadataType) = 0;
351
352 virtual void DeleteResource(int64_t id) = 0;
353
354 virtual void GetAllInternalIds(std::list<int64_t>& target,
355 OrthancPluginResourceType resourceType) = 0;
356
357 virtual void GetAllPublicIds(std::list<std::string>& target,
358 OrthancPluginResourceType resourceType) = 0;
359
360 virtual void GetAllPublicIds(std::list<std::string>& target,
361 OrthancPluginResourceType resourceType,
362 uint64_t since,
363 uint64_t limit) = 0;
364
365 /* Use GetOutput().AnswerChange() */
366 virtual void GetChanges(bool& done /*out*/,
367 int64_t since,
368 uint32_t maxResults) = 0;
369
370 virtual void GetChildrenInternalId(std::list<int64_t>& target /*out*/,
371 int64_t id) = 0;
372
373 virtual void GetChildrenPublicId(std::list<std::string>& target /*out*/,
374 int64_t id) = 0;
375
376 /* Use GetOutput().AnswerExportedResource() */
377 virtual void GetExportedResources(bool& done /*out*/,
378 int64_t since,
379 uint32_t maxResults) = 0;
380
381 /* Use GetOutput().AnswerChange() */
382 virtual void GetLastChange() = 0;
383
384 /* Use GetOutput().AnswerExportedResource() */
385 virtual void GetLastExportedResource() = 0;
386
387 /* Use GetOutput().AnswerDicomTag() */
388 virtual void GetMainDicomTags(int64_t id) = 0;
389
390 virtual std::string GetPublicId(int64_t resourceId) = 0;
391
392 virtual uint64_t GetResourceCount(OrthancPluginResourceType resourceType) = 0;
393
394 virtual OrthancPluginResourceType GetResourceType(int64_t resourceId) = 0;
395
396 virtual uint64_t GetTotalCompressedSize() = 0;
397
398 virtual uint64_t GetTotalUncompressedSize() = 0;
399
400 virtual bool IsExistingResource(int64_t internalId) = 0;
401
402 virtual bool IsProtectedPatient(int64_t internalId) = 0;
403
404 virtual void ListAvailableMetadata(std::list<int32_t>& target /*out*/,
405 int64_t id) = 0;
406
407 virtual void ListAvailableAttachments(std::list<int32_t>& target /*out*/,
408 int64_t id) = 0;
409
410 virtual void LogChange(const OrthancPluginChange& change) = 0;
411
412 virtual void LogExportedResource(const OrthancPluginExportedResource& resource) = 0;
413
414 /* Use GetOutput().AnswerAttachment() */
415 virtual bool LookupAttachment(int64_t id,
416 int32_t contentType) = 0;
417
418 virtual bool LookupGlobalProperty(std::string& target /*out*/,
419 int32_t property) = 0;
420
421 virtual void LookupIdentifier(std::list<int64_t>& target /*out*/,
422 OrthancPluginResourceType resourceType,
423 uint16_t group,
424 uint16_t element,
425 OrthancPluginIdentifierConstraint constraint,
426 const char* value) = 0;
427
428 virtual void LookupIdentifierRange(std::list<int64_t>& target /*out*/,
429 OrthancPluginResourceType resourceType,
430 uint16_t group,
431 uint16_t element,
432 const char* start,
433 const char* end) = 0;
434
435 virtual bool LookupMetadata(std::string& target /*out*/,
436 int64_t id,
437 int32_t metadataType) = 0;
438
439 virtual bool LookupParent(int64_t& parentId /*out*/,
440 int64_t resourceId) = 0;
441
442 virtual bool LookupResource(int64_t& id /*out*/,
443 OrthancPluginResourceType& type /*out*/,
444 const char* publicId) = 0;
445
446 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/) = 0;
447
448 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/,
449 int64_t patientIdToAvoid) = 0;
450
451 virtual void SetGlobalProperty(int32_t property,
452 const char* value) = 0;
453
454 virtual void SetMainDicomTag(int64_t id,
455 uint16_t group,
456 uint16_t element,
457 const char* value) = 0;
458
459 virtual void SetIdentifierTag(int64_t id,
460 uint16_t group,
461 uint16_t element,
462 const char* value) = 0;
463
464 virtual void SetMetadata(int64_t id,
465 int32_t metadataType,
466 const char* value) = 0;
467
468 virtual void SetProtectedPatient(int64_t internalId,
469 bool isProtected) = 0;
470
471 virtual void StartTransaction() = 0;
472
473 virtual void RollbackTransaction() = 0;
474
475 virtual void CommitTransaction() = 0;
476
477 virtual uint32_t GetDatabaseVersion() = 0;
478
479 /**
480 * Upgrade the database to the specified version of the database
481 * schema. The upgrade script is allowed to make calls to
482 * OrthancPluginReconstructMainDicomTags().
483 **/
484 virtual void UpgradeDatabase(uint32_t targetVersion,
485 OrthancPluginStorageArea* storageArea) = 0;
486
487 virtual void ClearMainDicomTags(int64_t internalId) = 0;
488
489 virtual bool HasCreateInstance() const
490 {
491 return false;
492 }
493
494 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
495 virtual void LookupResources(const std::vector<Orthanc::DatabaseConstraint>& lookup,
496 OrthancPluginResourceType queryLevel,
497 uint32_t limit,
498 bool requestSomeInstance) = 0;
499 #endif
500
501 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
502 virtual void CreateInstance(OrthancPluginCreateInstanceResult& result,
503 const char* hashPatient,
504 const char* hashStudy,
505 const char* hashSeries,
506 const char* hashInstance)
507 {
508 throw std::runtime_error("Not implemented");
509 }
510 #endif
511
512
513 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
514 virtual void SetResourcesContent(
515 uint32_t countIdentifierTags,
516 const OrthancPluginResourcesContentTags* identifierTags,
517 uint32_t countMainDicomTags,
518 const OrthancPluginResourcesContentTags* mainDicomTags,
519 uint32_t countMetadata,
520 const OrthancPluginResourcesContentMetadata* metadata) = 0;
521 #endif
522
523
524 virtual void GetChildrenMetadata(std::list<std::string>& target,
525 int64_t resourceId,
526 int32_t metadata) = 0;
527
528 virtual int64_t GetLastChangeIndex() = 0;
529
530 virtual void TagMostRecentPatient(int64_t patientId) = 0;
531
532 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1
533 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4)
534 // NB: "parentPublicId" must be cleared if the resource has no parent
535 virtual bool LookupResourceAndParent(int64_t& id,
536 OrthancPluginResourceType& type,
537 std::string& parentPublicId,
538 const char* publicId) = 0;
539 # endif
540 #endif
541
542 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1
543 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4)
544 virtual void GetAllMetadata(std::map<int32_t, std::string>& result,
545 int64_t id) = 0;
546 # endif
547 #endif
548 };
549
550 601
551 602
552 /** 603 /**
553 * @brief Bridge between C and C++ database engines. 604 * @brief Bridge between C and C++ database engines.
554 * 605 *
556 * custom database engines, and the high-level IDatabaseBackend C++ 607 * custom database engines, and the high-level IDatabaseBackend C++
557 * interface. 608 * interface.
558 * 609 *
559 * @ingroup Callbacks 610 * @ingroup Callbacks
560 **/ 611 **/
561 class DatabaseBackendAdapter 612 class DatabaseBackendAdapterV2
562 { 613 {
563 private: 614 private:
564 // This class cannot be instantiated 615 // This class cannot be instantiated
565 DatabaseBackendAdapter() 616 DatabaseBackendAdapterV2()
566 { 617 {
567 } 618 }
568 619
569 static void LogError(IDatabaseBackend* backend, 620 static void LogError(IDatabaseBackend* backend,
570 const std::runtime_error& e) 621 const std::runtime_error& e)
577 static OrthancPluginErrorCode AddAttachment(void* payload, 628 static OrthancPluginErrorCode AddAttachment(void* payload,
578 int64_t id, 629 int64_t id,
579 const OrthancPluginAttachment* attachment) 630 const OrthancPluginAttachment* attachment)
580 { 631 {
581 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 632 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
582 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 633 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
634 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
583 635
584 try 636 try
585 { 637 {
586 backend->AddAttachment(id, *attachment); 638 backend->AddAttachment(id, *attachment);
587 return OrthancPluginErrorCode_Success; 639 return OrthancPluginErrorCode_Success;
588 } 640 }
589 ORTHANC_PLUGINS_DATABASE_CATCH 641 ORTHANC_PLUGINS_DATABASE_CATCH;
590 } 642 }
591 643
592 644
593 static OrthancPluginErrorCode AttachChild(void* payload, 645 static OrthancPluginErrorCode AttachChild(void* payload,
594 int64_t parent, 646 int64_t parent,
595 int64_t child) 647 int64_t child)
596 { 648 {
597 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 649 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
598 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 650 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
651 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
599 652
600 try 653 try
601 { 654 {
602 backend->AttachChild(parent, child); 655 backend->AttachChild(parent, child);
603 return OrthancPluginErrorCode_Success; 656 return OrthancPluginErrorCode_Success;
604 } 657 }
605 ORTHANC_PLUGINS_DATABASE_CATCH 658 ORTHANC_PLUGINS_DATABASE_CATCH;
606 } 659 }
607 660
608 661
609 static OrthancPluginErrorCode ClearChanges(void* payload) 662 static OrthancPluginErrorCode ClearChanges(void* payload)
610 { 663 {
611 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 664 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
612 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 665 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
666 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
613 667
614 try 668 try
615 { 669 {
616 backend->ClearChanges(); 670 backend->ClearChanges();
617 return OrthancPluginErrorCode_Success; 671 return OrthancPluginErrorCode_Success;
618 } 672 }
619 ORTHANC_PLUGINS_DATABASE_CATCH 673 ORTHANC_PLUGINS_DATABASE_CATCH;
620 } 674 }
621 675
622 676
623 static OrthancPluginErrorCode ClearExportedResources(void* payload) 677 static OrthancPluginErrorCode ClearExportedResources(void* payload)
624 { 678 {
625 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 679 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
626 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 680 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
681 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
627 682
628 try 683 try
629 { 684 {
630 backend->ClearExportedResources(); 685 backend->ClearExportedResources();
631 return OrthancPluginErrorCode_Success; 686 return OrthancPluginErrorCode_Success;
632 } 687 }
633 ORTHANC_PLUGINS_DATABASE_CATCH 688 ORTHANC_PLUGINS_DATABASE_CATCH;
634 } 689 }
635 690
636 691
637 static OrthancPluginErrorCode CreateResource(int64_t* id, 692 static OrthancPluginErrorCode CreateResource(int64_t* id,
638 void* payload, 693 void* payload,
639 const char* publicId, 694 const char* publicId,
640 OrthancPluginResourceType resourceType) 695 OrthancPluginResourceType resourceType)
641 { 696 {
642 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 697 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
643 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 698 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
699 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
644 700
645 try 701 try
646 { 702 {
647 *id = backend->CreateResource(publicId, resourceType); 703 *id = backend->CreateResource(publicId, resourceType);
648 return OrthancPluginErrorCode_Success; 704 return OrthancPluginErrorCode_Success;
649 } 705 }
650 ORTHANC_PLUGINS_DATABASE_CATCH 706 ORTHANC_PLUGINS_DATABASE_CATCH;
651 } 707 }
652 708
653 709
654 static OrthancPluginErrorCode DeleteAttachment(void* payload, 710 static OrthancPluginErrorCode DeleteAttachment(void* payload,
655 int64_t id, 711 int64_t id,
656 int32_t contentType) 712 int32_t contentType)
657 { 713 {
658 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 714 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
659 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 715 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
716 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
660 717
661 try 718 try
662 { 719 {
663 backend->DeleteAttachment(id, contentType); 720 backend->DeleteAttachment(id, contentType);
664 return OrthancPluginErrorCode_Success; 721 return OrthancPluginErrorCode_Success;
665 } 722 }
666 ORTHANC_PLUGINS_DATABASE_CATCH 723 ORTHANC_PLUGINS_DATABASE_CATCH;
667 } 724 }
668 725
669 726
670 static OrthancPluginErrorCode DeleteMetadata(void* payload, 727 static OrthancPluginErrorCode DeleteMetadata(void* payload,
671 int64_t id, 728 int64_t id,
672 int32_t metadataType) 729 int32_t metadataType)
673 { 730 {
674 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 731 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
675 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 732 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
733 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
676 734
677 try 735 try
678 { 736 {
679 backend->DeleteMetadata(id, metadataType); 737 backend->DeleteMetadata(id, metadataType);
680 return OrthancPluginErrorCode_Success; 738 return OrthancPluginErrorCode_Success;
681 } 739 }
682 ORTHANC_PLUGINS_DATABASE_CATCH 740 ORTHANC_PLUGINS_DATABASE_CATCH;
683 } 741 }
684 742
685 743
686 static OrthancPluginErrorCode DeleteResource(void* payload, 744 static OrthancPluginErrorCode DeleteResource(void* payload,
687 int64_t id) 745 int64_t id)
688 { 746 {
689 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 747 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
690 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 748 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
749 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
691 750
692 try 751 try
693 { 752 {
694 backend->DeleteResource(id); 753 backend->DeleteResource(id);
695 return OrthancPluginErrorCode_Success; 754 return OrthancPluginErrorCode_Success;
696 } 755 }
697 ORTHANC_PLUGINS_DATABASE_CATCH 756 ORTHANC_PLUGINS_DATABASE_CATCH;
698 } 757 }
699 758
700 759
701 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context, 760 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context,
702 void* payload, 761 void* payload,
703 OrthancPluginResourceType resourceType) 762 OrthancPluginResourceType resourceType)
704 { 763 {
705 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 764 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
706 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 765 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
766 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
707 767
708 try 768 try
709 { 769 {
710 std::list<int64_t> target; 770 std::list<int64_t> target;
711 backend->GetAllInternalIds(target, resourceType); 771 backend->GetAllInternalIds(target, resourceType);
712 772
713 for (std::list<int64_t>::const_iterator 773 for (std::list<int64_t>::const_iterator
714 it = target.begin(); it != target.end(); ++it) 774 it = target.begin(); it != target.end(); ++it)
715 { 775 {
716 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 776 OrthancPluginDatabaseAnswerInt64(backend->GetContext(),
717 backend->GetOutput().GetDatabase(), *it); 777 output.GetDatabase(), *it);
718 } 778 }
719 779
720 return OrthancPluginErrorCode_Success; 780 return OrthancPluginErrorCode_Success;
721 } 781 }
722 ORTHANC_PLUGINS_DATABASE_CATCH 782 ORTHANC_PLUGINS_DATABASE_CATCH;
723 } 783 }
724 784
725 785
726 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context, 786 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context,
727 void* payload, 787 void* payload,
728 OrthancPluginResourceType resourceType) 788 OrthancPluginResourceType resourceType)
729 { 789 {
730 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 790 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
731 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 791 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
792 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
732 793
733 try 794 try
734 { 795 {
735 std::list<std::string> ids; 796 std::list<std::string> ids;
736 backend->GetAllPublicIds(ids, resourceType); 797 backend->GetAllPublicIds(ids, resourceType);
737 798
738 for (std::list<std::string>::const_iterator 799 for (std::list<std::string>::const_iterator
739 it = ids.begin(); it != ids.end(); ++it) 800 it = ids.begin(); it != ids.end(); ++it)
740 { 801 {
741 OrthancPluginDatabaseAnswerString(backend->GetContext(), 802 OrthancPluginDatabaseAnswerString(backend->GetContext(),
742 backend->GetOutput().GetDatabase(), 803 output.GetDatabase(),
743 it->c_str()); 804 it->c_str());
744 } 805 }
745 806
746 return OrthancPluginErrorCode_Success; 807 return OrthancPluginErrorCode_Success;
747 } 808 }
748 ORTHANC_PLUGINS_DATABASE_CATCH 809 ORTHANC_PLUGINS_DATABASE_CATCH;
749 } 810 }
750 811
751 812
752 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseContext* context, 813 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseContext* context,
753 void* payload, 814 void* payload,
754 OrthancPluginResourceType resourceType, 815 OrthancPluginResourceType resourceType,
755 uint64_t since, 816 uint64_t since,
756 uint64_t limit) 817 uint64_t limit)
757 { 818 {
758 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 819 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
759 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 820 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
821 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
760 822
761 try 823 try
762 { 824 {
763 std::list<std::string> ids; 825 std::list<std::string> ids;
764 backend->GetAllPublicIds(ids, resourceType, since, limit); 826 backend->GetAllPublicIds(ids, resourceType, since, limit);
765 827
766 for (std::list<std::string>::const_iterator 828 for (std::list<std::string>::const_iterator
767 it = ids.begin(); it != ids.end(); ++it) 829 it = ids.begin(); it != ids.end(); ++it)
768 { 830 {
769 OrthancPluginDatabaseAnswerString(backend->GetContext(), 831 OrthancPluginDatabaseAnswerString(backend->GetContext(),
770 backend->GetOutput().GetDatabase(), 832 output.GetDatabase(),
771 it->c_str()); 833 it->c_str());
772 } 834 }
773 835
774 return OrthancPluginErrorCode_Success; 836 return OrthancPluginErrorCode_Success;
775 } 837 }
776 ORTHANC_PLUGINS_DATABASE_CATCH 838 ORTHANC_PLUGINS_DATABASE_CATCH;
777 } 839 }
778 840
779 841
780 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context, 842 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context,
781 void* payload, 843 void* payload,
782 int64_t since, 844 int64_t since,
783 uint32_t maxResult) 845 uint32_t maxResult)
784 { 846 {
785 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 847 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
786 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change); 848 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
849 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_Change);
787 850
788 try 851 try
789 { 852 {
790 bool done; 853 bool done;
791 backend->GetChanges(done, since, maxResult); 854 backend->GetChanges(done, since, maxResult);
792 855
793 if (done) 856 if (done)
794 { 857 {
795 OrthancPluginDatabaseAnswerChangesDone(backend->GetContext(), 858 OrthancPluginDatabaseAnswerChangesDone(backend->GetContext(),
796 backend->GetOutput().GetDatabase()); 859 output.GetDatabase());
797 } 860 }
798 861
799 return OrthancPluginErrorCode_Success; 862 return OrthancPluginErrorCode_Success;
800 } 863 }
801 ORTHANC_PLUGINS_DATABASE_CATCH 864 ORTHANC_PLUGINS_DATABASE_CATCH;
802 } 865 }
803 866
804 867
805 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context, 868 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context,
806 void* payload, 869 void* payload,
807 int64_t id) 870 int64_t id)
808 { 871 {
809 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 872 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
810 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 873 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
874 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
811 875
812 try 876 try
813 { 877 {
814 std::list<int64_t> target; 878 std::list<int64_t> target;
815 backend->GetChildrenInternalId(target, id); 879 backend->GetChildrenInternalId(target, id);
816 880
817 for (std::list<int64_t>::const_iterator 881 for (std::list<int64_t>::const_iterator
818 it = target.begin(); it != target.end(); ++it) 882 it = target.begin(); it != target.end(); ++it)
819 { 883 {
820 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 884 OrthancPluginDatabaseAnswerInt64(backend->GetContext(),
821 backend->GetOutput().GetDatabase(), *it); 885 output.GetDatabase(), *it);
822 } 886 }
823 887
824 return OrthancPluginErrorCode_Success; 888 return OrthancPluginErrorCode_Success;
825 } 889 }
826 ORTHANC_PLUGINS_DATABASE_CATCH 890 ORTHANC_PLUGINS_DATABASE_CATCH;
827 } 891 }
828 892
829 893
830 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context, 894 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context,
831 void* payload, 895 void* payload,
832 int64_t id) 896 int64_t id)
833 { 897 {
834 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 898 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
835 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 899 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
900 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
836 901
837 try 902 try
838 { 903 {
839 std::list<std::string> ids; 904 std::list<std::string> ids;
840 backend->GetChildrenPublicId(ids, id); 905 backend->GetChildrenPublicId(ids, id);
841 906
842 for (std::list<std::string>::const_iterator 907 for (std::list<std::string>::const_iterator
843 it = ids.begin(); it != ids.end(); ++it) 908 it = ids.begin(); it != ids.end(); ++it)
844 { 909 {
845 OrthancPluginDatabaseAnswerString(backend->GetContext(), 910 OrthancPluginDatabaseAnswerString(backend->GetContext(),
846 backend->GetOutput().GetDatabase(), 911 output.GetDatabase(),
847 it->c_str()); 912 it->c_str());
848 } 913 }
849 914
850 return OrthancPluginErrorCode_Success; 915 return OrthancPluginErrorCode_Success;
851 } 916 }
852 ORTHANC_PLUGINS_DATABASE_CATCH 917 ORTHANC_PLUGINS_DATABASE_CATCH;
853 } 918 }
854 919
855 920
856 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context, 921 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context,
857 void* payload, 922 void* payload,
858 int64_t since, 923 int64_t since,
859 uint32_t maxResult) 924 uint32_t maxResult)
860 { 925 {
861 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 926 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
862 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource); 927 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
928 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_ExportedResource);
863 929
864 try 930 try
865 { 931 {
866 bool done; 932 bool done;
867 backend->GetExportedResources(done, since, maxResult); 933 backend->GetExportedResources(done, since, maxResult);
868 934
869 if (done) 935 if (done)
870 { 936 {
871 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetContext(), 937 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetContext(),
872 backend->GetOutput().GetDatabase()); 938 output.GetDatabase());
873 } 939 }
874 return OrthancPluginErrorCode_Success; 940 return OrthancPluginErrorCode_Success;
875 } 941 }
876 ORTHANC_PLUGINS_DATABASE_CATCH 942 ORTHANC_PLUGINS_DATABASE_CATCH;
877 } 943 }
878 944
879 945
880 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context, 946 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context,
881 void* payload) 947 void* payload)
882 { 948 {
883 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 949 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
884 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change); 950 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
951 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_Change);
885 952
886 try 953 try
887 { 954 {
888 backend->GetLastChange(); 955 backend->GetLastChange();
889 return OrthancPluginErrorCode_Success; 956 return OrthancPluginErrorCode_Success;
890 } 957 }
891 ORTHANC_PLUGINS_DATABASE_CATCH 958 ORTHANC_PLUGINS_DATABASE_CATCH;
892 } 959 }
893 960
894 961
895 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context, 962 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context,
896 void* payload) 963 void* payload)
897 { 964 {
898 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 965 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
899 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource); 966 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
967 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_ExportedResource);
900 968
901 try 969 try
902 { 970 {
903 backend->GetLastExportedResource(); 971 backend->GetLastExportedResource();
904 return OrthancPluginErrorCode_Success; 972 return OrthancPluginErrorCode_Success;
905 } 973 }
906 ORTHANC_PLUGINS_DATABASE_CATCH 974 ORTHANC_PLUGINS_DATABASE_CATCH;
907 } 975 }
908 976
909 977
910 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context, 978 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context,
911 void* payload, 979 void* payload,
912 int64_t id) 980 int64_t id)
913 { 981 {
914 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 982 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
915 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_DicomTag); 983 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
984 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_DicomTag);
916 985
917 try 986 try
918 { 987 {
919 backend->GetMainDicomTags(id); 988 backend->GetMainDicomTags(id);
920 return OrthancPluginErrorCode_Success; 989 return OrthancPluginErrorCode_Success;
921 } 990 }
922 ORTHANC_PLUGINS_DATABASE_CATCH 991 ORTHANC_PLUGINS_DATABASE_CATCH;
923 } 992 }
924 993
925 994
926 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context, 995 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context,
927 void* payload, 996 void* payload,
928 int64_t id) 997 int64_t id)
929 { 998 {
930 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 999 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
931 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1000 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1001 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
932 1002
933 try 1003 try
934 { 1004 {
935 std::string s = backend->GetPublicId(id); 1005 std::string s = backend->GetPublicId(id);
936 OrthancPluginDatabaseAnswerString(backend->GetContext(), 1006 OrthancPluginDatabaseAnswerString(backend->GetContext(),
937 backend->GetOutput().GetDatabase(), 1007 output.GetDatabase(),
938 s.c_str()); 1008 s.c_str());
939 1009
940 return OrthancPluginErrorCode_Success; 1010 return OrthancPluginErrorCode_Success;
941 } 1011 }
942 ORTHANC_PLUGINS_DATABASE_CATCH 1012 ORTHANC_PLUGINS_DATABASE_CATCH;
943 } 1013 }
944 1014
945 1015
946 static OrthancPluginErrorCode GetResourceCount(uint64_t* target, 1016 static OrthancPluginErrorCode GetResourceCount(uint64_t* target,
947 void* payload, 1017 void* payload,
948 OrthancPluginResourceType resourceType) 1018 OrthancPluginResourceType resourceType)
949 { 1019 {
950 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1020 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
951 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1021 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1022 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
952 1023
953 try 1024 try
954 { 1025 {
955 *target = backend->GetResourceCount(resourceType); 1026 *target = backend->GetResourceCount(resourceType);
956 return OrthancPluginErrorCode_Success; 1027 return OrthancPluginErrorCode_Success;
957 } 1028 }
958 ORTHANC_PLUGINS_DATABASE_CATCH 1029 ORTHANC_PLUGINS_DATABASE_CATCH;
959 } 1030 }
960 1031
961 1032
962 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType, 1033 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType,
963 void* payload, 1034 void* payload,
964 int64_t id) 1035 int64_t id)
965 { 1036 {
966 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1037 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
967 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1038 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1039 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
968 1040
969 try 1041 try
970 { 1042 {
971 *resourceType = backend->GetResourceType(id); 1043 *resourceType = backend->GetResourceType(id);
972 return OrthancPluginErrorCode_Success; 1044 return OrthancPluginErrorCode_Success;
973 } 1045 }
974 ORTHANC_PLUGINS_DATABASE_CATCH 1046 ORTHANC_PLUGINS_DATABASE_CATCH;
975 } 1047 }
976 1048
977 1049
978 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target, 1050 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target,
979 void* payload) 1051 void* payload)
980 { 1052 {
981 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1053 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
982 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1054 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1055 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
983 1056
984 try 1057 try
985 { 1058 {
986 *target = backend->GetTotalCompressedSize(); 1059 *target = backend->GetTotalCompressedSize();
987 return OrthancPluginErrorCode_Success; 1060 return OrthancPluginErrorCode_Success;
988 } 1061 }
989 ORTHANC_PLUGINS_DATABASE_CATCH 1062 ORTHANC_PLUGINS_DATABASE_CATCH;
990 } 1063 }
991 1064
992 1065
993 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target, 1066 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target,
994 void* payload) 1067 void* payload)
995 { 1068 {
996 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1069 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
997 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1070 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1071 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
998 1072
999 try 1073 try
1000 { 1074 {
1001 *target = backend->GetTotalUncompressedSize(); 1075 *target = backend->GetTotalUncompressedSize();
1002 return OrthancPluginErrorCode_Success; 1076 return OrthancPluginErrorCode_Success;
1003 } 1077 }
1004 ORTHANC_PLUGINS_DATABASE_CATCH 1078 ORTHANC_PLUGINS_DATABASE_CATCH;
1005 } 1079 }
1006 1080
1007 1081
1008 static OrthancPluginErrorCode IsExistingResource(int32_t* existing, 1082 static OrthancPluginErrorCode IsExistingResource(int32_t* existing,
1009 void* payload, 1083 void* payload,
1010 int64_t id) 1084 int64_t id)
1011 { 1085 {
1012 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1086 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1013 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1087 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1088 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1014 1089
1015 try 1090 try
1016 { 1091 {
1017 *existing = backend->IsExistingResource(id); 1092 *existing = backend->IsExistingResource(id);
1018 return OrthancPluginErrorCode_Success; 1093 return OrthancPluginErrorCode_Success;
1019 } 1094 }
1020 ORTHANC_PLUGINS_DATABASE_CATCH 1095 ORTHANC_PLUGINS_DATABASE_CATCH;
1021 } 1096 }
1022 1097
1023 1098
1024 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected, 1099 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected,
1025 void* payload, 1100 void* payload,
1026 int64_t id) 1101 int64_t id)
1027 { 1102 {
1028 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1103 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1029 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1104 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1105 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1030 1106
1031 try 1107 try
1032 { 1108 {
1033 *isProtected = backend->IsProtectedPatient(id); 1109 *isProtected = backend->IsProtectedPatient(id);
1034 return OrthancPluginErrorCode_Success; 1110 return OrthancPluginErrorCode_Success;
1035 } 1111 }
1036 ORTHANC_PLUGINS_DATABASE_CATCH 1112 ORTHANC_PLUGINS_DATABASE_CATCH;
1037 } 1113 }
1038 1114
1039 1115
1040 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context, 1116 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context,
1041 void* payload, 1117 void* payload,
1042 int64_t id) 1118 int64_t id)
1043 { 1119 {
1044 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1120 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1045 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1121 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1122 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1046 1123
1047 try 1124 try
1048 { 1125 {
1049 std::list<int32_t> target; 1126 std::list<int32_t> target;
1050 backend->ListAvailableMetadata(target, id); 1127 backend->ListAvailableMetadata(target, id);
1051 1128
1052 for (std::list<int32_t>::const_iterator 1129 for (std::list<int32_t>::const_iterator
1053 it = target.begin(); it != target.end(); ++it) 1130 it = target.begin(); it != target.end(); ++it)
1054 { 1131 {
1055 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), 1132 OrthancPluginDatabaseAnswerInt32(backend->GetContext(),
1056 backend->GetOutput().GetDatabase(), 1133 output.GetDatabase(),
1057 *it); 1134 *it);
1058 } 1135 }
1059 1136
1060 return OrthancPluginErrorCode_Success; 1137 return OrthancPluginErrorCode_Success;
1061 } 1138 }
1062 ORTHANC_PLUGINS_DATABASE_CATCH 1139 ORTHANC_PLUGINS_DATABASE_CATCH;
1063 } 1140 }
1064 1141
1065 1142
1066 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context, 1143 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context,
1067 void* payload, 1144 void* payload,
1068 int64_t id) 1145 int64_t id)
1069 { 1146 {
1070 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1147 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1071 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1148 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1149 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1072 1150
1073 try 1151 try
1074 { 1152 {
1075 std::list<int32_t> target; 1153 std::list<int32_t> target;
1076 backend->ListAvailableAttachments(target, id); 1154 backend->ListAvailableAttachments(target, id);
1077 1155
1078 for (std::list<int32_t>::const_iterator 1156 for (std::list<int32_t>::const_iterator
1079 it = target.begin(); it != target.end(); ++it) 1157 it = target.begin(); it != target.end(); ++it)
1080 { 1158 {
1081 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), 1159 OrthancPluginDatabaseAnswerInt32(backend->GetContext(),
1082 backend->GetOutput().GetDatabase(), 1160 output.GetDatabase(),
1083 *it); 1161 *it);
1084 } 1162 }
1085 1163
1086 return OrthancPluginErrorCode_Success; 1164 return OrthancPluginErrorCode_Success;
1087 } 1165 }
1088 ORTHANC_PLUGINS_DATABASE_CATCH 1166 ORTHANC_PLUGINS_DATABASE_CATCH;
1089 } 1167 }
1090 1168
1091 1169
1092 static OrthancPluginErrorCode LogChange(void* payload, 1170 static OrthancPluginErrorCode LogChange(void* payload,
1093 const OrthancPluginChange* change) 1171 const OrthancPluginChange* change)
1094 { 1172 {
1095 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1173 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1096 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1174 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1175 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1097 1176
1098 try 1177 try
1099 { 1178 {
1100 backend->LogChange(*change); 1179 backend->LogChange(*change);
1101 return OrthancPluginErrorCode_Success; 1180 return OrthancPluginErrorCode_Success;
1102 } 1181 }
1103 ORTHANC_PLUGINS_DATABASE_CATCH 1182 ORTHANC_PLUGINS_DATABASE_CATCH;
1104 } 1183 }
1105 1184
1106 1185
1107 static OrthancPluginErrorCode LogExportedResource(void* payload, 1186 static OrthancPluginErrorCode LogExportedResource(void* payload,
1108 const OrthancPluginExportedResource* exported) 1187 const OrthancPluginExportedResource* exported)
1109 { 1188 {
1110 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1189 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1111 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1190 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1191 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1112 1192
1113 try 1193 try
1114 { 1194 {
1115 backend->LogExportedResource(*exported); 1195 backend->LogExportedResource(*exported);
1116 return OrthancPluginErrorCode_Success; 1196 return OrthancPluginErrorCode_Success;
1117 } 1197 }
1118 ORTHANC_PLUGINS_DATABASE_CATCH 1198 ORTHANC_PLUGINS_DATABASE_CATCH;
1119 } 1199 }
1120 1200
1121 1201
1122 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context, 1202 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context,
1123 void* payload, 1203 void* payload,
1124 int64_t id, 1204 int64_t id,
1125 int32_t contentType) 1205 int32_t contentType)
1126 { 1206 {
1127 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1207 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1128 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Attachment); 1208 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1209 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_Attachment);
1129 1210
1130 try 1211 try
1131 { 1212 {
1132 backend->LookupAttachment(id, contentType); 1213 backend->LookupAttachment(id, contentType);
1133 return OrthancPluginErrorCode_Success; 1214 return OrthancPluginErrorCode_Success;
1134 } 1215 }
1135 ORTHANC_PLUGINS_DATABASE_CATCH 1216 ORTHANC_PLUGINS_DATABASE_CATCH;
1136 } 1217 }
1137 1218
1138 1219
1139 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context, 1220 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context,
1140 void* payload, 1221 void* payload,
1141 int32_t property) 1222 int32_t property)
1142 { 1223 {
1143 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1224 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1144 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1225 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1226 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1145 1227
1146 try 1228 try
1147 { 1229 {
1148 std::string s; 1230 std::string s;
1149 if (backend->LookupGlobalProperty(s, property)) 1231 if (backend->LookupGlobalProperty(s, property))
1150 { 1232 {
1151 OrthancPluginDatabaseAnswerString(backend->GetContext(), 1233 OrthancPluginDatabaseAnswerString(backend->GetContext(),
1152 backend->GetOutput().GetDatabase(), 1234 output.GetDatabase(),
1153 s.c_str()); 1235 s.c_str());
1154 } 1236 }
1155 1237
1156 return OrthancPluginErrorCode_Success; 1238 return OrthancPluginErrorCode_Success;
1157 } 1239 }
1158 ORTHANC_PLUGINS_DATABASE_CATCH 1240 ORTHANC_PLUGINS_DATABASE_CATCH;
1159 } 1241 }
1160 1242
1161 1243
1162 static OrthancPluginErrorCode LookupIdentifier3(OrthancPluginDatabaseContext* context, 1244 static OrthancPluginErrorCode LookupIdentifier3(OrthancPluginDatabaseContext* context,
1163 void* payload, 1245 void* payload,
1164 OrthancPluginResourceType resourceType, 1246 OrthancPluginResourceType resourceType,
1165 const OrthancPluginDicomTag* tag, 1247 const OrthancPluginDicomTag* tag,
1166 OrthancPluginIdentifierConstraint constraint) 1248 OrthancPluginIdentifierConstraint constraint)
1167 { 1249 {
1168 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1250 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1169 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1251 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1252 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1170 1253
1171 try 1254 try
1172 { 1255 {
1173 std::list<int64_t> target; 1256 std::list<int64_t> target;
1174 backend->LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value); 1257 backend->LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value);
1175 1258
1176 for (std::list<int64_t>::const_iterator 1259 for (std::list<int64_t>::const_iterator
1177 it = target.begin(); it != target.end(); ++it) 1260 it = target.begin(); it != target.end(); ++it)
1178 { 1261 {
1179 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 1262 OrthancPluginDatabaseAnswerInt64(backend->GetContext(),
1180 backend->GetOutput().GetDatabase(), *it); 1263 output.GetDatabase(), *it);
1181 } 1264 }
1182 1265
1183 return OrthancPluginErrorCode_Success; 1266 return OrthancPluginErrorCode_Success;
1184 } 1267 }
1185 ORTHANC_PLUGINS_DATABASE_CATCH 1268 ORTHANC_PLUGINS_DATABASE_CATCH;
1186 } 1269 }
1187 1270
1188 1271
1189 static OrthancPluginErrorCode LookupIdentifierRange(OrthancPluginDatabaseContext* context, 1272 static OrthancPluginErrorCode LookupIdentifierRange(OrthancPluginDatabaseContext* context,
1190 void* payload, 1273 void* payload,
1193 uint16_t element, 1276 uint16_t element,
1194 const char* start, 1277 const char* start,
1195 const char* end) 1278 const char* end)
1196 { 1279 {
1197 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1280 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1198 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1281 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1282 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1199 1283
1200 try 1284 try
1201 { 1285 {
1202 std::list<int64_t> target; 1286 std::list<int64_t> target;
1203 backend->LookupIdentifierRange(target, resourceType, group, element, start, end); 1287 backend->LookupIdentifierRange(target, resourceType, group, element, start, end);
1204 1288
1205 for (std::list<int64_t>::const_iterator 1289 for (std::list<int64_t>::const_iterator
1206 it = target.begin(); it != target.end(); ++it) 1290 it = target.begin(); it != target.end(); ++it)
1207 { 1291 {
1208 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 1292 OrthancPluginDatabaseAnswerInt64(backend->GetContext(),
1209 backend->GetOutput().GetDatabase(), *it); 1293 output.GetDatabase(), *it);
1210 } 1294 }
1211 1295
1212 return OrthancPluginErrorCode_Success; 1296 return OrthancPluginErrorCode_Success;
1213 } 1297 }
1214 ORTHANC_PLUGINS_DATABASE_CATCH 1298 ORTHANC_PLUGINS_DATABASE_CATCH;
1215 } 1299 }
1216 1300
1217 1301
1218 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context, 1302 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context,
1219 void* payload, 1303 void* payload,
1220 int64_t id, 1304 int64_t id,
1221 int32_t metadata) 1305 int32_t metadata)
1222 { 1306 {
1223 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1307 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1224 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1308 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1309 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1225 1310
1226 try 1311 try
1227 { 1312 {
1228 std::string s; 1313 std::string s;
1229 if (backend->LookupMetadata(s, id, metadata)) 1314 if (backend->LookupMetadata(s, id, metadata))
1230 { 1315 {
1231 OrthancPluginDatabaseAnswerString(backend->GetContext(), 1316 OrthancPluginDatabaseAnswerString(backend->GetContext(),
1232 backend->GetOutput().GetDatabase(), s.c_str()); 1317 output.GetDatabase(), s.c_str());
1233 } 1318 }
1234 1319
1235 return OrthancPluginErrorCode_Success; 1320 return OrthancPluginErrorCode_Success;
1236 } 1321 }
1237 ORTHANC_PLUGINS_DATABASE_CATCH 1322 ORTHANC_PLUGINS_DATABASE_CATCH;
1238 } 1323 }
1239 1324
1240 1325
1241 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context, 1326 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context,
1242 void* payload, 1327 void* payload,
1243 int64_t id) 1328 int64_t id)
1244 { 1329 {
1245 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1330 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1246 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1331 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1332 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1247 1333
1248 try 1334 try
1249 { 1335 {
1250 int64_t parent; 1336 int64_t parent;
1251 if (backend->LookupParent(parent, id)) 1337 if (backend->LookupParent(parent, id))
1252 { 1338 {
1253 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 1339 OrthancPluginDatabaseAnswerInt64(backend->GetContext(),
1254 backend->GetOutput().GetDatabase(), parent); 1340 output.GetDatabase(), parent);
1255 } 1341 }
1256 1342
1257 return OrthancPluginErrorCode_Success; 1343 return OrthancPluginErrorCode_Success;
1258 } 1344 }
1259 ORTHANC_PLUGINS_DATABASE_CATCH 1345 ORTHANC_PLUGINS_DATABASE_CATCH;
1260 } 1346 }
1261 1347
1262 1348
1263 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context, 1349 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context,
1264 void* payload, 1350 void* payload,
1265 const char* publicId) 1351 const char* publicId)
1266 { 1352 {
1267 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1353 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1268 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1354 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1355 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1269 1356
1270 try 1357 try
1271 { 1358 {
1272 int64_t id; 1359 int64_t id;
1273 OrthancPluginResourceType type; 1360 OrthancPluginResourceType type;
1274 if (backend->LookupResource(id, type, publicId)) 1361 if (backend->LookupResource(id, type, publicId))
1275 { 1362 {
1276 OrthancPluginDatabaseAnswerResource(backend->GetContext(), 1363 OrthancPluginDatabaseAnswerResource(backend->GetContext(),
1277 backend->GetOutput().GetDatabase(), 1364 output.GetDatabase(),
1278 id, type); 1365 id, type);
1279 } 1366 }
1280 1367
1281 return OrthancPluginErrorCode_Success; 1368 return OrthancPluginErrorCode_Success;
1282 } 1369 }
1283 ORTHANC_PLUGINS_DATABASE_CATCH 1370 ORTHANC_PLUGINS_DATABASE_CATCH;
1284 } 1371 }
1285 1372
1286 1373
1287 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context, 1374 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context,
1288 void* payload) 1375 void* payload)
1289 { 1376 {
1290 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1377 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1291 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1378 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1379 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1292 1380
1293 try 1381 try
1294 { 1382 {
1295 int64_t id; 1383 int64_t id;
1296 if (backend->SelectPatientToRecycle(id)) 1384 if (backend->SelectPatientToRecycle(id))
1297 { 1385 {
1298 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 1386 OrthancPluginDatabaseAnswerInt64(backend->GetContext(),
1299 backend->GetOutput().GetDatabase(), id); 1387 output.GetDatabase(), id);
1300 } 1388 }
1301 1389
1302 return OrthancPluginErrorCode_Success; 1390 return OrthancPluginErrorCode_Success;
1303 } 1391 }
1304 ORTHANC_PLUGINS_DATABASE_CATCH 1392 ORTHANC_PLUGINS_DATABASE_CATCH;
1305 } 1393 }
1306 1394
1307 1395
1308 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context, 1396 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context,
1309 void* payload, 1397 void* payload,
1310 int64_t patientIdToAvoid) 1398 int64_t patientIdToAvoid)
1311 { 1399 {
1312 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1400 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1313 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1401 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1402 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1314 1403
1315 try 1404 try
1316 { 1405 {
1317 int64_t id; 1406 int64_t id;
1318 if (backend->SelectPatientToRecycle(id, patientIdToAvoid)) 1407 if (backend->SelectPatientToRecycle(id, patientIdToAvoid))
1319 { 1408 {
1320 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 1409 OrthancPluginDatabaseAnswerInt64(backend->GetContext(),
1321 backend->GetOutput().GetDatabase(), id); 1410 output.GetDatabase(), id);
1322 } 1411 }
1323 1412
1324 return OrthancPluginErrorCode_Success; 1413 return OrthancPluginErrorCode_Success;
1325 } 1414 }
1326 ORTHANC_PLUGINS_DATABASE_CATCH 1415 ORTHANC_PLUGINS_DATABASE_CATCH;
1327 } 1416 }
1328 1417
1329 1418
1330 static OrthancPluginErrorCode SetGlobalProperty(void* payload, 1419 static OrthancPluginErrorCode SetGlobalProperty(void* payload,
1331 int32_t property, 1420 int32_t property,
1332 const char* value) 1421 const char* value)
1333 { 1422 {
1334 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1423 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1335 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1424 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1425 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1336 1426
1337 try 1427 try
1338 { 1428 {
1339 backend->SetGlobalProperty(property, value); 1429 backend->SetGlobalProperty(property, value);
1340 return OrthancPluginErrorCode_Success; 1430 return OrthancPluginErrorCode_Success;
1341 } 1431 }
1342 ORTHANC_PLUGINS_DATABASE_CATCH 1432 ORTHANC_PLUGINS_DATABASE_CATCH;
1343 } 1433 }
1344 1434
1345 1435
1346 static OrthancPluginErrorCode SetMainDicomTag(void* payload, 1436 static OrthancPluginErrorCode SetMainDicomTag(void* payload,
1347 int64_t id, 1437 int64_t id,
1348 const OrthancPluginDicomTag* tag) 1438 const OrthancPluginDicomTag* tag)
1349 { 1439 {
1350 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1440 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1351 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1441 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1442 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1352 1443
1353 try 1444 try
1354 { 1445 {
1355 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value); 1446 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value);
1356 return OrthancPluginErrorCode_Success; 1447 return OrthancPluginErrorCode_Success;
1357 } 1448 }
1358 ORTHANC_PLUGINS_DATABASE_CATCH 1449 ORTHANC_PLUGINS_DATABASE_CATCH;
1359 } 1450 }
1360 1451
1361 1452
1362 static OrthancPluginErrorCode SetIdentifierTag(void* payload, 1453 static OrthancPluginErrorCode SetIdentifierTag(void* payload,
1363 int64_t id, 1454 int64_t id,
1364 const OrthancPluginDicomTag* tag) 1455 const OrthancPluginDicomTag* tag)
1365 { 1456 {
1366 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1457 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1367 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1458 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1459 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1368 1460
1369 try 1461 try
1370 { 1462 {
1371 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value); 1463 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value);
1372 return OrthancPluginErrorCode_Success; 1464 return OrthancPluginErrorCode_Success;
1373 } 1465 }
1374 ORTHANC_PLUGINS_DATABASE_CATCH 1466 ORTHANC_PLUGINS_DATABASE_CATCH;
1375 } 1467 }
1376 1468
1377 1469
1378 static OrthancPluginErrorCode SetMetadata(void* payload, 1470 static OrthancPluginErrorCode SetMetadata(void* payload,
1379 int64_t id, 1471 int64_t id,
1380 int32_t metadata, 1472 int32_t metadata,
1381 const char* value) 1473 const char* value)
1382 { 1474 {
1383 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1475 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1384 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1476 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1477 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1385 1478
1386 try 1479 try
1387 { 1480 {
1388 backend->SetMetadata(id, metadata, value); 1481 backend->SetMetadata(id, metadata, value);
1389 return OrthancPluginErrorCode_Success; 1482 return OrthancPluginErrorCode_Success;
1390 } 1483 }
1391 ORTHANC_PLUGINS_DATABASE_CATCH 1484 ORTHANC_PLUGINS_DATABASE_CATCH;
1392 } 1485 }
1393 1486
1394 1487
1395 static OrthancPluginErrorCode SetProtectedPatient(void* payload, 1488 static OrthancPluginErrorCode SetProtectedPatient(void* payload,
1396 int64_t id, 1489 int64_t id,
1397 int32_t isProtected) 1490 int32_t isProtected)
1398 { 1491 {
1399 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1492 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1400 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1493 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1494 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1401 1495
1402 try 1496 try
1403 { 1497 {
1404 backend->SetProtectedPatient(id, (isProtected != 0)); 1498 backend->SetProtectedPatient(id, (isProtected != 0));
1405 return OrthancPluginErrorCode_Success; 1499 return OrthancPluginErrorCode_Success;
1406 } 1500 }
1407 ORTHANC_PLUGINS_DATABASE_CATCH 1501 ORTHANC_PLUGINS_DATABASE_CATCH;
1408 } 1502 }
1409 1503
1410 1504
1411 static OrthancPluginErrorCode StartTransaction(void* payload) 1505 static OrthancPluginErrorCode StartTransaction(void* payload)
1412 { 1506 {
1413 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1507 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1414 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1508 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1509 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1415 1510
1416 try 1511 try
1417 { 1512 {
1418 backend->StartTransaction(); 1513 backend->StartTransaction();
1419 return OrthancPluginErrorCode_Success; 1514 return OrthancPluginErrorCode_Success;
1420 } 1515 }
1421 ORTHANC_PLUGINS_DATABASE_CATCH 1516 ORTHANC_PLUGINS_DATABASE_CATCH;
1422 } 1517 }
1423 1518
1424 1519
1425 static OrthancPluginErrorCode RollbackTransaction(void* payload) 1520 static OrthancPluginErrorCode RollbackTransaction(void* payload)
1426 { 1521 {
1427 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1522 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1428 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1523 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1524 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1429 1525
1430 try 1526 try
1431 { 1527 {
1432 backend->RollbackTransaction(); 1528 backend->RollbackTransaction();
1433 return OrthancPluginErrorCode_Success; 1529 return OrthancPluginErrorCode_Success;
1434 } 1530 }
1435 ORTHANC_PLUGINS_DATABASE_CATCH 1531 ORTHANC_PLUGINS_DATABASE_CATCH;
1436 } 1532 }
1437 1533
1438 1534
1439 static OrthancPluginErrorCode CommitTransaction(void* payload) 1535 static OrthancPluginErrorCode CommitTransaction(void* payload)
1440 { 1536 {
1441 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1537 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1442 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1538 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1539 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1443 1540
1444 try 1541 try
1445 { 1542 {
1446 backend->CommitTransaction(); 1543 backend->CommitTransaction();
1447 return OrthancPluginErrorCode_Success; 1544 return OrthancPluginErrorCode_Success;
1448 } 1545 }
1449 ORTHANC_PLUGINS_DATABASE_CATCH 1546 ORTHANC_PLUGINS_DATABASE_CATCH;
1450 } 1547 }
1451 1548
1452 1549
1453 static OrthancPluginErrorCode Open(void* payload) 1550 static OrthancPluginErrorCode Open(void* payload)
1454 { 1551 {
1455 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1552 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1456 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1553 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1554 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1457 1555
1458 try 1556 try
1459 { 1557 {
1460 backend->Open(); 1558 backend->Open();
1461 return OrthancPluginErrorCode_Success; 1559 return OrthancPluginErrorCode_Success;
1462 } 1560 }
1463 ORTHANC_PLUGINS_DATABASE_CATCH 1561 ORTHANC_PLUGINS_DATABASE_CATCH;
1464 } 1562 }
1465 1563
1466 1564
1467 static OrthancPluginErrorCode Close(void* payload) 1565 static OrthancPluginErrorCode Close(void* payload)
1468 { 1566 {
1469 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1567 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1470 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1568 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1569 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1471 1570
1472 try 1571 try
1473 { 1572 {
1474 backend->Close(); 1573 backend->Close();
1475 return OrthancPluginErrorCode_Success; 1574 return OrthancPluginErrorCode_Success;
1476 } 1575 }
1477 ORTHANC_PLUGINS_DATABASE_CATCH 1576 ORTHANC_PLUGINS_DATABASE_CATCH;
1478 } 1577 }
1479 1578
1480 1579
1481 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version, 1580 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version,
1482 void* payload) 1581 void* payload)
1483 { 1582 {
1484 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1583 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1485 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1584 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1585 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1486 1586
1487 try 1587 try
1488 { 1588 {
1489 *version = backend->GetDatabaseVersion(); 1589 *version = backend->GetDatabaseVersion();
1490 return OrthancPluginErrorCode_Success; 1590 return OrthancPluginErrorCode_Success;
1491 } 1591 }
1492 ORTHANC_PLUGINS_DATABASE_CATCH 1592 ORTHANC_PLUGINS_DATABASE_CATCH;
1493 } 1593 }
1494 1594
1495 1595
1496 static OrthancPluginErrorCode UpgradeDatabase(void* payload, 1596 static OrthancPluginErrorCode UpgradeDatabase(void* payload,
1497 uint32_t targetVersion, 1597 uint32_t targetVersion,
1498 OrthancPluginStorageArea* storageArea) 1598 OrthancPluginStorageArea* storageArea)
1499 { 1599 {
1500 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1600 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1501 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1601 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1602 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1502 1603
1503 try 1604 try
1504 { 1605 {
1505 backend->UpgradeDatabase(targetVersion, storageArea); 1606 backend->UpgradeDatabase(targetVersion, storageArea);
1506 return OrthancPluginErrorCode_Success; 1607 return OrthancPluginErrorCode_Success;
1507 } 1608 }
1508 ORTHANC_PLUGINS_DATABASE_CATCH 1609 ORTHANC_PLUGINS_DATABASE_CATCH;
1509 } 1610 }
1510 1611
1511 1612
1512 static OrthancPluginErrorCode ClearMainDicomTags(void* payload, 1613 static OrthancPluginErrorCode ClearMainDicomTags(void* payload,
1513 int64_t internalId) 1614 int64_t internalId)
1514 { 1615 {
1515 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1616 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1516 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1617 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1618 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1517 1619
1518 try 1620 try
1519 { 1621 {
1520 backend->ClearMainDicomTags(internalId); 1622 backend->ClearMainDicomTags(internalId);
1521 return OrthancPluginErrorCode_Success; 1623 return OrthancPluginErrorCode_Success;
1522 } 1624 }
1523 ORTHANC_PLUGINS_DATABASE_CATCH 1625 ORTHANC_PLUGINS_DATABASE_CATCH;
1524 } 1626 }
1525 1627
1526 1628
1527 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 1629 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
1528 /* Use GetOutput().AnswerResource() */ 1630 /* Use GetOutput().AnswerResource() */
1534 OrthancPluginResourceType queryLevel, 1636 OrthancPluginResourceType queryLevel,
1535 uint32_t limit, 1637 uint32_t limit,
1536 uint8_t requestSomeInstance) 1638 uint8_t requestSomeInstance)
1537 { 1639 {
1538 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1640 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1539 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_MatchingResource); 1641 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1642 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_MatchingResource);
1540 1643
1541 try 1644 try
1542 { 1645 {
1543 std::vector<Orthanc::DatabaseConstraint> lookup; 1646 std::vector<Orthanc::DatabaseConstraint> lookup;
1544 lookup.reserve(constraintsCount); 1647 lookup.reserve(constraintsCount);
1549 } 1652 }
1550 1653
1551 backend->LookupResources(lookup, queryLevel, limit, (requestSomeInstance != 0)); 1654 backend->LookupResources(lookup, queryLevel, limit, (requestSomeInstance != 0));
1552 return OrthancPluginErrorCode_Success; 1655 return OrthancPluginErrorCode_Success;
1553 } 1656 }
1554 ORTHANC_PLUGINS_DATABASE_CATCH 1657 ORTHANC_PLUGINS_DATABASE_CATCH;
1555 } 1658 }
1556 #endif 1659 #endif
1557 1660
1558 1661
1559 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 1662 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
1560 static OrthancPluginErrorCode CreateInstance(OrthancPluginCreateInstanceResult* output, 1663 static OrthancPluginErrorCode CreateInstance(OrthancPluginCreateInstanceResult* target,
1561 void* payload, 1664 void* payload,
1562 const char* hashPatient, 1665 const char* hashPatient,
1563 const char* hashStudy, 1666 const char* hashStudy,
1564 const char* hashSeries, 1667 const char* hashSeries,
1565 const char* hashInstance) 1668 const char* hashInstance)
1566 { 1669 {
1567 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1670 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1568 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1671 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1569 1672 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1570 try 1673
1571 { 1674 try
1572 backend->CreateInstance(*output, hashPatient, hashStudy, hashSeries, hashInstance); 1675 {
1573 return OrthancPluginErrorCode_Success; 1676 backend->CreateInstance(*target, hashPatient, hashStudy, hashSeries, hashInstance);
1574 } 1677 return OrthancPluginErrorCode_Success;
1575 ORTHANC_PLUGINS_DATABASE_CATCH 1678 }
1679 ORTHANC_PLUGINS_DATABASE_CATCH;
1576 } 1680 }
1577 #endif 1681 #endif
1578 1682
1579 1683
1580 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 1684 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
1586 const OrthancPluginResourcesContentTags* mainDicomTags, 1690 const OrthancPluginResourcesContentTags* mainDicomTags,
1587 uint32_t countMetadata, 1691 uint32_t countMetadata,
1588 const OrthancPluginResourcesContentMetadata* metadata) 1692 const OrthancPluginResourcesContentMetadata* metadata)
1589 { 1693 {
1590 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1694 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1591 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1695 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1696 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1592 1697
1593 try 1698 try
1594 { 1699 {
1595 backend->SetResourcesContent(countIdentifierTags, identifierTags, 1700 backend->SetResourcesContent(countIdentifierTags, identifierTags,
1596 countMainDicomTags, mainDicomTags, 1701 countMainDicomTags, mainDicomTags,
1597 countMetadata, metadata); 1702 countMetadata, metadata);
1598 return OrthancPluginErrorCode_Success; 1703 return OrthancPluginErrorCode_Success;
1599 } 1704 }
1600 ORTHANC_PLUGINS_DATABASE_CATCH 1705 ORTHANC_PLUGINS_DATABASE_CATCH;
1601 } 1706 }
1602 #endif 1707 #endif
1603 1708
1604 1709
1605 // New primitive since Orthanc 1.5.2 1710 // New primitive since Orthanc 1.5.2
1607 void* payload, 1712 void* payload,
1608 int64_t resourceId, 1713 int64_t resourceId,
1609 int32_t metadata) 1714 int32_t metadata)
1610 { 1715 {
1611 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1716 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1612 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1717 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1718 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1613 1719
1614 try 1720 try
1615 { 1721 {
1616 std::list<std::string> values; 1722 std::list<std::string> values;
1617 backend->GetChildrenMetadata(values, resourceId, metadata); 1723 backend->GetChildrenMetadata(values, resourceId, metadata);
1618 1724
1619 for (std::list<std::string>::const_iterator 1725 for (std::list<std::string>::const_iterator
1620 it = values.begin(); it != values.end(); ++it) 1726 it = values.begin(); it != values.end(); ++it)
1621 { 1727 {
1622 OrthancPluginDatabaseAnswerString(backend->GetContext(), 1728 OrthancPluginDatabaseAnswerString(backend->GetContext(),
1623 backend->GetOutput().GetDatabase(), 1729 output.GetDatabase(),
1624 it->c_str()); 1730 it->c_str());
1625 } 1731 }
1626 1732
1627 return OrthancPluginErrorCode_Success; 1733 return OrthancPluginErrorCode_Success;
1628 } 1734 }
1629 ORTHANC_PLUGINS_DATABASE_CATCH 1735 ORTHANC_PLUGINS_DATABASE_CATCH;
1630 } 1736 }
1631 1737
1632 1738
1633 // New primitive since Orthanc 1.5.2 1739 // New primitive since Orthanc 1.5.2
1634 static OrthancPluginErrorCode GetLastChangeIndex(int64_t* result, 1740 static OrthancPluginErrorCode GetLastChangeIndex(int64_t* result,
1635 void* payload) 1741 void* payload)
1636 { 1742 {
1637 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1743 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1638 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1744 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1745 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1639 1746
1640 try 1747 try
1641 { 1748 {
1642 *result = backend->GetLastChangeIndex(); 1749 *result = backend->GetLastChangeIndex();
1643 return OrthancPluginErrorCode_Success; 1750 return OrthancPluginErrorCode_Success;
1644 } 1751 }
1645 ORTHANC_PLUGINS_DATABASE_CATCH 1752 ORTHANC_PLUGINS_DATABASE_CATCH;
1646 } 1753 }
1647 1754
1648 1755
1649 // New primitive since Orthanc 1.5.2 1756 // New primitive since Orthanc 1.5.2
1650 static OrthancPluginErrorCode TagMostRecentPatient(void* payload, 1757 static OrthancPluginErrorCode TagMostRecentPatient(void* payload,
1651 int64_t patientId) 1758 int64_t patientId)
1652 { 1759 {
1653 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1760 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1654 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); 1761 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1762 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_None);
1655 1763
1656 try 1764 try
1657 { 1765 {
1658 backend->TagMostRecentPatient(patientId); 1766 backend->TagMostRecentPatient(patientId);
1659 return OrthancPluginErrorCode_Success; 1767 return OrthancPluginErrorCode_Success;
1660 } 1768 }
1661 ORTHANC_PLUGINS_DATABASE_CATCH 1769 ORTHANC_PLUGINS_DATABASE_CATCH;
1662 } 1770 }
1663 1771
1664 1772
1665 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1 1773 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in 1.3.1
1666 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4) 1774 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4)
1668 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseContext* context, 1776 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseContext* context,
1669 void* payload, 1777 void* payload,
1670 int64_t resourceId) 1778 int64_t resourceId)
1671 { 1779 {
1672 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1780 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1673 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Metadata); 1781 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1782 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_Metadata);
1674 1783
1675 try 1784 try
1676 { 1785 {
1677 std::map<int32_t, std::string> result; 1786 std::map<int32_t, std::string> result;
1678 backend->GetAllMetadata(result, resourceId); 1787 backend->GetAllMetadata(result, resourceId);
1679 1788
1680 for (std::map<int32_t, std::string>::const_iterator 1789 for (std::map<int32_t, std::string>::const_iterator
1681 it = result.begin(); it != result.end(); ++it) 1790 it = result.begin(); it != result.end(); ++it)
1682 { 1791 {
1683 OrthancPluginDatabaseAnswerMetadata(backend->GetContext(), 1792 OrthancPluginDatabaseAnswerMetadata(backend->GetContext(),
1684 backend->GetOutput().GetDatabase(), 1793 output.GetDatabase(),
1685 resourceId, it->first, it->second.c_str()); 1794 resourceId, it->first, it->second.c_str());
1686 } 1795 }
1687 1796
1688 return OrthancPluginErrorCode_Success; 1797 return OrthancPluginErrorCode_Success;
1689 } 1798 }
1690 ORTHANC_PLUGINS_DATABASE_CATCH 1799 ORTHANC_PLUGINS_DATABASE_CATCH;
1691 } 1800 }
1692 # endif 1801 # endif
1693 #endif 1802 #endif
1694 1803
1695 1804
1702 OrthancPluginResourceType* type, 1811 OrthancPluginResourceType* type,
1703 void* payload, 1812 void* payload,
1704 const char* publicId) 1813 const char* publicId)
1705 { 1814 {
1706 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1815 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1707 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_String); 1816 DatabaseBackendOutputV2& output = dynamic_cast<DatabaseBackendOutputV2&>(backend->GetOutput());
1817 output.SetAllowedAnswers(DatabaseBackendOutputV2::AllowedAnswers_String);
1708 1818
1709 try 1819 try
1710 { 1820 {
1711 std::string parent; 1821 std::string parent;
1712 if (backend->LookupResourceAndParent(*id, *type, parent, publicId)) 1822 if (backend->LookupResourceAndParent(*id, *type, parent, publicId))
1714 *isExisting = 1; 1824 *isExisting = 1;
1715 1825
1716 if (!parent.empty()) 1826 if (!parent.empty())
1717 { 1827 {
1718 OrthancPluginDatabaseAnswerString(backend->GetContext(), 1828 OrthancPluginDatabaseAnswerString(backend->GetContext(),
1719 backend->GetOutput().GetDatabase(), 1829 output.GetDatabase(),
1720 parent.c_str()); 1830 parent.c_str());
1721 } 1831 }
1722 } 1832 }
1723 else 1833 else
1724 { 1834 {
1725 *isExisting = 0; 1835 *isExisting = 0;
1726 } 1836 }
1727 1837
1728 return OrthancPluginErrorCode_Success; 1838 return OrthancPluginErrorCode_Success;
1729 } 1839 }
1730 ORTHANC_PLUGINS_DATABASE_CATCH 1840 ORTHANC_PLUGINS_DATABASE_CATCH;
1731 } 1841 }
1732 # endif 1842 # endif
1733 #endif 1843 #endif
1734 1844
1735 1845
1857 if (!context) 1967 if (!context)
1858 { 1968 {
1859 throw std::runtime_error("Unable to register the database backend"); 1969 throw std::runtime_error("Unable to register the database backend");
1860 } 1970 }
1861 1971
1862 backend.RegisterOutput(context, new DatabaseBackendOutput(context, database)); 1972 backend.RegisterOutput(context, new DatabaseBackendOutputV2(context, database));
1863 } 1973 }
1864 }; 1974 };
1865 } 1975 }