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