Mercurial > hg > orthanc-databases
comparison Framework/Plugins/DatabaseBackendAdapterV2.cpp @ 224:61c309e06797
added internal class DatabaseBackendAdapterV2::Adapter
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 01 Apr 2021 16:09:59 +0200 |
parents | c8e06b41feec |
children | 94c9908e6aca |
comparison
equal
deleted
inserted
replaced
223:af049cd66661 | 224:61c309e06797 |
---|---|
23 #include "DatabaseBackendAdapterV2.h" | 23 #include "DatabaseBackendAdapterV2.h" |
24 #include "GlobalProperties.h" | 24 #include "GlobalProperties.h" |
25 | 25 |
26 #include <OrthancException.h> | 26 #include <OrthancException.h> |
27 | 27 |
28 #include <boost/thread/mutex.hpp> | |
29 #include <list> | |
28 #include <stdexcept> | 30 #include <stdexcept> |
29 #include <list> | |
30 #include <string> | 31 #include <string> |
31 | 32 |
32 | 33 |
33 #define ORTHANC_PLUGINS_DATABASE_CATCH \ | 34 #define ORTHANC_PLUGINS_DATABASE_CATCH \ |
34 catch (::Orthanc::OrthancException& e) \ | 35 catch (::Orthanc::OrthancException& e) \ |
35 { \ | 36 { \ |
36 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \ | 37 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \ |
37 } \ | 38 } \ |
38 catch (::std::runtime_error& e) \ | 39 catch (::std::runtime_error& e) \ |
39 { \ | 40 { \ |
40 LogError(backend, e); \ | 41 LogError(adapter->GetBackend(), e); \ |
41 return OrthancPluginErrorCode_DatabasePlugin; \ | 42 return OrthancPluginErrorCode_DatabasePlugin; \ |
42 } \ | 43 } \ |
43 catch (...) \ | 44 catch (...) \ |
44 { \ | 45 { \ |
45 OrthancPluginLogError(backend->GetContext(), "Native exception"); \ | 46 OrthancPluginLogError(adapter->GetBackend().GetContext(), "Native exception"); \ |
46 return OrthancPluginErrorCode_DatabasePlugin; \ | 47 return OrthancPluginErrorCode_DatabasePlugin; \ |
47 } | 48 } |
48 | 49 |
49 | 50 |
50 namespace OrthancDatabases | 51 namespace OrthancDatabases |
51 { | 52 { |
53 class DatabaseBackendAdapterV2::Adapter : public boost::noncopyable | |
54 { | |
55 private: | |
56 std::unique_ptr<IDatabaseBackend> backend_; | |
57 boost::mutex databaseMutex_; | |
58 std::unique_ptr<DatabaseManager> database_; | |
59 | |
60 public: | |
61 Adapter(IDatabaseBackend* backend) : | |
62 backend_(backend) | |
63 { | |
64 if (backend == NULL) | |
65 { | |
66 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | |
67 } | |
68 } | |
69 | |
70 IDatabaseBackend& GetBackend() const | |
71 { | |
72 return *backend_; | |
73 } | |
74 | |
75 void OpenConnection() | |
76 { | |
77 boost::mutex::scoped_lock lock(databaseMutex_); | |
78 | |
79 if (database_.get() == NULL) | |
80 { | |
81 database_.reset(new DatabaseManager(backend_->CreateDatabaseFactory())); | |
82 database_->Open(); | |
83 } | |
84 else | |
85 { | |
86 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
87 } | |
88 } | |
89 | |
90 void CloseConnection() | |
91 { | |
92 boost::mutex::scoped_lock lock(databaseMutex_); | |
93 | |
94 if (database_.get() == NULL) | |
95 { | |
96 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
97 } | |
98 else | |
99 { | |
100 database_->Close(); | |
101 database_.reset(NULL); | |
102 } | |
103 } | |
104 | |
105 class DatabaseAccessor : public boost::noncopyable | |
106 { | |
107 private: | |
108 boost::mutex::scoped_lock lock_; | |
109 DatabaseManager* database_; | |
110 | |
111 public: | |
112 DatabaseAccessor(Adapter& adapter) : | |
113 lock_(adapter.databaseMutex_), | |
114 database_(adapter.database_.get()) | |
115 { | |
116 if (database_ == NULL) | |
117 { | |
118 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
119 } | |
120 } | |
121 | |
122 DatabaseManager& GetDatabase() const | |
123 { | |
124 assert(database_ != NULL); | |
125 return *database_; | |
126 } | |
127 }; | |
128 }; | |
129 | |
130 | |
52 class DatabaseBackendAdapterV2::Output : public IDatabaseBackendOutput | 131 class DatabaseBackendAdapterV2::Output : public IDatabaseBackendOutput |
53 { | 132 { |
54 public: | 133 public: |
55 enum AllowedAnswers | 134 enum AllowedAnswers |
56 { | 135 { |
254 } | 333 } |
255 #endif | 334 #endif |
256 }; | 335 }; |
257 | 336 |
258 | 337 |
259 static void LogError(IDatabaseBackend* backend, | 338 static void LogError(IDatabaseBackend& backend, |
260 const std::runtime_error& e) | 339 const std::runtime_error& e) |
261 { | 340 { |
262 const std::string message = "Exception in database back-end: " + std::string(e.what()); | 341 const std::string message = "Exception in database back-end: " + std::string(e.what()); |
263 OrthancPluginLogError(backend->GetContext(), message.c_str()); | 342 OrthancPluginLogError(backend.GetContext(), message.c_str()); |
264 } | 343 } |
265 | 344 |
266 | 345 |
267 static OrthancPluginErrorCode AddAttachment(void* payload, | 346 static OrthancPluginErrorCode AddAttachment(void* payload, |
268 int64_t id, | 347 int64_t id, |
269 const OrthancPluginAttachment* attachment) | 348 const OrthancPluginAttachment* attachment) |
270 { | 349 { |
271 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 350 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
272 | 351 |
273 try | 352 try |
274 { | 353 { |
275 backend->AddAttachment(id, *attachment); | 354 //DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter); // TODO |
355 | |
356 adapter->GetBackend().AddAttachment(id, *attachment); | |
276 return OrthancPluginErrorCode_Success; | 357 return OrthancPluginErrorCode_Success; |
277 } | 358 } |
278 ORTHANC_PLUGINS_DATABASE_CATCH; | 359 ORTHANC_PLUGINS_DATABASE_CATCH; |
279 } | 360 } |
280 | 361 |
281 | 362 |
282 static OrthancPluginErrorCode AttachChild(void* payload, | 363 static OrthancPluginErrorCode AttachChild(void* payload, |
283 int64_t parent, | 364 int64_t parent, |
284 int64_t child) | 365 int64_t child) |
285 { | 366 { |
286 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 367 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
287 | 368 |
288 try | 369 try |
289 { | 370 { |
290 backend->AttachChild(parent, child); | 371 adapter->GetBackend().AttachChild(parent, child); |
291 return OrthancPluginErrorCode_Success; | 372 return OrthancPluginErrorCode_Success; |
292 } | 373 } |
293 ORTHANC_PLUGINS_DATABASE_CATCH; | 374 ORTHANC_PLUGINS_DATABASE_CATCH; |
294 } | 375 } |
295 | 376 |
296 | 377 |
297 static OrthancPluginErrorCode ClearChanges(void* payload) | 378 static OrthancPluginErrorCode ClearChanges(void* payload) |
298 { | 379 { |
299 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 380 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
300 | 381 |
301 try | 382 try |
302 { | 383 { |
303 backend->ClearChanges(); | 384 adapter->GetBackend().ClearChanges(); |
304 return OrthancPluginErrorCode_Success; | 385 return OrthancPluginErrorCode_Success; |
305 } | 386 } |
306 ORTHANC_PLUGINS_DATABASE_CATCH; | 387 ORTHANC_PLUGINS_DATABASE_CATCH; |
307 } | 388 } |
308 | 389 |
309 | 390 |
310 static OrthancPluginErrorCode ClearExportedResources(void* payload) | 391 static OrthancPluginErrorCode ClearExportedResources(void* payload) |
311 { | 392 { |
312 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 393 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
313 | 394 |
314 try | 395 try |
315 { | 396 { |
316 backend->ClearExportedResources(); | 397 adapter->GetBackend().ClearExportedResources(); |
317 return OrthancPluginErrorCode_Success; | 398 return OrthancPluginErrorCode_Success; |
318 } | 399 } |
319 ORTHANC_PLUGINS_DATABASE_CATCH; | 400 ORTHANC_PLUGINS_DATABASE_CATCH; |
320 } | 401 } |
321 | 402 |
323 static OrthancPluginErrorCode CreateResource(int64_t* id, | 404 static OrthancPluginErrorCode CreateResource(int64_t* id, |
324 void* payload, | 405 void* payload, |
325 const char* publicId, | 406 const char* publicId, |
326 OrthancPluginResourceType resourceType) | 407 OrthancPluginResourceType resourceType) |
327 { | 408 { |
328 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 409 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
329 | 410 |
330 try | 411 try |
331 { | 412 { |
332 *id = backend->CreateResource(publicId, resourceType); | 413 *id = adapter->GetBackend().CreateResource(publicId, resourceType); |
333 return OrthancPluginErrorCode_Success; | 414 return OrthancPluginErrorCode_Success; |
334 } | 415 } |
335 ORTHANC_PLUGINS_DATABASE_CATCH; | 416 ORTHANC_PLUGINS_DATABASE_CATCH; |
336 } | 417 } |
337 | 418 |
338 | 419 |
339 static OrthancPluginErrorCode DeleteAttachment(void* payload, | 420 static OrthancPluginErrorCode DeleteAttachment(void* payload, |
340 int64_t id, | 421 int64_t id, |
341 int32_t contentType) | 422 int32_t contentType) |
342 { | 423 { |
343 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 424 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
344 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 425 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
345 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 426 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
346 | 427 |
347 try | 428 try |
348 { | 429 { |
349 backend->DeleteAttachment(*output, id, contentType); | 430 adapter->GetBackend().DeleteAttachment(*output, id, contentType); |
350 return OrthancPluginErrorCode_Success; | 431 return OrthancPluginErrorCode_Success; |
351 } | 432 } |
352 ORTHANC_PLUGINS_DATABASE_CATCH; | 433 ORTHANC_PLUGINS_DATABASE_CATCH; |
353 } | 434 } |
354 | 435 |
355 | 436 |
356 static OrthancPluginErrorCode DeleteMetadata(void* payload, | 437 static OrthancPluginErrorCode DeleteMetadata(void* payload, |
357 int64_t id, | 438 int64_t id, |
358 int32_t metadataType) | 439 int32_t metadataType) |
359 { | 440 { |
360 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 441 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
361 | 442 |
362 try | 443 try |
363 { | 444 { |
364 backend->DeleteMetadata(id, metadataType); | 445 adapter->GetBackend().DeleteMetadata(id, metadataType); |
365 return OrthancPluginErrorCode_Success; | 446 return OrthancPluginErrorCode_Success; |
366 } | 447 } |
367 ORTHANC_PLUGINS_DATABASE_CATCH; | 448 ORTHANC_PLUGINS_DATABASE_CATCH; |
368 } | 449 } |
369 | 450 |
370 | 451 |
371 static OrthancPluginErrorCode DeleteResource(void* payload, | 452 static OrthancPluginErrorCode DeleteResource(void* payload, |
372 int64_t id) | 453 int64_t id) |
373 { | 454 { |
374 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 455 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
375 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 456 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
376 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 457 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
377 | 458 |
378 try | 459 try |
379 { | 460 { |
380 backend->DeleteResource(*output, id); | 461 adapter->GetBackend().DeleteResource(*output, id); |
381 return OrthancPluginErrorCode_Success; | 462 return OrthancPluginErrorCode_Success; |
382 } | 463 } |
383 ORTHANC_PLUGINS_DATABASE_CATCH; | 464 ORTHANC_PLUGINS_DATABASE_CATCH; |
384 } | 465 } |
385 | 466 |
386 | 467 |
387 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context, | 468 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context, |
388 void* payload, | 469 void* payload, |
389 OrthancPluginResourceType resourceType) | 470 OrthancPluginResourceType resourceType) |
390 { | 471 { |
391 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 472 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
392 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 473 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
393 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 474 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
394 | 475 |
395 try | 476 try |
396 { | 477 { |
397 std::list<int64_t> target; | 478 std::list<int64_t> target; |
398 backend->GetAllInternalIds(target, resourceType); | 479 adapter->GetBackend().GetAllInternalIds(target, resourceType); |
399 | 480 |
400 for (std::list<int64_t>::const_iterator | 481 for (std::list<int64_t>::const_iterator |
401 it = target.begin(); it != target.end(); ++it) | 482 it = target.begin(); it != target.end(); ++it) |
402 { | 483 { |
403 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 484 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), |
404 output->GetDatabase(), *it); | 485 output->GetDatabase(), *it); |
405 } | 486 } |
406 | 487 |
407 return OrthancPluginErrorCode_Success; | 488 return OrthancPluginErrorCode_Success; |
408 } | 489 } |
412 | 493 |
413 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context, | 494 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context, |
414 void* payload, | 495 void* payload, |
415 OrthancPluginResourceType resourceType) | 496 OrthancPluginResourceType resourceType) |
416 { | 497 { |
417 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 498 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
418 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 499 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
419 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 500 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
420 | 501 |
421 try | 502 try |
422 { | 503 { |
423 std::list<std::string> ids; | 504 std::list<std::string> ids; |
424 backend->GetAllPublicIds(ids, resourceType); | 505 adapter->GetBackend().GetAllPublicIds(ids, resourceType); |
425 | 506 |
426 for (std::list<std::string>::const_iterator | 507 for (std::list<std::string>::const_iterator |
427 it = ids.begin(); it != ids.end(); ++it) | 508 it = ids.begin(); it != ids.end(); ++it) |
428 { | 509 { |
429 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 510 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), |
430 output->GetDatabase(), | 511 output->GetDatabase(), |
431 it->c_str()); | 512 it->c_str()); |
432 } | 513 } |
433 | 514 |
434 return OrthancPluginErrorCode_Success; | 515 return OrthancPluginErrorCode_Success; |
441 void* payload, | 522 void* payload, |
442 OrthancPluginResourceType resourceType, | 523 OrthancPluginResourceType resourceType, |
443 uint64_t since, | 524 uint64_t since, |
444 uint64_t limit) | 525 uint64_t limit) |
445 { | 526 { |
446 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 527 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
447 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 528 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
448 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 529 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
449 | 530 |
450 try | 531 try |
451 { | 532 { |
452 std::list<std::string> ids; | 533 std::list<std::string> ids; |
453 backend->GetAllPublicIds(ids, resourceType, since, limit); | 534 adapter->GetBackend().GetAllPublicIds(ids, resourceType, since, limit); |
454 | 535 |
455 for (std::list<std::string>::const_iterator | 536 for (std::list<std::string>::const_iterator |
456 it = ids.begin(); it != ids.end(); ++it) | 537 it = ids.begin(); it != ids.end(); ++it) |
457 { | 538 { |
458 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 539 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), |
459 output->GetDatabase(), | 540 output->GetDatabase(), |
460 it->c_str()); | 541 it->c_str()); |
461 } | 542 } |
462 | 543 |
463 return OrthancPluginErrorCode_Success; | 544 return OrthancPluginErrorCode_Success; |
469 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context, | 550 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context, |
470 void* payload, | 551 void* payload, |
471 int64_t since, | 552 int64_t since, |
472 uint32_t maxResult) | 553 uint32_t maxResult) |
473 { | 554 { |
474 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 555 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
475 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 556 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
476 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change); | 557 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change); |
477 | 558 |
478 try | 559 try |
479 { | 560 { |
480 bool done; | 561 bool done; |
481 backend->GetChanges(*output, done, since, maxResult); | 562 adapter->GetBackend().GetChanges(*output, done, since, maxResult); |
482 | 563 |
483 if (done) | 564 if (done) |
484 { | 565 { |
485 OrthancPluginDatabaseAnswerChangesDone(backend->GetContext(), | 566 OrthancPluginDatabaseAnswerChangesDone(adapter->GetBackend().GetContext(), |
486 output->GetDatabase()); | 567 output->GetDatabase()); |
487 } | 568 } |
488 | 569 |
489 return OrthancPluginErrorCode_Success; | 570 return OrthancPluginErrorCode_Success; |
490 } | 571 } |
494 | 575 |
495 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context, | 576 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context, |
496 void* payload, | 577 void* payload, |
497 int64_t id) | 578 int64_t id) |
498 { | 579 { |
499 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 580 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
500 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 581 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
501 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 582 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
502 | 583 |
503 try | 584 try |
504 { | 585 { |
505 std::list<int64_t> target; | 586 std::list<int64_t> target; |
506 backend->GetChildrenInternalId(target, id); | 587 adapter->GetBackend().GetChildrenInternalId(target, id); |
507 | 588 |
508 for (std::list<int64_t>::const_iterator | 589 for (std::list<int64_t>::const_iterator |
509 it = target.begin(); it != target.end(); ++it) | 590 it = target.begin(); it != target.end(); ++it) |
510 { | 591 { |
511 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 592 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), |
512 output->GetDatabase(), *it); | 593 output->GetDatabase(), *it); |
513 } | 594 } |
514 | 595 |
515 return OrthancPluginErrorCode_Success; | 596 return OrthancPluginErrorCode_Success; |
516 } | 597 } |
520 | 601 |
521 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context, | 602 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context, |
522 void* payload, | 603 void* payload, |
523 int64_t id) | 604 int64_t id) |
524 { | 605 { |
525 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 606 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
526 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 607 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
527 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 608 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
528 | 609 |
529 try | 610 try |
530 { | 611 { |
531 std::list<std::string> ids; | 612 std::list<std::string> ids; |
532 backend->GetChildrenPublicId(ids, id); | 613 adapter->GetBackend().GetChildrenPublicId(ids, id); |
533 | 614 |
534 for (std::list<std::string>::const_iterator | 615 for (std::list<std::string>::const_iterator |
535 it = ids.begin(); it != ids.end(); ++it) | 616 it = ids.begin(); it != ids.end(); ++it) |
536 { | 617 { |
537 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 618 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), |
538 output->GetDatabase(), | 619 output->GetDatabase(), |
539 it->c_str()); | 620 it->c_str()); |
540 } | 621 } |
541 | 622 |
542 return OrthancPluginErrorCode_Success; | 623 return OrthancPluginErrorCode_Success; |
548 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context, | 629 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context, |
549 void* payload, | 630 void* payload, |
550 int64_t since, | 631 int64_t since, |
551 uint32_t maxResult) | 632 uint32_t maxResult) |
552 { | 633 { |
553 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 634 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
554 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 635 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
555 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource); | 636 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource); |
556 | 637 |
557 try | 638 try |
558 { | 639 { |
559 bool done; | 640 bool done; |
560 backend->GetExportedResources(*output, done, since, maxResult); | 641 adapter->GetBackend().GetExportedResources(*output, done, since, maxResult); |
561 | 642 |
562 if (done) | 643 if (done) |
563 { | 644 { |
564 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetContext(), | 645 OrthancPluginDatabaseAnswerExportedResourcesDone(adapter->GetBackend().GetContext(), |
565 output->GetDatabase()); | 646 output->GetDatabase()); |
566 } | 647 } |
567 return OrthancPluginErrorCode_Success; | 648 return OrthancPluginErrorCode_Success; |
568 } | 649 } |
569 ORTHANC_PLUGINS_DATABASE_CATCH; | 650 ORTHANC_PLUGINS_DATABASE_CATCH; |
571 | 652 |
572 | 653 |
573 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context, | 654 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context, |
574 void* payload) | 655 void* payload) |
575 { | 656 { |
576 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 657 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
577 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 658 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
578 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change); | 659 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change); |
579 | 660 |
580 try | 661 try |
581 { | 662 { |
582 backend->GetLastChange(*output); | 663 adapter->GetBackend().GetLastChange(*output); |
583 return OrthancPluginErrorCode_Success; | 664 return OrthancPluginErrorCode_Success; |
584 } | 665 } |
585 ORTHANC_PLUGINS_DATABASE_CATCH; | 666 ORTHANC_PLUGINS_DATABASE_CATCH; |
586 } | 667 } |
587 | 668 |
588 | 669 |
589 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context, | 670 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context, |
590 void* payload) | 671 void* payload) |
591 { | 672 { |
592 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 673 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
593 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 674 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
594 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource); | 675 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource); |
595 | 676 |
596 try | 677 try |
597 { | 678 { |
598 backend->GetLastExportedResource(*output); | 679 adapter->GetBackend().GetLastExportedResource(*output); |
599 return OrthancPluginErrorCode_Success; | 680 return OrthancPluginErrorCode_Success; |
600 } | 681 } |
601 ORTHANC_PLUGINS_DATABASE_CATCH; | 682 ORTHANC_PLUGINS_DATABASE_CATCH; |
602 } | 683 } |
603 | 684 |
604 | 685 |
605 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context, | 686 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context, |
606 void* payload, | 687 void* payload, |
607 int64_t id) | 688 int64_t id) |
608 { | 689 { |
609 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 690 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
610 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 691 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
611 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_DicomTag); | 692 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_DicomTag); |
612 | 693 |
613 try | 694 try |
614 { | 695 { |
615 backend->GetMainDicomTags(*output, id); | 696 adapter->GetBackend().GetMainDicomTags(*output, id); |
616 return OrthancPluginErrorCode_Success; | 697 return OrthancPluginErrorCode_Success; |
617 } | 698 } |
618 ORTHANC_PLUGINS_DATABASE_CATCH; | 699 ORTHANC_PLUGINS_DATABASE_CATCH; |
619 } | 700 } |
620 | 701 |
621 | 702 |
622 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context, | 703 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context, |
623 void* payload, | 704 void* payload, |
624 int64_t id) | 705 int64_t id) |
625 { | 706 { |
626 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 707 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
627 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 708 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
628 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 709 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
629 | 710 |
630 try | 711 try |
631 { | 712 { |
632 std::string s = backend->GetPublicId(id); | 713 std::string s = adapter->GetBackend().GetPublicId(id); |
633 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 714 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), |
634 output->GetDatabase(), | 715 output->GetDatabase(), |
635 s.c_str()); | 716 s.c_str()); |
636 | 717 |
637 return OrthancPluginErrorCode_Success; | 718 return OrthancPluginErrorCode_Success; |
638 } | 719 } |
642 | 723 |
643 static OrthancPluginErrorCode GetResourceCount(uint64_t* target, | 724 static OrthancPluginErrorCode GetResourceCount(uint64_t* target, |
644 void* payload, | 725 void* payload, |
645 OrthancPluginResourceType resourceType) | 726 OrthancPluginResourceType resourceType) |
646 { | 727 { |
647 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 728 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
648 | 729 |
649 try | 730 try |
650 { | 731 { |
651 *target = backend->GetResourcesCount(resourceType); | 732 *target = adapter->GetBackend().GetResourcesCount(resourceType); |
652 return OrthancPluginErrorCode_Success; | 733 return OrthancPluginErrorCode_Success; |
653 } | 734 } |
654 ORTHANC_PLUGINS_DATABASE_CATCH; | 735 ORTHANC_PLUGINS_DATABASE_CATCH; |
655 } | 736 } |
656 | 737 |
657 | 738 |
658 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType, | 739 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType, |
659 void* payload, | 740 void* payload, |
660 int64_t id) | 741 int64_t id) |
661 { | 742 { |
662 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 743 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
663 | 744 |
664 try | 745 try |
665 { | 746 { |
666 *resourceType = backend->GetResourceType(id); | 747 *resourceType = adapter->GetBackend().GetResourceType(id); |
667 return OrthancPluginErrorCode_Success; | 748 return OrthancPluginErrorCode_Success; |
668 } | 749 } |
669 ORTHANC_PLUGINS_DATABASE_CATCH; | 750 ORTHANC_PLUGINS_DATABASE_CATCH; |
670 } | 751 } |
671 | 752 |
672 | 753 |
673 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target, | 754 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target, |
674 void* payload) | 755 void* payload) |
675 { | 756 { |
676 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 757 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
677 | 758 |
678 try | 759 try |
679 { | 760 { |
680 *target = backend->GetTotalCompressedSize(); | 761 *target = adapter->GetBackend().GetTotalCompressedSize(); |
681 return OrthancPluginErrorCode_Success; | 762 return OrthancPluginErrorCode_Success; |
682 } | 763 } |
683 ORTHANC_PLUGINS_DATABASE_CATCH; | 764 ORTHANC_PLUGINS_DATABASE_CATCH; |
684 } | 765 } |
685 | 766 |
686 | 767 |
687 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target, | 768 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target, |
688 void* payload) | 769 void* payload) |
689 { | 770 { |
690 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 771 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
691 | 772 |
692 try | 773 try |
693 { | 774 { |
694 *target = backend->GetTotalUncompressedSize(); | 775 *target = adapter->GetBackend().GetTotalUncompressedSize(); |
695 return OrthancPluginErrorCode_Success; | 776 return OrthancPluginErrorCode_Success; |
696 } | 777 } |
697 ORTHANC_PLUGINS_DATABASE_CATCH; | 778 ORTHANC_PLUGINS_DATABASE_CATCH; |
698 } | 779 } |
699 | 780 |
700 | 781 |
701 static OrthancPluginErrorCode IsExistingResource(int32_t* existing, | 782 static OrthancPluginErrorCode IsExistingResource(int32_t* existing, |
702 void* payload, | 783 void* payload, |
703 int64_t id) | 784 int64_t id) |
704 { | 785 { |
705 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 786 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
706 | 787 |
707 try | 788 try |
708 { | 789 { |
709 *existing = backend->IsExistingResource(id); | 790 *existing = adapter->GetBackend().IsExistingResource(id); |
710 return OrthancPluginErrorCode_Success; | 791 return OrthancPluginErrorCode_Success; |
711 } | 792 } |
712 ORTHANC_PLUGINS_DATABASE_CATCH; | 793 ORTHANC_PLUGINS_DATABASE_CATCH; |
713 } | 794 } |
714 | 795 |
715 | 796 |
716 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected, | 797 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected, |
717 void* payload, | 798 void* payload, |
718 int64_t id) | 799 int64_t id) |
719 { | 800 { |
720 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 801 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
721 | 802 |
722 try | 803 try |
723 { | 804 { |
724 *isProtected = backend->IsProtectedPatient(id); | 805 *isProtected = adapter->GetBackend().IsProtectedPatient(id); |
725 return OrthancPluginErrorCode_Success; | 806 return OrthancPluginErrorCode_Success; |
726 } | 807 } |
727 ORTHANC_PLUGINS_DATABASE_CATCH; | 808 ORTHANC_PLUGINS_DATABASE_CATCH; |
728 } | 809 } |
729 | 810 |
730 | 811 |
731 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context, | 812 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context, |
732 void* payload, | 813 void* payload, |
733 int64_t id) | 814 int64_t id) |
734 { | 815 { |
735 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 816 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
736 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 817 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
737 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 818 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
738 | 819 |
739 try | 820 try |
740 { | 821 { |
741 std::list<int32_t> target; | 822 std::list<int32_t> target; |
742 backend->ListAvailableMetadata(target, id); | 823 adapter->GetBackend().ListAvailableMetadata(target, id); |
743 | 824 |
744 for (std::list<int32_t>::const_iterator | 825 for (std::list<int32_t>::const_iterator |
745 it = target.begin(); it != target.end(); ++it) | 826 it = target.begin(); it != target.end(); ++it) |
746 { | 827 { |
747 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), | 828 OrthancPluginDatabaseAnswerInt32(adapter->GetBackend().GetContext(), |
748 output->GetDatabase(), | 829 output->GetDatabase(), |
749 *it); | 830 *it); |
750 } | 831 } |
751 | 832 |
752 return OrthancPluginErrorCode_Success; | 833 return OrthancPluginErrorCode_Success; |
757 | 838 |
758 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context, | 839 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context, |
759 void* payload, | 840 void* payload, |
760 int64_t id) | 841 int64_t id) |
761 { | 842 { |
762 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 843 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
763 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 844 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
764 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 845 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
765 | 846 |
766 try | 847 try |
767 { | 848 { |
768 std::list<int32_t> target; | 849 std::list<int32_t> target; |
769 backend->ListAvailableAttachments(target, id); | 850 adapter->GetBackend().ListAvailableAttachments(target, id); |
770 | 851 |
771 for (std::list<int32_t>::const_iterator | 852 for (std::list<int32_t>::const_iterator |
772 it = target.begin(); it != target.end(); ++it) | 853 it = target.begin(); it != target.end(); ++it) |
773 { | 854 { |
774 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), | 855 OrthancPluginDatabaseAnswerInt32(adapter->GetBackend().GetContext(), |
775 output->GetDatabase(), | 856 output->GetDatabase(), |
776 *it); | 857 *it); |
777 } | 858 } |
778 | 859 |
779 return OrthancPluginErrorCode_Success; | 860 return OrthancPluginErrorCode_Success; |
783 | 864 |
784 | 865 |
785 static OrthancPluginErrorCode LogChange(void* payload, | 866 static OrthancPluginErrorCode LogChange(void* payload, |
786 const OrthancPluginChange* change) | 867 const OrthancPluginChange* change) |
787 { | 868 { |
788 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 869 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
789 | 870 |
790 try | 871 try |
791 { | 872 { |
792 int64_t id; | 873 int64_t id; |
793 OrthancPluginResourceType type; | 874 OrthancPluginResourceType type; |
794 if (!backend->LookupResource(id, type, change->publicId) || | 875 if (!adapter->GetBackend().LookupResource(id, type, change->publicId) || |
795 type != change->resourceType) | 876 type != change->resourceType) |
796 { | 877 { |
797 throw Orthanc::OrthancException(Orthanc::ErrorCode_Database); | 878 throw Orthanc::OrthancException(Orthanc::ErrorCode_Database); |
798 } | 879 } |
799 else | 880 else |
800 { | 881 { |
801 backend->LogChange(change->changeType, id, type, change->date); | 882 adapter->GetBackend().LogChange(change->changeType, id, type, change->date); |
802 } | 883 } |
803 | 884 |
804 return OrthancPluginErrorCode_Success; | 885 return OrthancPluginErrorCode_Success; |
805 } | 886 } |
806 ORTHANC_PLUGINS_DATABASE_CATCH; | 887 ORTHANC_PLUGINS_DATABASE_CATCH; |
808 | 889 |
809 | 890 |
810 static OrthancPluginErrorCode LogExportedResource(void* payload, | 891 static OrthancPluginErrorCode LogExportedResource(void* payload, |
811 const OrthancPluginExportedResource* exported) | 892 const OrthancPluginExportedResource* exported) |
812 { | 893 { |
813 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 894 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
814 | 895 |
815 try | 896 try |
816 { | 897 { |
817 backend->LogExportedResource(*exported); | 898 adapter->GetBackend().LogExportedResource(*exported); |
818 return OrthancPluginErrorCode_Success; | 899 return OrthancPluginErrorCode_Success; |
819 } | 900 } |
820 ORTHANC_PLUGINS_DATABASE_CATCH; | 901 ORTHANC_PLUGINS_DATABASE_CATCH; |
821 } | 902 } |
822 | 903 |
824 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context, | 905 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context, |
825 void* payload, | 906 void* payload, |
826 int64_t id, | 907 int64_t id, |
827 int32_t contentType) | 908 int32_t contentType) |
828 { | 909 { |
829 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 910 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
830 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 911 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
831 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Attachment); | 912 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Attachment); |
832 | 913 |
833 try | 914 try |
834 { | 915 { |
835 backend->LookupAttachment(*output, id, contentType); | 916 adapter->GetBackend().LookupAttachment(*output, id, contentType); |
836 return OrthancPluginErrorCode_Success; | 917 return OrthancPluginErrorCode_Success; |
837 } | 918 } |
838 ORTHANC_PLUGINS_DATABASE_CATCH; | 919 ORTHANC_PLUGINS_DATABASE_CATCH; |
839 } | 920 } |
840 | 921 |
841 | 922 |
842 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context, | 923 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context, |
843 void* payload, | 924 void* payload, |
844 int32_t property) | 925 int32_t property) |
845 { | 926 { |
846 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 927 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
847 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 928 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
848 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 929 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
849 | 930 |
850 try | 931 try |
851 { | 932 { |
852 std::string s; | 933 std::string s; |
853 if (backend->LookupGlobalProperty(s, MISSING_SERVER_IDENTIFIER, property)) | 934 if (adapter->GetBackend().LookupGlobalProperty(s, MISSING_SERVER_IDENTIFIER, property)) |
854 { | 935 { |
855 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 936 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), |
856 output->GetDatabase(), | 937 output->GetDatabase(), |
857 s.c_str()); | 938 s.c_str()); |
858 } | 939 } |
859 | 940 |
860 return OrthancPluginErrorCode_Success; | 941 return OrthancPluginErrorCode_Success; |
867 void* payload, | 948 void* payload, |
868 OrthancPluginResourceType resourceType, | 949 OrthancPluginResourceType resourceType, |
869 const OrthancPluginDicomTag* tag, | 950 const OrthancPluginDicomTag* tag, |
870 OrthancPluginIdentifierConstraint constraint) | 951 OrthancPluginIdentifierConstraint constraint) |
871 { | 952 { |
872 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 953 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
873 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 954 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
874 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 955 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
875 | 956 |
876 try | 957 try |
877 { | 958 { |
878 std::list<int64_t> target; | 959 std::list<int64_t> target; |
879 backend->LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value); | 960 adapter->GetBackend().LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value); |
880 | 961 |
881 for (std::list<int64_t>::const_iterator | 962 for (std::list<int64_t>::const_iterator |
882 it = target.begin(); it != target.end(); ++it) | 963 it = target.begin(); it != target.end(); ++it) |
883 { | 964 { |
884 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 965 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), |
885 output->GetDatabase(), *it); | 966 output->GetDatabase(), *it); |
886 } | 967 } |
887 | 968 |
888 return OrthancPluginErrorCode_Success; | 969 return OrthancPluginErrorCode_Success; |
889 } | 970 } |
897 uint16_t group, | 978 uint16_t group, |
898 uint16_t element, | 979 uint16_t element, |
899 const char* start, | 980 const char* start, |
900 const char* end) | 981 const char* end) |
901 { | 982 { |
902 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 983 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
903 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 984 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
904 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 985 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
905 | 986 |
906 try | 987 try |
907 { | 988 { |
908 std::list<int64_t> target; | 989 std::list<int64_t> target; |
909 backend->LookupIdentifierRange(target, resourceType, group, element, start, end); | 990 adapter->GetBackend().LookupIdentifierRange(target, resourceType, group, element, start, end); |
910 | 991 |
911 for (std::list<int64_t>::const_iterator | 992 for (std::list<int64_t>::const_iterator |
912 it = target.begin(); it != target.end(); ++it) | 993 it = target.begin(); it != target.end(); ++it) |
913 { | 994 { |
914 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 995 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), |
915 output->GetDatabase(), *it); | 996 output->GetDatabase(), *it); |
916 } | 997 } |
917 | 998 |
918 return OrthancPluginErrorCode_Success; | 999 return OrthancPluginErrorCode_Success; |
919 } | 1000 } |
924 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context, | 1005 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context, |
925 void* payload, | 1006 void* payload, |
926 int64_t id, | 1007 int64_t id, |
927 int32_t metadata) | 1008 int32_t metadata) |
928 { | 1009 { |
929 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1010 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
930 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 1011 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
931 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 1012 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
932 | 1013 |
933 try | 1014 try |
934 { | 1015 { |
935 std::string s; | 1016 std::string s; |
936 if (backend->LookupMetadata(s, id, metadata)) | 1017 if (adapter->GetBackend().LookupMetadata(s, id, metadata)) |
937 { | 1018 { |
938 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 1019 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), |
939 output->GetDatabase(), s.c_str()); | 1020 output->GetDatabase(), s.c_str()); |
940 } | 1021 } |
941 | 1022 |
942 return OrthancPluginErrorCode_Success; | 1023 return OrthancPluginErrorCode_Success; |
943 } | 1024 } |
947 | 1028 |
948 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context, | 1029 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context, |
949 void* payload, | 1030 void* payload, |
950 int64_t id) | 1031 int64_t id) |
951 { | 1032 { |
952 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1033 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
953 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 1034 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
954 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 1035 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
955 | 1036 |
956 try | 1037 try |
957 { | 1038 { |
958 int64_t parent; | 1039 int64_t parent; |
959 if (backend->LookupParent(parent, id)) | 1040 if (adapter->GetBackend().LookupParent(parent, id)) |
960 { | 1041 { |
961 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 1042 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), |
962 output->GetDatabase(), parent); | 1043 output->GetDatabase(), parent); |
963 } | 1044 } |
964 | 1045 |
965 return OrthancPluginErrorCode_Success; | 1046 return OrthancPluginErrorCode_Success; |
966 } | 1047 } |
970 | 1051 |
971 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context, | 1052 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context, |
972 void* payload, | 1053 void* payload, |
973 const char* publicId) | 1054 const char* publicId) |
974 { | 1055 { |
975 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1056 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
976 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 1057 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
977 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 1058 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
978 | 1059 |
979 try | 1060 try |
980 { | 1061 { |
981 int64_t id; | 1062 int64_t id; |
982 OrthancPluginResourceType type; | 1063 OrthancPluginResourceType type; |
983 if (backend->LookupResource(id, type, publicId)) | 1064 if (adapter->GetBackend().LookupResource(id, type, publicId)) |
984 { | 1065 { |
985 OrthancPluginDatabaseAnswerResource(backend->GetContext(), | 1066 OrthancPluginDatabaseAnswerResource(adapter->GetBackend().GetContext(), |
986 output->GetDatabase(), | 1067 output->GetDatabase(), |
987 id, type); | 1068 id, type); |
988 } | 1069 } |
989 | 1070 |
990 return OrthancPluginErrorCode_Success; | 1071 return OrthancPluginErrorCode_Success; |
994 | 1075 |
995 | 1076 |
996 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context, | 1077 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context, |
997 void* payload) | 1078 void* payload) |
998 { | 1079 { |
999 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1080 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1000 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 1081 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
1001 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 1082 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
1002 | 1083 |
1003 try | 1084 try |
1004 { | 1085 { |
1005 int64_t id; | 1086 int64_t id; |
1006 if (backend->SelectPatientToRecycle(id)) | 1087 if (adapter->GetBackend().SelectPatientToRecycle(id)) |
1007 { | 1088 { |
1008 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 1089 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), |
1009 output->GetDatabase(), id); | 1090 output->GetDatabase(), id); |
1010 } | 1091 } |
1011 | 1092 |
1012 return OrthancPluginErrorCode_Success; | 1093 return OrthancPluginErrorCode_Success; |
1013 } | 1094 } |
1017 | 1098 |
1018 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context, | 1099 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context, |
1019 void* payload, | 1100 void* payload, |
1020 int64_t patientIdToAvoid) | 1101 int64_t patientIdToAvoid) |
1021 { | 1102 { |
1022 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1103 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1023 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 1104 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
1024 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 1105 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
1025 | 1106 |
1026 try | 1107 try |
1027 { | 1108 { |
1028 int64_t id; | 1109 int64_t id; |
1029 if (backend->SelectPatientToRecycle(id, patientIdToAvoid)) | 1110 if (adapter->GetBackend().SelectPatientToRecycle(id, patientIdToAvoid)) |
1030 { | 1111 { |
1031 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), | 1112 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), |
1032 output->GetDatabase(), id); | 1113 output->GetDatabase(), id); |
1033 } | 1114 } |
1034 | 1115 |
1035 return OrthancPluginErrorCode_Success; | 1116 return OrthancPluginErrorCode_Success; |
1036 } | 1117 } |
1040 | 1121 |
1041 static OrthancPluginErrorCode SetGlobalProperty(void* payload, | 1122 static OrthancPluginErrorCode SetGlobalProperty(void* payload, |
1042 int32_t property, | 1123 int32_t property, |
1043 const char* value) | 1124 const char* value) |
1044 { | 1125 { |
1045 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1126 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1046 | 1127 |
1047 try | 1128 try |
1048 { | 1129 { |
1049 backend->SetGlobalProperty(MISSING_SERVER_IDENTIFIER, property, value); | 1130 adapter->GetBackend().SetGlobalProperty(MISSING_SERVER_IDENTIFIER, property, value); |
1050 return OrthancPluginErrorCode_Success; | 1131 return OrthancPluginErrorCode_Success; |
1051 } | 1132 } |
1052 ORTHANC_PLUGINS_DATABASE_CATCH; | 1133 ORTHANC_PLUGINS_DATABASE_CATCH; |
1053 } | 1134 } |
1054 | 1135 |
1055 | 1136 |
1056 static OrthancPluginErrorCode SetMainDicomTag(void* payload, | 1137 static OrthancPluginErrorCode SetMainDicomTag(void* payload, |
1057 int64_t id, | 1138 int64_t id, |
1058 const OrthancPluginDicomTag* tag) | 1139 const OrthancPluginDicomTag* tag) |
1059 { | 1140 { |
1060 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1141 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1061 | 1142 |
1062 try | 1143 try |
1063 { | 1144 { |
1064 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value); | 1145 adapter->GetBackend().SetMainDicomTag(id, tag->group, tag->element, tag->value); |
1065 return OrthancPluginErrorCode_Success; | 1146 return OrthancPluginErrorCode_Success; |
1066 } | 1147 } |
1067 ORTHANC_PLUGINS_DATABASE_CATCH; | 1148 ORTHANC_PLUGINS_DATABASE_CATCH; |
1068 } | 1149 } |
1069 | 1150 |
1070 | 1151 |
1071 static OrthancPluginErrorCode SetIdentifierTag(void* payload, | 1152 static OrthancPluginErrorCode SetIdentifierTag(void* payload, |
1072 int64_t id, | 1153 int64_t id, |
1073 const OrthancPluginDicomTag* tag) | 1154 const OrthancPluginDicomTag* tag) |
1074 { | 1155 { |
1075 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1156 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1076 | 1157 |
1077 try | 1158 try |
1078 { | 1159 { |
1079 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value); | 1160 adapter->GetBackend().SetIdentifierTag(id, tag->group, tag->element, tag->value); |
1080 return OrthancPluginErrorCode_Success; | 1161 return OrthancPluginErrorCode_Success; |
1081 } | 1162 } |
1082 ORTHANC_PLUGINS_DATABASE_CATCH; | 1163 ORTHANC_PLUGINS_DATABASE_CATCH; |
1083 } | 1164 } |
1084 | 1165 |
1086 static OrthancPluginErrorCode SetMetadata(void* payload, | 1167 static OrthancPluginErrorCode SetMetadata(void* payload, |
1087 int64_t id, | 1168 int64_t id, |
1088 int32_t metadata, | 1169 int32_t metadata, |
1089 const char* value) | 1170 const char* value) |
1090 { | 1171 { |
1091 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1172 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1092 | 1173 |
1093 try | 1174 try |
1094 { | 1175 { |
1095 backend->SetMetadata(id, metadata, value); | 1176 adapter->GetBackend().SetMetadata(id, metadata, value); |
1096 return OrthancPluginErrorCode_Success; | 1177 return OrthancPluginErrorCode_Success; |
1097 } | 1178 } |
1098 ORTHANC_PLUGINS_DATABASE_CATCH; | 1179 ORTHANC_PLUGINS_DATABASE_CATCH; |
1099 } | 1180 } |
1100 | 1181 |
1101 | 1182 |
1102 static OrthancPluginErrorCode SetProtectedPatient(void* payload, | 1183 static OrthancPluginErrorCode SetProtectedPatient(void* payload, |
1103 int64_t id, | 1184 int64_t id, |
1104 int32_t isProtected) | 1185 int32_t isProtected) |
1105 { | 1186 { |
1106 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1187 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1107 | 1188 |
1108 try | 1189 try |
1109 { | 1190 { |
1110 backend->SetProtectedPatient(id, (isProtected != 0)); | 1191 adapter->GetBackend().SetProtectedPatient(id, (isProtected != 0)); |
1111 return OrthancPluginErrorCode_Success; | 1192 return OrthancPluginErrorCode_Success; |
1112 } | 1193 } |
1113 ORTHANC_PLUGINS_DATABASE_CATCH; | 1194 ORTHANC_PLUGINS_DATABASE_CATCH; |
1114 } | 1195 } |
1115 | 1196 |
1116 | 1197 |
1117 static OrthancPluginErrorCode StartTransaction(void* payload) | 1198 static OrthancPluginErrorCode StartTransaction(void* payload) |
1118 { | 1199 { |
1119 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1200 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1120 | 1201 |
1121 try | 1202 try |
1122 { | 1203 { |
1123 backend->StartTransaction(TransactionType_ReadWrite); | 1204 adapter->GetBackend().StartTransaction(TransactionType_ReadWrite); |
1124 return OrthancPluginErrorCode_Success; | 1205 return OrthancPluginErrorCode_Success; |
1125 } | 1206 } |
1126 ORTHANC_PLUGINS_DATABASE_CATCH; | 1207 ORTHANC_PLUGINS_DATABASE_CATCH; |
1127 } | 1208 } |
1128 | 1209 |
1129 | 1210 |
1130 static OrthancPluginErrorCode RollbackTransaction(void* payload) | 1211 static OrthancPluginErrorCode RollbackTransaction(void* payload) |
1131 { | 1212 { |
1132 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1213 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1133 | 1214 |
1134 try | 1215 try |
1135 { | 1216 { |
1136 backend->RollbackTransaction(); | 1217 adapter->GetBackend().RollbackTransaction(); |
1137 return OrthancPluginErrorCode_Success; | 1218 return OrthancPluginErrorCode_Success; |
1138 } | 1219 } |
1139 ORTHANC_PLUGINS_DATABASE_CATCH; | 1220 ORTHANC_PLUGINS_DATABASE_CATCH; |
1140 } | 1221 } |
1141 | 1222 |
1142 | 1223 |
1143 static OrthancPluginErrorCode CommitTransaction(void* payload) | 1224 static OrthancPluginErrorCode CommitTransaction(void* payload) |
1144 { | 1225 { |
1145 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1226 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1146 | 1227 |
1147 try | 1228 try |
1148 { | 1229 { |
1149 backend->CommitTransaction(); | 1230 adapter->GetBackend().CommitTransaction(); |
1150 return OrthancPluginErrorCode_Success; | 1231 return OrthancPluginErrorCode_Success; |
1151 } | 1232 } |
1152 ORTHANC_PLUGINS_DATABASE_CATCH; | 1233 ORTHANC_PLUGINS_DATABASE_CATCH; |
1153 } | 1234 } |
1154 | 1235 |
1155 | 1236 |
1156 static OrthancPluginErrorCode Open(void* payload) | 1237 static OrthancPluginErrorCode Open(void* payload) |
1157 { | 1238 { |
1158 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1239 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1159 | 1240 |
1160 try | 1241 try |
1161 { | 1242 { |
1162 backend->Open(); | 1243 //adapter->OpenConnection(); // TODO |
1244 adapter->GetBackend().Open(); | |
1163 return OrthancPluginErrorCode_Success; | 1245 return OrthancPluginErrorCode_Success; |
1164 } | 1246 } |
1165 ORTHANC_PLUGINS_DATABASE_CATCH; | 1247 ORTHANC_PLUGINS_DATABASE_CATCH; |
1166 } | 1248 } |
1167 | 1249 |
1168 | 1250 |
1169 static OrthancPluginErrorCode Close(void* payload) | 1251 static OrthancPluginErrorCode Close(void* payload) |
1170 { | 1252 { |
1171 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1253 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1172 | 1254 |
1173 try | 1255 try |
1174 { | 1256 { |
1175 backend->Close(); | 1257 adapter->GetBackend().Close(); |
1258 //adapter->CloseConnection(); // TODO | |
1176 return OrthancPluginErrorCode_Success; | 1259 return OrthancPluginErrorCode_Success; |
1177 } | 1260 } |
1178 ORTHANC_PLUGINS_DATABASE_CATCH; | 1261 ORTHANC_PLUGINS_DATABASE_CATCH; |
1179 } | 1262 } |
1180 | 1263 |
1181 | 1264 |
1182 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version, | 1265 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version, |
1183 void* payload) | 1266 void* payload) |
1184 { | 1267 { |
1185 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1268 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1186 | 1269 |
1187 try | 1270 try |
1188 { | 1271 { |
1189 *version = backend->GetDatabaseVersion(); | 1272 *version = adapter->GetBackend().GetDatabaseVersion(); |
1190 return OrthancPluginErrorCode_Success; | 1273 return OrthancPluginErrorCode_Success; |
1191 } | 1274 } |
1192 ORTHANC_PLUGINS_DATABASE_CATCH; | 1275 ORTHANC_PLUGINS_DATABASE_CATCH; |
1193 } | 1276 } |
1194 | 1277 |
1195 | 1278 |
1196 static OrthancPluginErrorCode UpgradeDatabase(void* payload, | 1279 static OrthancPluginErrorCode UpgradeDatabase(void* payload, |
1197 uint32_t targetVersion, | 1280 uint32_t targetVersion, |
1198 OrthancPluginStorageArea* storageArea) | 1281 OrthancPluginStorageArea* storageArea) |
1199 { | 1282 { |
1200 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1283 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1201 | 1284 |
1202 try | 1285 try |
1203 { | 1286 { |
1204 backend->UpgradeDatabase(targetVersion, storageArea); | 1287 adapter->GetBackend().UpgradeDatabase(targetVersion, storageArea); |
1205 return OrthancPluginErrorCode_Success; | 1288 return OrthancPluginErrorCode_Success; |
1206 } | 1289 } |
1207 ORTHANC_PLUGINS_DATABASE_CATCH; | 1290 ORTHANC_PLUGINS_DATABASE_CATCH; |
1208 } | 1291 } |
1209 | 1292 |
1210 | 1293 |
1211 static OrthancPluginErrorCode ClearMainDicomTags(void* payload, | 1294 static OrthancPluginErrorCode ClearMainDicomTags(void* payload, |
1212 int64_t internalId) | 1295 int64_t internalId) |
1213 { | 1296 { |
1214 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1297 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1215 | 1298 |
1216 try | 1299 try |
1217 { | 1300 { |
1218 backend->ClearMainDicomTags(internalId); | 1301 adapter->GetBackend().ClearMainDicomTags(internalId); |
1219 return OrthancPluginErrorCode_Success; | 1302 return OrthancPluginErrorCode_Success; |
1220 } | 1303 } |
1221 ORTHANC_PLUGINS_DATABASE_CATCH; | 1304 ORTHANC_PLUGINS_DATABASE_CATCH; |
1222 } | 1305 } |
1223 | 1306 |
1231 const OrthancPluginDatabaseConstraint* constraints, | 1314 const OrthancPluginDatabaseConstraint* constraints, |
1232 OrthancPluginResourceType queryLevel, | 1315 OrthancPluginResourceType queryLevel, |
1233 uint32_t limit, | 1316 uint32_t limit, |
1234 uint8_t requestSomeInstance) | 1317 uint8_t requestSomeInstance) |
1235 { | 1318 { |
1236 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1319 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1237 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 1320 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
1238 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_MatchingResource); | 1321 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_MatchingResource); |
1239 | 1322 |
1240 try | 1323 try |
1241 { | 1324 { |
1242 std::vector<Orthanc::DatabaseConstraint> lookup; | 1325 std::vector<Orthanc::DatabaseConstraint> lookup; |
1245 for (uint32_t i = 0; i < constraintsCount; i++) | 1328 for (uint32_t i = 0; i < constraintsCount; i++) |
1246 { | 1329 { |
1247 lookup.push_back(Orthanc::DatabaseConstraint(constraints[i])); | 1330 lookup.push_back(Orthanc::DatabaseConstraint(constraints[i])); |
1248 } | 1331 } |
1249 | 1332 |
1250 backend->LookupResources(*output, lookup, queryLevel, limit, (requestSomeInstance != 0)); | 1333 adapter->GetBackend().LookupResources(*output, lookup, queryLevel, limit, (requestSomeInstance != 0)); |
1251 return OrthancPluginErrorCode_Success; | 1334 return OrthancPluginErrorCode_Success; |
1252 } | 1335 } |
1253 ORTHANC_PLUGINS_DATABASE_CATCH; | 1336 ORTHANC_PLUGINS_DATABASE_CATCH; |
1254 } | 1337 } |
1255 #endif | 1338 #endif |
1261 const char* hashPatient, | 1344 const char* hashPatient, |
1262 const char* hashStudy, | 1345 const char* hashStudy, |
1263 const char* hashSeries, | 1346 const char* hashSeries, |
1264 const char* hashInstance) | 1347 const char* hashInstance) |
1265 { | 1348 { |
1266 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1349 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1267 | 1350 |
1268 try | 1351 try |
1269 { | 1352 { |
1270 backend->CreateInstance(*target, hashPatient, hashStudy, hashSeries, hashInstance); | 1353 adapter->GetBackend().CreateInstance(*target, hashPatient, hashStudy, hashSeries, hashInstance); |
1271 return OrthancPluginErrorCode_Success; | 1354 return OrthancPluginErrorCode_Success; |
1272 } | 1355 } |
1273 ORTHANC_PLUGINS_DATABASE_CATCH; | 1356 ORTHANC_PLUGINS_DATABASE_CATCH; |
1274 } | 1357 } |
1275 #endif | 1358 #endif |
1283 uint32_t countMainDicomTags, | 1366 uint32_t countMainDicomTags, |
1284 const OrthancPluginResourcesContentTags* mainDicomTags, | 1367 const OrthancPluginResourcesContentTags* mainDicomTags, |
1285 uint32_t countMetadata, | 1368 uint32_t countMetadata, |
1286 const OrthancPluginResourcesContentMetadata* metadata) | 1369 const OrthancPluginResourcesContentMetadata* metadata) |
1287 { | 1370 { |
1288 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1371 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1289 | 1372 |
1290 try | 1373 try |
1291 { | 1374 { |
1292 backend->SetResourcesContent(countIdentifierTags, identifierTags, | 1375 adapter->GetBackend().SetResourcesContent(countIdentifierTags, identifierTags, |
1293 countMainDicomTags, mainDicomTags, | 1376 countMainDicomTags, mainDicomTags, |
1294 countMetadata, metadata); | 1377 countMetadata, metadata); |
1295 return OrthancPluginErrorCode_Success; | 1378 return OrthancPluginErrorCode_Success; |
1296 } | 1379 } |
1297 ORTHANC_PLUGINS_DATABASE_CATCH; | 1380 ORTHANC_PLUGINS_DATABASE_CATCH; |
1303 static OrthancPluginErrorCode GetChildrenMetadata(OrthancPluginDatabaseContext* context, | 1386 static OrthancPluginErrorCode GetChildrenMetadata(OrthancPluginDatabaseContext* context, |
1304 void* payload, | 1387 void* payload, |
1305 int64_t resourceId, | 1388 int64_t resourceId, |
1306 int32_t metadata) | 1389 int32_t metadata) |
1307 { | 1390 { |
1308 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1391 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1309 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 1392 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
1310 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); | 1393 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); |
1311 | 1394 |
1312 try | 1395 try |
1313 { | 1396 { |
1314 std::list<std::string> values; | 1397 std::list<std::string> values; |
1315 backend->GetChildrenMetadata(values, resourceId, metadata); | 1398 adapter->GetBackend().GetChildrenMetadata(values, resourceId, metadata); |
1316 | 1399 |
1317 for (std::list<std::string>::const_iterator | 1400 for (std::list<std::string>::const_iterator |
1318 it = values.begin(); it != values.end(); ++it) | 1401 it = values.begin(); it != values.end(); ++it) |
1319 { | 1402 { |
1320 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 1403 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), |
1321 output->GetDatabase(), | 1404 output->GetDatabase(), |
1322 it->c_str()); | 1405 it->c_str()); |
1323 } | 1406 } |
1324 | 1407 |
1325 return OrthancPluginErrorCode_Success; | 1408 return OrthancPluginErrorCode_Success; |
1330 | 1413 |
1331 // New primitive since Orthanc 1.5.2 | 1414 // New primitive since Orthanc 1.5.2 |
1332 static OrthancPluginErrorCode GetLastChangeIndex(int64_t* result, | 1415 static OrthancPluginErrorCode GetLastChangeIndex(int64_t* result, |
1333 void* payload) | 1416 void* payload) |
1334 { | 1417 { |
1335 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1418 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1336 | 1419 |
1337 try | 1420 try |
1338 { | 1421 { |
1339 *result = backend->GetLastChangeIndex(); | 1422 *result = adapter->GetBackend().GetLastChangeIndex(); |
1340 return OrthancPluginErrorCode_Success; | 1423 return OrthancPluginErrorCode_Success; |
1341 } | 1424 } |
1342 ORTHANC_PLUGINS_DATABASE_CATCH; | 1425 ORTHANC_PLUGINS_DATABASE_CATCH; |
1343 } | 1426 } |
1344 | 1427 |
1345 | 1428 |
1346 // New primitive since Orthanc 1.5.2 | 1429 // New primitive since Orthanc 1.5.2 |
1347 static OrthancPluginErrorCode TagMostRecentPatient(void* payload, | 1430 static OrthancPluginErrorCode TagMostRecentPatient(void* payload, |
1348 int64_t patientId) | 1431 int64_t patientId) |
1349 { | 1432 { |
1350 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1433 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1351 | 1434 |
1352 try | 1435 try |
1353 { | 1436 { |
1354 backend->TagMostRecentPatient(patientId); | 1437 adapter->GetBackend().TagMostRecentPatient(patientId); |
1355 return OrthancPluginErrorCode_Success; | 1438 return OrthancPluginErrorCode_Success; |
1356 } | 1439 } |
1357 ORTHANC_PLUGINS_DATABASE_CATCH; | 1440 ORTHANC_PLUGINS_DATABASE_CATCH; |
1358 } | 1441 } |
1359 | 1442 |
1363 // New primitive since Orthanc 1.5.4 | 1446 // New primitive since Orthanc 1.5.4 |
1364 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseContext* context, | 1447 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseContext* context, |
1365 void* payload, | 1448 void* payload, |
1366 int64_t resourceId) | 1449 int64_t resourceId) |
1367 { | 1450 { |
1368 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1451 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1369 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 1452 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
1370 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Metadata); | 1453 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Metadata); |
1371 | 1454 |
1372 try | 1455 try |
1373 { | 1456 { |
1374 std::map<int32_t, std::string> result; | 1457 std::map<int32_t, std::string> result; |
1375 backend->GetAllMetadata(result, resourceId); | 1458 adapter->GetBackend().GetAllMetadata(result, resourceId); |
1376 | 1459 |
1377 for (std::map<int32_t, std::string>::const_iterator | 1460 for (std::map<int32_t, std::string>::const_iterator |
1378 it = result.begin(); it != result.end(); ++it) | 1461 it = result.begin(); it != result.end(); ++it) |
1379 { | 1462 { |
1380 OrthancPluginDatabaseAnswerMetadata(backend->GetContext(), | 1463 OrthancPluginDatabaseAnswerMetadata(adapter->GetBackend().GetContext(), |
1381 output->GetDatabase(), | 1464 output->GetDatabase(), |
1382 resourceId, it->first, it->second.c_str()); | 1465 resourceId, it->first, it->second.c_str()); |
1383 } | 1466 } |
1384 | 1467 |
1385 return OrthancPluginErrorCode_Success; | 1468 return OrthancPluginErrorCode_Success; |
1398 int64_t* id, | 1481 int64_t* id, |
1399 OrthancPluginResourceType* type, | 1482 OrthancPluginResourceType* type, |
1400 void* payload, | 1483 void* payload, |
1401 const char* publicId) | 1484 const char* publicId) |
1402 { | 1485 { |
1403 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); | 1486 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); |
1404 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); | 1487 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); |
1405 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_String); | 1488 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_String); |
1406 | 1489 |
1407 try | 1490 try |
1408 { | 1491 { |
1409 std::string parent; | 1492 std::string parent; |
1410 if (backend->LookupResourceAndParent(*id, *type, parent, publicId)) | 1493 if (adapter->GetBackend().LookupResourceAndParent(*id, *type, parent, publicId)) |
1411 { | 1494 { |
1412 *isExisting = 1; | 1495 *isExisting = 1; |
1413 | 1496 |
1414 if (!parent.empty()) | 1497 if (!parent.empty()) |
1415 { | 1498 { |
1416 OrthancPluginDatabaseAnswerString(backend->GetContext(), | 1499 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), |
1417 output->GetDatabase(), | 1500 output->GetDatabase(), |
1418 parent.c_str()); | 1501 parent.c_str()); |
1419 } | 1502 } |
1420 } | 1503 } |
1421 else | 1504 else |
1435 { | 1518 { |
1436 return new Output(context_, database_); | 1519 return new Output(context_, database_); |
1437 } | 1520 } |
1438 | 1521 |
1439 | 1522 |
1440 static std::unique_ptr<IDatabaseBackend> backend_; | 1523 static std::unique_ptr<DatabaseBackendAdapterV2::Adapter> adapter_; |
1441 | 1524 |
1442 void DatabaseBackendAdapterV2::Register(IDatabaseBackend* backend) | 1525 void DatabaseBackendAdapterV2::Register(IDatabaseBackend* backend) |
1443 { | 1526 { |
1444 if (backend == NULL) | 1527 if (backend == NULL) |
1445 { | 1528 { |
1446 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | 1529 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); |
1447 } | 1530 } |
1448 | 1531 |
1449 if (backend_.get() != NULL) | 1532 if (adapter_.get() != NULL) |
1450 { | 1533 { |
1451 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | 1534 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); |
1452 } | 1535 } |
1453 | 1536 |
1454 backend_.reset(backend); | 1537 adapter_.reset(new Adapter(backend)); |
1455 | 1538 |
1456 OrthancPluginDatabaseBackend params; | 1539 OrthancPluginDatabaseBackend params; |
1457 memset(¶ms, 0, sizeof(params)); | 1540 memset(¶ms, 0, sizeof(params)); |
1458 | 1541 |
1459 OrthancPluginDatabaseExtensions extensions; | 1542 OrthancPluginDatabaseExtensions extensions; |
1527 extensions.setResourcesContent = SetResourcesContent; // Fast setting tags/metadata | 1610 extensions.setResourcesContent = SetResourcesContent; // Fast setting tags/metadata |
1528 extensions.getChildrenMetadata = GetChildrenMetadata; | 1611 extensions.getChildrenMetadata = GetChildrenMetadata; |
1529 extensions.getLastChangeIndex = GetLastChangeIndex; | 1612 extensions.getLastChangeIndex = GetLastChangeIndex; |
1530 extensions.tagMostRecentPatient = TagMostRecentPatient; | 1613 extensions.tagMostRecentPatient = TagMostRecentPatient; |
1531 | 1614 |
1532 if (backend_->HasCreateInstance()) | 1615 if (adapter_->GetBackend().HasCreateInstance()) |
1533 { | 1616 { |
1534 extensions.createInstance = CreateInstance; // Fast creation of resources | 1617 extensions.createInstance = CreateInstance; // Fast creation of resources |
1535 } | 1618 } |
1536 #endif | 1619 #endif |
1537 | 1620 |
1542 extensions.getAllMetadata = GetAllMetadata; | 1625 extensions.getAllMetadata = GetAllMetadata; |
1543 performanceWarning = false; | 1626 performanceWarning = false; |
1544 # endif | 1627 # endif |
1545 #endif | 1628 #endif |
1546 | 1629 |
1547 OrthancPluginContext* context = backend_->GetContext(); | 1630 OrthancPluginContext* context = adapter_->GetBackend().GetContext(); |
1548 | 1631 |
1549 if (performanceWarning) | 1632 if (performanceWarning) |
1550 { | 1633 { |
1551 char info[1024]; | 1634 char info[1024]; |
1552 sprintf(info, | 1635 sprintf(info, |
1562 | 1645 |
1563 OrthancPluginLogWarning(context, info); | 1646 OrthancPluginLogWarning(context, info); |
1564 } | 1647 } |
1565 | 1648 |
1566 OrthancPluginDatabaseContext* database = | 1649 OrthancPluginDatabaseContext* database = |
1567 OrthancPluginRegisterDatabaseBackendV2(context, ¶ms, &extensions, backend_.get()); | 1650 OrthancPluginRegisterDatabaseBackendV2(context, ¶ms, &extensions, adapter_.get()); |
1568 if (database == NULL) | 1651 if (database == NULL) |
1569 { | 1652 { |
1570 throw std::runtime_error("Unable to register the database backend"); | 1653 throw std::runtime_error("Unable to register the database backend"); |
1571 } | 1654 } |
1572 | 1655 |
1573 backend_->SetOutputFactory(new Factory(context, database)); | 1656 adapter_->GetBackend().SetOutputFactory(new Factory(context, database)); |
1574 } | 1657 } |
1575 | 1658 |
1576 | 1659 |
1577 void DatabaseBackendAdapterV2::Finalize() | 1660 void DatabaseBackendAdapterV2::Finalize() |
1578 { | 1661 { |
1579 backend_.reset(NULL); | 1662 adapter_.reset(NULL); |
1580 } | 1663 } |
1581 } | 1664 } |