Mercurial > hg > orthanc-databases
annotate Framework/Plugins/OrthancCppDatabasePlugin.h @ 24:17f849b2af34
sharing plugin initialization code
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 12 Jul 2018 12:17:39 +0200 |
parents | 9e419261f1c9 |
children | 714c5d2bee76 |
rev | line source |
---|---|
0 | 1 /** |
2 * Orthanc - A Lightweight, RESTful DICOM Store | |
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
4 * Department, University Hospital of Liege, Belgium | |
5 * Copyright (C) 2017-2018 Osimis S.A., Belgium | |
6 * | |
7 * This program is free software: you can redistribute it and/or | |
8 * modify it under the terms of the GNU Affero General Public License | |
9 * as published by the Free Software Foundation, either version 3 of | |
10 * the License, or (at your option) any later version. | |
11 * | |
12 * This program is distributed in the hope that it will be useful, but | |
13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Affero General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Affero General Public License | |
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
19 **/ | |
20 | |
21 | |
22 | |
23 /** | |
24 * NOTE: Until Orthanc 1.4.0, this file was part of the Orthanc source | |
25 * distribution. This file is now part of "orthanc-databases", in | |
26 * order to uncouple its evolution from the Orthanc core. | |
27 **/ | |
28 | |
29 #pragma once | |
30 | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
31 #if HAS_ORTHANC_EXCEPTION != 1 |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
32 # error HAS_ORTHANC_EXCEPTION must be set to 1 |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
33 #endif |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
34 |
0 | 35 |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
36 #include <orthanc/OrthancCDatabasePlugin.h> |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
37 #include <Core/OrthancException.h> |
0 | 38 |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
39 |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
40 #define ORTHANC_PLUGINS_DATABASE_CATCH \ |
0 | 41 catch (::Orthanc::OrthancException& e) \ |
42 { \ | |
43 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \ | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
44 } \ |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
45 catch (::std::runtime_error& e) \ |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
46 { \ |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
47 LogError(backend, e); \ |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
48 return OrthancPluginErrorCode_DatabasePlugin; \ |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
49 } \ |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
50 catch (...) \ |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
51 { \ |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
52 backend->GetOutput().LogError("Native exception"); \ |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
53 return OrthancPluginErrorCode_DatabasePlugin; \ |
0 | 54 } |
55 | |
56 | |
57 #include <stdexcept> | |
58 #include <list> | |
59 #include <string> | |
60 | |
61 namespace OrthancPlugins | |
62 { | |
63 /** | |
64 * @ingroup Callbacks | |
65 **/ | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
66 class DatabaseBackendOutput : public boost::noncopyable |
0 | 67 { |
68 friend class DatabaseBackendAdapter; | |
69 | |
70 private: | |
71 enum AllowedAnswers | |
72 { | |
73 AllowedAnswers_All, | |
74 AllowedAnswers_None, | |
75 AllowedAnswers_Attachment, | |
76 AllowedAnswers_Change, | |
77 AllowedAnswers_DicomTag, | |
78 AllowedAnswers_ExportedResource | |
79 }; | |
80 | |
81 OrthancPluginContext* context_; | |
82 OrthancPluginDatabaseContext* database_; | |
83 AllowedAnswers allowedAnswers_; | |
84 | |
85 void SetAllowedAnswers(AllowedAnswers allowed) | |
86 { | |
87 allowedAnswers_ = allowed; | |
88 } | |
89 | |
90 public: | |
91 DatabaseBackendOutput(OrthancPluginContext* context, | |
92 OrthancPluginDatabaseContext* database) : | |
93 context_(context), | |
94 database_(database), | |
95 allowedAnswers_(AllowedAnswers_All /* for unit tests */) | |
96 { | |
97 } | |
98 | |
99 OrthancPluginContext* GetContext() | |
100 { | |
101 return context_; | |
102 } | |
103 | |
104 void LogError(const std::string& message) | |
105 { | |
106 OrthancPluginLogError(context_, message.c_str()); | |
107 } | |
108 | |
109 void LogWarning(const std::string& message) | |
110 { | |
111 OrthancPluginLogWarning(context_, message.c_str()); | |
112 } | |
113 | |
114 void LogInfo(const std::string& message) | |
115 { | |
116 OrthancPluginLogInfo(context_, message.c_str()); | |
117 } | |
118 | |
119 void SignalDeletedAttachment(const std::string& uuid, | |
120 int32_t contentType, | |
121 uint64_t uncompressedSize, | |
122 const std::string& uncompressedHash, | |
123 int32_t compressionType, | |
124 uint64_t compressedSize, | |
125 const std::string& compressedHash) | |
126 { | |
127 OrthancPluginAttachment attachment; | |
128 attachment.uuid = uuid.c_str(); | |
129 attachment.contentType = contentType; | |
130 attachment.uncompressedSize = uncompressedSize; | |
131 attachment.uncompressedHash = uncompressedHash.c_str(); | |
132 attachment.compressionType = compressionType; | |
133 attachment.compressedSize = compressedSize; | |
134 attachment.compressedHash = compressedHash.c_str(); | |
135 | |
136 OrthancPluginDatabaseSignalDeletedAttachment(context_, database_, &attachment); | |
137 } | |
138 | |
139 void SignalDeletedResource(const std::string& publicId, | |
140 OrthancPluginResourceType resourceType) | |
141 { | |
142 OrthancPluginDatabaseSignalDeletedResource(context_, database_, publicId.c_str(), resourceType); | |
143 } | |
144 | |
145 void SignalRemainingAncestor(const std::string& ancestorId, | |
146 OrthancPluginResourceType ancestorType) | |
147 { | |
148 OrthancPluginDatabaseSignalRemainingAncestor(context_, database_, ancestorId.c_str(), ancestorType); | |
149 } | |
150 | |
151 void AnswerAttachment(const std::string& uuid, | |
152 int32_t contentType, | |
153 uint64_t uncompressedSize, | |
154 const std::string& uncompressedHash, | |
155 int32_t compressionType, | |
156 uint64_t compressedSize, | |
157 const std::string& compressedHash) | |
158 { | |
159 if (allowedAnswers_ != AllowedAnswers_All && | |
160 allowedAnswers_ != AllowedAnswers_Attachment) | |
161 { | |
162 throw std::runtime_error("Cannot answer with an attachment in the current state"); | |
163 } | |
164 | |
165 OrthancPluginAttachment attachment; | |
166 attachment.uuid = uuid.c_str(); | |
167 attachment.contentType = contentType; | |
168 attachment.uncompressedSize = uncompressedSize; | |
169 attachment.uncompressedHash = uncompressedHash.c_str(); | |
170 attachment.compressionType = compressionType; | |
171 attachment.compressedSize = compressedSize; | |
172 attachment.compressedHash = compressedHash.c_str(); | |
173 | |
174 OrthancPluginDatabaseAnswerAttachment(context_, database_, &attachment); | |
175 } | |
176 | |
177 void AnswerChange(int64_t seq, | |
178 int32_t changeType, | |
179 OrthancPluginResourceType resourceType, | |
180 const std::string& publicId, | |
181 const std::string& date) | |
182 { | |
183 if (allowedAnswers_ != AllowedAnswers_All && | |
184 allowedAnswers_ != AllowedAnswers_Change) | |
185 { | |
186 throw std::runtime_error("Cannot answer with a change in the current state"); | |
187 } | |
188 | |
189 OrthancPluginChange change; | |
190 change.seq = seq; | |
191 change.changeType = changeType; | |
192 change.resourceType = resourceType; | |
193 change.publicId = publicId.c_str(); | |
194 change.date = date.c_str(); | |
195 | |
196 OrthancPluginDatabaseAnswerChange(context_, database_, &change); | |
197 } | |
198 | |
199 void AnswerDicomTag(uint16_t group, | |
200 uint16_t element, | |
201 const std::string& value) | |
202 { | |
203 if (allowedAnswers_ != AllowedAnswers_All && | |
204 allowedAnswers_ != AllowedAnswers_DicomTag) | |
205 { | |
206 throw std::runtime_error("Cannot answer with a DICOM tag in the current state"); | |
207 } | |
208 | |
209 OrthancPluginDicomTag tag; | |
210 tag.group = group; | |
211 tag.element = element; | |
212 tag.value = value.c_str(); | |
213 | |
214 OrthancPluginDatabaseAnswerDicomTag(context_, database_, &tag); | |
215 } | |
216 | |
217 void AnswerExportedResource(int64_t seq, | |
218 OrthancPluginResourceType resourceType, | |
219 const std::string& publicId, | |
220 const std::string& modality, | |
221 const std::string& date, | |
222 const std::string& patientId, | |
223 const std::string& studyInstanceUid, | |
224 const std::string& seriesInstanceUid, | |
225 const std::string& sopInstanceUid) | |
226 { | |
227 if (allowedAnswers_ != AllowedAnswers_All && | |
228 allowedAnswers_ != AllowedAnswers_ExportedResource) | |
229 { | |
230 throw std::runtime_error("Cannot answer with an exported resource in the current state"); | |
231 } | |
232 | |
233 OrthancPluginExportedResource exported; | |
234 exported.seq = seq; | |
235 exported.resourceType = resourceType; | |
236 exported.publicId = publicId.c_str(); | |
237 exported.modality = modality.c_str(); | |
238 exported.date = date.c_str(); | |
239 exported.patientId = patientId.c_str(); | |
240 exported.studyInstanceUid = studyInstanceUid.c_str(); | |
241 exported.seriesInstanceUid = seriesInstanceUid.c_str(); | |
242 exported.sopInstanceUid = sopInstanceUid.c_str(); | |
243 | |
244 OrthancPluginDatabaseAnswerExportedResource(context_, database_, &exported); | |
245 } | |
246 }; | |
247 | |
248 | |
249 /** | |
250 * @ingroup Callbacks | |
251 **/ | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
252 class IDatabaseBackend : public boost::noncopyable |
0 | 253 { |
254 friend class DatabaseBackendAdapter; | |
255 | |
256 private: | |
257 DatabaseBackendOutput* output_; | |
258 | |
259 void Finalize() | |
260 { | |
261 if (output_ != NULL) | |
262 { | |
263 delete output_; | |
264 output_ = NULL; | |
265 } | |
266 } | |
267 | |
268 protected: | |
269 DatabaseBackendOutput& GetOutput() | |
270 { | |
271 return *output_; | |
272 } | |
273 | |
274 public: | |
275 IDatabaseBackend() : output_(NULL) | |
276 { | |
277 } | |
278 | |
279 virtual ~IDatabaseBackend() | |
280 { | |
281 Finalize(); | |
282 } | |
283 | |
284 // This takes the ownership | |
285 void RegisterOutput(DatabaseBackendOutput* output) | |
286 { | |
287 Finalize(); | |
288 output_ = output; | |
289 } | |
290 | |
291 virtual void Open() = 0; | |
292 | |
293 virtual void Close() = 0; | |
294 | |
295 virtual void AddAttachment(int64_t id, | |
296 const OrthancPluginAttachment& attachment) = 0; | |
297 | |
298 virtual void AttachChild(int64_t parent, | |
299 int64_t child) = 0; | |
300 | |
301 virtual void ClearChanges() = 0; | |
302 | |
303 virtual void ClearExportedResources() = 0; | |
304 | |
305 virtual int64_t CreateResource(const char* publicId, | |
306 OrthancPluginResourceType type) = 0; | |
307 | |
308 virtual void DeleteAttachment(int64_t id, | |
309 int32_t attachment) = 0; | |
310 | |
311 virtual void DeleteMetadata(int64_t id, | |
312 int32_t metadataType) = 0; | |
313 | |
314 virtual void DeleteResource(int64_t id) = 0; | |
315 | |
316 virtual void GetAllInternalIds(std::list<int64_t>& target, | |
317 OrthancPluginResourceType resourceType) = 0; | |
318 | |
319 virtual void GetAllPublicIds(std::list<std::string>& target, | |
320 OrthancPluginResourceType resourceType) = 0; | |
321 | |
322 virtual void GetAllPublicIds(std::list<std::string>& target, | |
323 OrthancPluginResourceType resourceType, | |
324 uint64_t since, | |
325 uint64_t limit) = 0; | |
326 | |
327 /* Use GetOutput().AnswerChange() */ | |
328 virtual void GetChanges(bool& done /*out*/, | |
329 int64_t since, | |
330 uint32_t maxResults) = 0; | |
331 | |
332 virtual void GetChildrenInternalId(std::list<int64_t>& target /*out*/, | |
333 int64_t id) = 0; | |
334 | |
335 virtual void GetChildrenPublicId(std::list<std::string>& target /*out*/, | |
336 int64_t id) = 0; | |
337 | |
338 /* Use GetOutput().AnswerExportedResource() */ | |
339 virtual void GetExportedResources(bool& done /*out*/, | |
340 int64_t since, | |
341 uint32_t maxResults) = 0; | |
342 | |
343 /* Use GetOutput().AnswerChange() */ | |
344 virtual void GetLastChange() = 0; | |
345 | |
346 /* Use GetOutput().AnswerExportedResource() */ | |
347 virtual void GetLastExportedResource() = 0; | |
348 | |
349 /* Use GetOutput().AnswerDicomTag() */ | |
350 virtual void GetMainDicomTags(int64_t id) = 0; | |
351 | |
352 virtual std::string GetPublicId(int64_t resourceId) = 0; | |
353 | |
354 virtual uint64_t GetResourceCount(OrthancPluginResourceType resourceType) = 0; | |
355 | |
356 virtual OrthancPluginResourceType GetResourceType(int64_t resourceId) = 0; | |
357 | |
358 virtual uint64_t GetTotalCompressedSize() = 0; | |
359 | |
360 virtual uint64_t GetTotalUncompressedSize() = 0; | |
361 | |
362 virtual bool IsExistingResource(int64_t internalId) = 0; | |
363 | |
364 virtual bool IsProtectedPatient(int64_t internalId) = 0; | |
365 | |
366 virtual void ListAvailableMetadata(std::list<int32_t>& target /*out*/, | |
367 int64_t id) = 0; | |
368 | |
369 virtual void ListAvailableAttachments(std::list<int32_t>& target /*out*/, | |
370 int64_t id) = 0; | |
371 | |
372 virtual void LogChange(const OrthancPluginChange& change) = 0; | |
373 | |
374 virtual void LogExportedResource(const OrthancPluginExportedResource& resource) = 0; | |
375 | |
376 /* Use GetOutput().AnswerAttachment() */ | |
377 virtual bool LookupAttachment(int64_t id, | |
378 int32_t contentType) = 0; | |
379 | |
380 virtual bool LookupGlobalProperty(std::string& target /*out*/, | |
381 int32_t property) = 0; | |
382 | |
383 virtual void LookupIdentifier(std::list<int64_t>& target /*out*/, | |
384 OrthancPluginResourceType resourceType, | |
385 uint16_t group, | |
386 uint16_t element, | |
387 OrthancPluginIdentifierConstraint constraint, | |
388 const char* value) = 0; | |
389 | |
390 virtual void LookupIdentifierRange(std::list<int64_t>& target /*out*/, | |
391 OrthancPluginResourceType resourceType, | |
392 uint16_t group, | |
393 uint16_t element, | |
394 const char* start, | |
395 const char* end) = 0; | |
396 | |
397 virtual bool LookupMetadata(std::string& target /*out*/, | |
398 int64_t id, | |
399 int32_t metadataType) = 0; | |
400 | |
401 virtual bool LookupParent(int64_t& parentId /*out*/, | |
402 int64_t resourceId) = 0; | |
403 | |
404 virtual bool LookupResource(int64_t& id /*out*/, | |
405 OrthancPluginResourceType& type /*out*/, | |
406 const char* publicId) = 0; | |
407 | |
408 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/) = 0; | |
409 | |
410 virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/, | |
411 int64_t patientIdToAvoid) = 0; | |
412 | |
413 virtual void SetGlobalProperty(int32_t property, | |
414 const char* value) = 0; | |
415 | |
416 virtual void SetMainDicomTag(int64_t id, | |
417 uint16_t group, | |
418 uint16_t element, | |
419 const char* value) = 0; | |
420 | |
421 virtual void SetIdentifierTag(int64_t id, | |
422 uint16_t group, | |
423 uint16_t element, | |
424 const char* value) = 0; | |
425 | |
426 virtual void SetMetadata(int64_t id, | |
427 int32_t metadataType, | |
428 const char* value) = 0; | |
429 | |
430 virtual void SetProtectedPatient(int64_t internalId, | |
431 bool isProtected) = 0; | |
432 | |
433 virtual void StartTransaction() = 0; | |
434 | |
435 virtual void RollbackTransaction() = 0; | |
436 | |
437 virtual void CommitTransaction() = 0; | |
438 | |
439 virtual uint32_t GetDatabaseVersion() = 0; | |
440 | |
441 /** | |
442 * Upgrade the database to the specified version of the database | |
443 * schema. The upgrade script is allowed to make calls to | |
444 * OrthancPluginReconstructMainDicomTags(). | |
445 **/ | |
446 virtual void UpgradeDatabase(uint32_t targetVersion, | |
447 OrthancPluginStorageArea* storageArea) = 0; | |
448 | |
449 virtual void ClearMainDicomTags(int64_t internalId) = 0; | |
450 }; | |
451 | |
452 | |
453 | |
454 /** | |
455 * @brief Bridge between C and C++ database engines. | |
456 * | |
457 * Class creating the bridge between the C low-level primitives for | |
458 * custom database engines, and the high-level IDatabaseBackend C++ | |
459 * interface. | |
460 * | |
461 * @ingroup Callbacks | |
462 **/ | |
463 class DatabaseBackendAdapter | |
464 { | |
465 private: | |
466 // This class cannot be instantiated | |
467 DatabaseBackendAdapter() | |
468 { | |
469 } | |
470 | |
471 static void LogError(IDatabaseBackend* backend, | |
472 const std::runtime_error& e) | |
473 { | |
474 backend->GetOutput().LogError("Exception in database back-end: " + std::string(e.what())); | |
475 } | |
476 | |
477 | |
478 static OrthancPluginErrorCode AddAttachment(void* payload, | |
479 int64_t id, | |
480 const OrthancPluginAttachment* attachment) | |
481 { | |
482 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
483 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
484 | |
485 try | |
486 { | |
487 backend->AddAttachment(id, *attachment); | |
488 return OrthancPluginErrorCode_Success; | |
489 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
490 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 491 } |
492 | |
493 | |
494 static OrthancPluginErrorCode AttachChild(void* payload, | |
495 int64_t parent, | |
496 int64_t child) | |
497 { | |
498 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
499 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
500 | |
501 try | |
502 { | |
503 backend->AttachChild(parent, child); | |
504 return OrthancPluginErrorCode_Success; | |
505 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
506 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 507 } |
508 | |
509 | |
510 static OrthancPluginErrorCode ClearChanges(void* payload) | |
511 { | |
512 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
513 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
514 | |
515 try | |
516 { | |
517 backend->ClearChanges(); | |
518 return OrthancPluginErrorCode_Success; | |
519 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
520 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 521 } |
522 | |
523 | |
524 static OrthancPluginErrorCode ClearExportedResources(void* payload) | |
525 { | |
526 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
527 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
528 | |
529 try | |
530 { | |
531 backend->ClearExportedResources(); | |
532 return OrthancPluginErrorCode_Success; | |
533 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
534 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 535 } |
536 | |
537 | |
538 static OrthancPluginErrorCode CreateResource(int64_t* id, | |
539 void* payload, | |
540 const char* publicId, | |
541 OrthancPluginResourceType resourceType) | |
542 { | |
543 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
544 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
545 | |
546 try | |
547 { | |
548 *id = backend->CreateResource(publicId, resourceType); | |
549 return OrthancPluginErrorCode_Success; | |
550 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
551 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 552 } |
553 | |
554 | |
555 static OrthancPluginErrorCode DeleteAttachment(void* payload, | |
556 int64_t id, | |
557 int32_t contentType) | |
558 { | |
559 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
560 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
561 | |
562 try | |
563 { | |
564 backend->DeleteAttachment(id, contentType); | |
565 return OrthancPluginErrorCode_Success; | |
566 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
567 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 568 } |
569 | |
570 | |
571 static OrthancPluginErrorCode DeleteMetadata(void* payload, | |
572 int64_t id, | |
573 int32_t metadataType) | |
574 { | |
575 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
576 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
577 | |
578 try | |
579 { | |
580 backend->DeleteMetadata(id, metadataType); | |
581 return OrthancPluginErrorCode_Success; | |
582 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
583 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 584 } |
585 | |
586 | |
587 static OrthancPluginErrorCode DeleteResource(void* payload, | |
588 int64_t id) | |
589 { | |
590 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
591 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
592 | |
593 try | |
594 { | |
595 backend->DeleteResource(id); | |
596 return OrthancPluginErrorCode_Success; | |
597 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
598 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 599 } |
600 | |
601 | |
602 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context, | |
603 void* payload, | |
604 OrthancPluginResourceType resourceType) | |
605 { | |
606 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
607 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
608 | |
609 try | |
610 { | |
611 std::list<int64_t> target; | |
612 backend->GetAllInternalIds(target, resourceType); | |
613 | |
614 for (std::list<int64_t>::const_iterator | |
615 it = target.begin(); it != target.end(); ++it) | |
616 { | |
617 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
618 backend->GetOutput().database_, *it); | |
619 } | |
620 | |
621 return OrthancPluginErrorCode_Success; | |
622 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
623 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 624 } |
625 | |
626 | |
627 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context, | |
628 void* payload, | |
629 OrthancPluginResourceType resourceType) | |
630 { | |
631 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
632 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
633 | |
634 try | |
635 { | |
636 std::list<std::string> ids; | |
637 backend->GetAllPublicIds(ids, resourceType); | |
638 | |
639 for (std::list<std::string>::const_iterator | |
640 it = ids.begin(); it != ids.end(); ++it) | |
641 { | |
642 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
643 backend->GetOutput().database_, | |
644 it->c_str()); | |
645 } | |
646 | |
647 return OrthancPluginErrorCode_Success; | |
648 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
649 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 650 } |
651 | |
652 | |
653 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseContext* context, | |
654 void* payload, | |
655 OrthancPluginResourceType resourceType, | |
656 uint64_t since, | |
657 uint64_t limit) | |
658 { | |
659 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
660 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
661 | |
662 try | |
663 { | |
664 std::list<std::string> ids; | |
665 backend->GetAllPublicIds(ids, resourceType, since, limit); | |
666 | |
667 for (std::list<std::string>::const_iterator | |
668 it = ids.begin(); it != ids.end(); ++it) | |
669 { | |
670 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
671 backend->GetOutput().database_, | |
672 it->c_str()); | |
673 } | |
674 | |
675 return OrthancPluginErrorCode_Success; | |
676 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
677 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 678 } |
679 | |
680 | |
681 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context, | |
682 void* payload, | |
683 int64_t since, | |
684 uint32_t maxResult) | |
685 { | |
686 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
687 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change); | |
688 | |
689 try | |
690 { | |
691 bool done; | |
692 backend->GetChanges(done, since, maxResult); | |
693 | |
694 if (done) | |
695 { | |
696 OrthancPluginDatabaseAnswerChangesDone(backend->GetOutput().context_, | |
697 backend->GetOutput().database_); | |
698 } | |
699 | |
700 return OrthancPluginErrorCode_Success; | |
701 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
702 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 703 } |
704 | |
705 | |
706 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context, | |
707 void* payload, | |
708 int64_t id) | |
709 { | |
710 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
711 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
712 | |
713 try | |
714 { | |
715 std::list<int64_t> target; | |
716 backend->GetChildrenInternalId(target, id); | |
717 | |
718 for (std::list<int64_t>::const_iterator | |
719 it = target.begin(); it != target.end(); ++it) | |
720 { | |
721 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
722 backend->GetOutput().database_, *it); | |
723 } | |
724 | |
725 return OrthancPluginErrorCode_Success; | |
726 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
727 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 728 } |
729 | |
730 | |
731 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context, | |
732 void* payload, | |
733 int64_t id) | |
734 { | |
735 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
736 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
737 | |
738 try | |
739 { | |
740 std::list<std::string> ids; | |
741 backend->GetChildrenPublicId(ids, id); | |
742 | |
743 for (std::list<std::string>::const_iterator | |
744 it = ids.begin(); it != ids.end(); ++it) | |
745 { | |
746 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
747 backend->GetOutput().database_, | |
748 it->c_str()); | |
749 } | |
750 | |
751 return OrthancPluginErrorCode_Success; | |
752 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
753 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 754 } |
755 | |
756 | |
757 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context, | |
758 void* payload, | |
759 int64_t since, | |
760 uint32_t maxResult) | |
761 { | |
762 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
763 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource); | |
764 | |
765 try | |
766 { | |
767 bool done; | |
768 backend->GetExportedResources(done, since, maxResult); | |
769 | |
770 if (done) | |
771 { | |
772 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetOutput().context_, | |
773 backend->GetOutput().database_); | |
774 } | |
775 return OrthancPluginErrorCode_Success; | |
776 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
777 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 778 } |
779 | |
780 | |
781 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context, | |
782 void* payload) | |
783 { | |
784 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
785 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change); | |
786 | |
787 try | |
788 { | |
789 backend->GetLastChange(); | |
790 return OrthancPluginErrorCode_Success; | |
791 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
792 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 793 } |
794 | |
795 | |
796 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context, | |
797 void* payload) | |
798 { | |
799 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
800 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource); | |
801 | |
802 try | |
803 { | |
804 backend->GetLastExportedResource(); | |
805 return OrthancPluginErrorCode_Success; | |
806 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
807 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 808 } |
809 | |
810 | |
811 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context, | |
812 void* payload, | |
813 int64_t id) | |
814 { | |
815 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
816 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_DicomTag); | |
817 | |
818 try | |
819 { | |
820 backend->GetMainDicomTags(id); | |
821 return OrthancPluginErrorCode_Success; | |
822 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
823 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 824 } |
825 | |
826 | |
827 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context, | |
828 void* payload, | |
829 int64_t id) | |
830 { | |
831 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
832 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
833 | |
834 try | |
835 { | |
836 std::string s = backend->GetPublicId(id); | |
837 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
838 backend->GetOutput().database_, | |
839 s.c_str()); | |
840 | |
841 return OrthancPluginErrorCode_Success; | |
842 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
843 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 844 } |
845 | |
846 | |
847 static OrthancPluginErrorCode GetResourceCount(uint64_t* target, | |
848 void* payload, | |
849 OrthancPluginResourceType resourceType) | |
850 { | |
851 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
852 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
853 | |
854 try | |
855 { | |
856 *target = backend->GetResourceCount(resourceType); | |
857 return OrthancPluginErrorCode_Success; | |
858 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
859 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 860 } |
861 | |
862 | |
863 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType, | |
864 void* payload, | |
865 int64_t id) | |
866 { | |
867 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
868 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
869 | |
870 try | |
871 { | |
872 *resourceType = backend->GetResourceType(id); | |
873 return OrthancPluginErrorCode_Success; | |
874 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
875 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 876 } |
877 | |
878 | |
879 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target, | |
880 void* payload) | |
881 { | |
882 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
883 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
884 | |
885 try | |
886 { | |
887 *target = backend->GetTotalCompressedSize(); | |
888 return OrthancPluginErrorCode_Success; | |
889 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
890 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 891 } |
892 | |
893 | |
894 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target, | |
895 void* payload) | |
896 { | |
897 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
898 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
899 | |
900 try | |
901 { | |
902 *target = backend->GetTotalUncompressedSize(); | |
903 return OrthancPluginErrorCode_Success; | |
904 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
905 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 906 } |
907 | |
908 | |
909 static OrthancPluginErrorCode IsExistingResource(int32_t* existing, | |
910 void* payload, | |
911 int64_t id) | |
912 { | |
913 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
914 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
915 | |
916 try | |
917 { | |
918 *existing = backend->IsExistingResource(id); | |
919 return OrthancPluginErrorCode_Success; | |
920 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
921 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 922 } |
923 | |
924 | |
925 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected, | |
926 void* payload, | |
927 int64_t id) | |
928 { | |
929 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
930 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
931 | |
932 try | |
933 { | |
934 *isProtected = backend->IsProtectedPatient(id); | |
935 return OrthancPluginErrorCode_Success; | |
936 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
937 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 938 } |
939 | |
940 | |
941 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context, | |
942 void* payload, | |
943 int64_t id) | |
944 { | |
945 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
946 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
947 | |
948 try | |
949 { | |
950 std::list<int32_t> target; | |
951 backend->ListAvailableMetadata(target, id); | |
952 | |
953 for (std::list<int32_t>::const_iterator | |
954 it = target.begin(); it != target.end(); ++it) | |
955 { | |
956 OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_, | |
957 backend->GetOutput().database_, | |
958 *it); | |
959 } | |
960 | |
961 return OrthancPluginErrorCode_Success; | |
962 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
963 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 964 } |
965 | |
966 | |
967 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context, | |
968 void* payload, | |
969 int64_t id) | |
970 { | |
971 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
972 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
973 | |
974 try | |
975 { | |
976 std::list<int32_t> target; | |
977 backend->ListAvailableAttachments(target, id); | |
978 | |
979 for (std::list<int32_t>::const_iterator | |
980 it = target.begin(); it != target.end(); ++it) | |
981 { | |
982 OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_, | |
983 backend->GetOutput().database_, | |
984 *it); | |
985 } | |
986 | |
987 return OrthancPluginErrorCode_Success; | |
988 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
989 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 990 } |
991 | |
992 | |
993 static OrthancPluginErrorCode LogChange(void* payload, | |
994 const OrthancPluginChange* change) | |
995 { | |
996 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
997 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
998 | |
999 try | |
1000 { | |
1001 backend->LogChange(*change); | |
1002 return OrthancPluginErrorCode_Success; | |
1003 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1004 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1005 } |
1006 | |
1007 | |
1008 static OrthancPluginErrorCode LogExportedResource(void* payload, | |
1009 const OrthancPluginExportedResource* exported) | |
1010 { | |
1011 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1012 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1013 | |
1014 try | |
1015 { | |
1016 backend->LogExportedResource(*exported); | |
1017 return OrthancPluginErrorCode_Success; | |
1018 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1019 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1020 } |
1021 | |
1022 | |
1023 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context, | |
1024 void* payload, | |
1025 int64_t id, | |
1026 int32_t contentType) | |
1027 { | |
1028 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1029 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Attachment); | |
1030 | |
1031 try | |
1032 { | |
1033 backend->LookupAttachment(id, contentType); | |
1034 return OrthancPluginErrorCode_Success; | |
1035 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1036 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1037 } |
1038 | |
1039 | |
1040 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context, | |
1041 void* payload, | |
1042 int32_t property) | |
1043 { | |
1044 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1045 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1046 | |
1047 try | |
1048 { | |
1049 std::string s; | |
1050 if (backend->LookupGlobalProperty(s, property)) | |
1051 { | |
1052 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
1053 backend->GetOutput().database_, | |
1054 s.c_str()); | |
1055 } | |
1056 | |
1057 return OrthancPluginErrorCode_Success; | |
1058 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1059 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1060 } |
1061 | |
1062 | |
1063 static OrthancPluginErrorCode LookupIdentifier3(OrthancPluginDatabaseContext* context, | |
1064 void* payload, | |
1065 OrthancPluginResourceType resourceType, | |
1066 const OrthancPluginDicomTag* tag, | |
1067 OrthancPluginIdentifierConstraint constraint) | |
1068 { | |
1069 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1070 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1071 | |
1072 try | |
1073 { | |
1074 std::list<int64_t> target; | |
1075 backend->LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value); | |
1076 | |
1077 for (std::list<int64_t>::const_iterator | |
1078 it = target.begin(); it != target.end(); ++it) | |
1079 { | |
1080 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1081 backend->GetOutput().database_, *it); | |
1082 } | |
1083 | |
1084 return OrthancPluginErrorCode_Success; | |
1085 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1086 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1087 } |
1088 | |
1089 | |
1090 static OrthancPluginErrorCode LookupIdentifierRange(OrthancPluginDatabaseContext* context, | |
1091 void* payload, | |
1092 OrthancPluginResourceType resourceType, | |
1093 uint16_t group, | |
1094 uint16_t element, | |
1095 const char* start, | |
1096 const char* end) | |
1097 { | |
1098 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1099 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1100 | |
1101 try | |
1102 { | |
1103 std::list<int64_t> target; | |
1104 backend->LookupIdentifierRange(target, resourceType, group, element, start, end); | |
1105 | |
1106 for (std::list<int64_t>::const_iterator | |
1107 it = target.begin(); it != target.end(); ++it) | |
1108 { | |
1109 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1110 backend->GetOutput().database_, *it); | |
1111 } | |
1112 | |
1113 return OrthancPluginErrorCode_Success; | |
1114 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1115 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1116 } |
1117 | |
1118 | |
1119 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context, | |
1120 void* payload, | |
1121 int64_t id, | |
1122 int32_t metadata) | |
1123 { | |
1124 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1125 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1126 | |
1127 try | |
1128 { | |
1129 std::string s; | |
1130 if (backend->LookupMetadata(s, id, metadata)) | |
1131 { | |
1132 OrthancPluginDatabaseAnswerString(backend->GetOutput().context_, | |
1133 backend->GetOutput().database_, s.c_str()); | |
1134 } | |
1135 | |
1136 return OrthancPluginErrorCode_Success; | |
1137 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1138 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1139 } |
1140 | |
1141 | |
1142 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context, | |
1143 void* payload, | |
1144 int64_t id) | |
1145 { | |
1146 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1147 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1148 | |
1149 try | |
1150 { | |
1151 int64_t parent; | |
1152 if (backend->LookupParent(parent, id)) | |
1153 { | |
1154 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1155 backend->GetOutput().database_, parent); | |
1156 } | |
1157 | |
1158 return OrthancPluginErrorCode_Success; | |
1159 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1160 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1161 } |
1162 | |
1163 | |
1164 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context, | |
1165 void* payload, | |
1166 const char* publicId) | |
1167 { | |
1168 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1169 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1170 | |
1171 try | |
1172 { | |
1173 int64_t id; | |
1174 OrthancPluginResourceType type; | |
1175 if (backend->LookupResource(id, type, publicId)) | |
1176 { | |
1177 OrthancPluginDatabaseAnswerResource(backend->GetOutput().context_, | |
1178 backend->GetOutput().database_, | |
1179 id, type); | |
1180 } | |
1181 | |
1182 return OrthancPluginErrorCode_Success; | |
1183 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1184 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1185 } |
1186 | |
1187 | |
1188 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context, | |
1189 void* payload) | |
1190 { | |
1191 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1192 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1193 | |
1194 try | |
1195 { | |
1196 int64_t id; | |
1197 if (backend->SelectPatientToRecycle(id)) | |
1198 { | |
1199 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1200 backend->GetOutput().database_, id); | |
1201 } | |
1202 | |
1203 return OrthancPluginErrorCode_Success; | |
1204 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1205 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1206 } |
1207 | |
1208 | |
1209 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context, | |
1210 void* payload, | |
1211 int64_t patientIdToAvoid) | |
1212 { | |
1213 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1214 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1215 | |
1216 try | |
1217 { | |
1218 int64_t id; | |
1219 if (backend->SelectPatientToRecycle(id, patientIdToAvoid)) | |
1220 { | |
1221 OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_, | |
1222 backend->GetOutput().database_, id); | |
1223 } | |
1224 | |
1225 return OrthancPluginErrorCode_Success; | |
1226 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1227 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1228 } |
1229 | |
1230 | |
1231 static OrthancPluginErrorCode SetGlobalProperty(void* payload, | |
1232 int32_t property, | |
1233 const char* value) | |
1234 { | |
1235 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1236 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1237 | |
1238 try | |
1239 { | |
1240 backend->SetGlobalProperty(property, value); | |
1241 return OrthancPluginErrorCode_Success; | |
1242 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1243 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1244 } |
1245 | |
1246 | |
1247 static OrthancPluginErrorCode SetMainDicomTag(void* payload, | |
1248 int64_t id, | |
1249 const OrthancPluginDicomTag* tag) | |
1250 { | |
1251 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1252 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1253 | |
1254 try | |
1255 { | |
1256 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value); | |
1257 return OrthancPluginErrorCode_Success; | |
1258 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1259 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1260 } |
1261 | |
1262 | |
1263 static OrthancPluginErrorCode SetIdentifierTag(void* payload, | |
1264 int64_t id, | |
1265 const OrthancPluginDicomTag* tag) | |
1266 { | |
1267 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1268 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1269 | |
1270 try | |
1271 { | |
1272 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value); | |
1273 return OrthancPluginErrorCode_Success; | |
1274 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1275 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1276 } |
1277 | |
1278 | |
1279 static OrthancPluginErrorCode SetMetadata(void* payload, | |
1280 int64_t id, | |
1281 int32_t metadata, | |
1282 const char* value) | |
1283 { | |
1284 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1285 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1286 | |
1287 try | |
1288 { | |
1289 backend->SetMetadata(id, metadata, value); | |
1290 return OrthancPluginErrorCode_Success; | |
1291 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1292 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1293 } |
1294 | |
1295 | |
1296 static OrthancPluginErrorCode SetProtectedPatient(void* payload, | |
1297 int64_t id, | |
1298 int32_t isProtected) | |
1299 { | |
1300 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1301 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1302 | |
1303 try | |
1304 { | |
1305 backend->SetProtectedPatient(id, (isProtected != 0)); | |
1306 return OrthancPluginErrorCode_Success; | |
1307 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1308 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1309 } |
1310 | |
1311 | |
1312 static OrthancPluginErrorCode StartTransaction(void* payload) | |
1313 { | |
1314 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1315 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1316 | |
1317 try | |
1318 { | |
1319 backend->StartTransaction(); | |
1320 return OrthancPluginErrorCode_Success; | |
1321 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1322 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1323 } |
1324 | |
1325 | |
1326 static OrthancPluginErrorCode RollbackTransaction(void* payload) | |
1327 { | |
1328 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1329 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1330 | |
1331 try | |
1332 { | |
1333 backend->RollbackTransaction(); | |
1334 return OrthancPluginErrorCode_Success; | |
1335 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1336 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1337 } |
1338 | |
1339 | |
1340 static OrthancPluginErrorCode CommitTransaction(void* payload) | |
1341 { | |
1342 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1343 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1344 | |
1345 try | |
1346 { | |
1347 backend->CommitTransaction(); | |
1348 return OrthancPluginErrorCode_Success; | |
1349 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1350 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1351 } |
1352 | |
1353 | |
1354 static OrthancPluginErrorCode Open(void* payload) | |
1355 { | |
1356 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1357 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1358 | |
1359 try | |
1360 { | |
1361 backend->Open(); | |
1362 return OrthancPluginErrorCode_Success; | |
1363 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1364 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1365 } |
1366 | |
1367 | |
1368 static OrthancPluginErrorCode Close(void* payload) | |
1369 { | |
1370 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1371 backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None); | |
1372 | |
1373 try | |
1374 { | |
1375 backend->Close(); | |
1376 return OrthancPluginErrorCode_Success; | |
1377 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1378 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1379 } |
1380 | |
1381 | |
1382 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version, | |
1383 void* payload) | |
1384 { | |
1385 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1386 | |
1387 try | |
1388 { | |
1389 *version = backend->GetDatabaseVersion(); | |
1390 return OrthancPluginErrorCode_Success; | |
1391 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1392 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1393 } |
1394 | |
1395 | |
1396 static OrthancPluginErrorCode UpgradeDatabase(void* payload, | |
1397 uint32_t targetVersion, | |
1398 OrthancPluginStorageArea* storageArea) | |
1399 { | |
1400 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1401 | |
1402 try | |
1403 { | |
1404 backend->UpgradeDatabase(targetVersion, storageArea); | |
1405 return OrthancPluginErrorCode_Success; | |
1406 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1407 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1408 } |
1409 | |
1410 | |
1411 static OrthancPluginErrorCode ClearMainDicomTags(void* payload, | |
1412 int64_t internalId) | |
1413 { | |
1414 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | |
1415 | |
1416 try | |
1417 { | |
1418 backend->ClearMainDicomTags(internalId); | |
1419 return OrthancPluginErrorCode_Success; | |
1420 } | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1421 ORTHANC_PLUGINS_DATABASE_CATCH |
0 | 1422 } |
1423 | |
1424 | |
1425 public: | |
1426 /** | |
1427 * Register a custom database back-end written in C++. | |
1428 * | |
1429 * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). | |
1430 * @param backend Your custom database engine. | |
1431 **/ | |
1432 | |
1433 static void Register(OrthancPluginContext* context, | |
1434 IDatabaseBackend& backend) | |
1435 { | |
1436 OrthancPluginDatabaseBackend params; | |
1437 memset(¶ms, 0, sizeof(params)); | |
1438 | |
1439 OrthancPluginDatabaseExtensions extensions; | |
1440 memset(&extensions, 0, sizeof(extensions)); | |
1441 | |
1442 params.addAttachment = AddAttachment; | |
1443 params.attachChild = AttachChild; | |
1444 params.clearChanges = ClearChanges; | |
1445 params.clearExportedResources = ClearExportedResources; | |
1446 params.createResource = CreateResource; | |
1447 params.deleteAttachment = DeleteAttachment; | |
1448 params.deleteMetadata = DeleteMetadata; | |
1449 params.deleteResource = DeleteResource; | |
1450 params.getAllPublicIds = GetAllPublicIds; | |
1451 params.getChanges = GetChanges; | |
1452 params.getChildrenInternalId = GetChildrenInternalId; | |
1453 params.getChildrenPublicId = GetChildrenPublicId; | |
1454 params.getExportedResources = GetExportedResources; | |
1455 params.getLastChange = GetLastChange; | |
1456 params.getLastExportedResource = GetLastExportedResource; | |
1457 params.getMainDicomTags = GetMainDicomTags; | |
1458 params.getPublicId = GetPublicId; | |
1459 params.getResourceCount = GetResourceCount; | |
1460 params.getResourceType = GetResourceType; | |
1461 params.getTotalCompressedSize = GetTotalCompressedSize; | |
1462 params.getTotalUncompressedSize = GetTotalUncompressedSize; | |
1463 params.isExistingResource = IsExistingResource; | |
1464 params.isProtectedPatient = IsProtectedPatient; | |
1465 params.listAvailableMetadata = ListAvailableMetadata; | |
1466 params.listAvailableAttachments = ListAvailableAttachments; | |
1467 params.logChange = LogChange; | |
1468 params.logExportedResource = LogExportedResource; | |
1469 params.lookupAttachment = LookupAttachment; | |
1470 params.lookupGlobalProperty = LookupGlobalProperty; | |
1471 params.lookupIdentifier = NULL; // Unused starting with Orthanc 0.9.5 (db v6) | |
1472 params.lookupIdentifier2 = NULL; // Unused starting with Orthanc 0.9.5 (db v6) | |
1473 params.lookupMetadata = LookupMetadata; | |
1474 params.lookupParent = LookupParent; | |
1475 params.lookupResource = LookupResource; | |
1476 params.selectPatientToRecycle = SelectPatientToRecycle; | |
1477 params.selectPatientToRecycle2 = SelectPatientToRecycle2; | |
1478 params.setGlobalProperty = SetGlobalProperty; | |
1479 params.setMainDicomTag = SetMainDicomTag; | |
1480 params.setIdentifierTag = SetIdentifierTag; | |
1481 params.setMetadata = SetMetadata; | |
1482 params.setProtectedPatient = SetProtectedPatient; | |
1483 params.startTransaction = StartTransaction; | |
1484 params.rollbackTransaction = RollbackTransaction; | |
1485 params.commitTransaction = CommitTransaction; | |
1486 params.open = Open; | |
1487 params.close = Close; | |
1488 | |
1489 extensions.getAllPublicIdsWithLimit = GetAllPublicIdsWithLimit; | |
1490 extensions.getDatabaseVersion = GetDatabaseVersion; | |
1491 extensions.upgradeDatabase = UpgradeDatabase; | |
1492 extensions.clearMainDicomTags = ClearMainDicomTags; | |
1493 extensions.getAllInternalIds = GetAllInternalIds; // New in Orthanc 0.9.5 (db v6) | |
1494 extensions.lookupIdentifier3 = LookupIdentifier3; // New in Orthanc 0.9.5 (db v6) | |
1495 | |
1496 bool performanceWarning = true; | |
1497 | |
1498 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in Orthanc 1.3.1 | |
1499 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 4, 0) | |
1500 extensions.lookupIdentifierRange = LookupIdentifierRange; // New in Orthanc 1.4.0 | |
1501 performanceWarning = false; | |
1502 # endif | |
1503 #endif | |
1504 | |
1505 if (performanceWarning) | |
1506 { | |
24
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1507 char info[1024]; |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1508 sprintf(info, |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1509 "Performance warning: The database index plugin was compiled " |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1510 "against an old version of the Orthanc SDK (%d.%d.%d): " |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1511 "Consider upgrading to version 1.4.0 of the Orthanc SDK", |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1512 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER, |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1513 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER, |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1514 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER); |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1515 |
17f849b2af34
sharing plugin initialization code
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
1516 OrthancPluginLogWarning(context, info); |
0 | 1517 } |
1518 | |
1
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1519 OrthancPluginDatabaseContext* database = |
d17b2631bb67
starting StorageBackend
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
1520 OrthancPluginRegisterDatabaseBackendV2(context, ¶ms, &extensions, &backend); |
0 | 1521 if (!context) |
1522 { | |
1523 throw std::runtime_error("Unable to register the database backend"); | |
1524 } | |
1525 | |
1526 backend.RegisterOutput(new DatabaseBackendOutput(context, database)); | |
1527 } | |
1528 }; | |
1529 } |