Mercurial > hg > orthanc-databases

comparison Framework/Plugins/DatabaseBackendAdapterV2.cpp @ 225:94c9908e6aca

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
removed DatabaseManager member out of class IndexBackend
author Sebastien Jodogne <s.jodogne@gmail.com>
date Thu, 01 Apr 2021 19:18:19 +0200
parents 61c309e06797
children a4918d57435c
comparison
equal deleted inserted replaced
224:61c309e06797 225:94c9908e6aca
52 { 52 {
53 class DatabaseBackendAdapterV2::Adapter : public boost::noncopyable 53 class DatabaseBackendAdapterV2::Adapter : public boost::noncopyable
54 { 54 {
55 private: 55 private:
56 std::unique_ptr<IDatabaseBackend> backend_; 56 std::unique_ptr<IDatabaseBackend> backend_;
57 boost::mutex databaseMutex_; 57 boost::mutex managerMutex_;
58 std::unique_ptr<DatabaseManager> database_; 58 std::unique_ptr<DatabaseManager> manager_;
59 59
60 public: 60 public:
61 Adapter(IDatabaseBackend* backend) : 61 Adapter(IDatabaseBackend* backend) :
62 backend_(backend) 62 backend_(backend)
63 { 63 {
72 return *backend_; 72 return *backend_;
73 } 73 }
74 74
75 void OpenConnection() 75 void OpenConnection()
76 { 76 {
77 boost::mutex::scoped_lock lock(databaseMutex_); 77 boost::mutex::scoped_lock lock(managerMutex_);
78 78
79 if (database_.get() == NULL) 79 if (manager_.get() == NULL)
80 { 80 {
81 database_.reset(new DatabaseManager(backend_->CreateDatabaseFactory())); 81 manager_.reset(new DatabaseManager(backend_->CreateDatabaseFactory()));
82 database_->Open(); 82 manager_->Open();
83 } 83 }
84 else 84 else
85 { 85 {
86 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); 86 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
87 } 87 }
88 } 88 }
89 89
90 void CloseConnection() 90 void CloseConnection()
91 { 91 {
92 boost::mutex::scoped_lock lock(databaseMutex_); 92 boost::mutex::scoped_lock lock(managerMutex_);
93 93
94 if (database_.get() == NULL) 94 if (manager_.get() == NULL)
95 { 95 {
96 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); 96 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
97 } 97 }
98 else 98 else
99 { 99 {
100 database_->Close(); 100 manager_->Close();
101 database_.reset(NULL); 101 manager_.reset(NULL);
102 } 102 }
103 } 103 }
104 104
105 class DatabaseAccessor : public boost::noncopyable 105 class DatabaseAccessor : public boost::noncopyable
106 { 106 {
107 private: 107 private:
108 boost::mutex::scoped_lock lock_; 108 boost::mutex::scoped_lock lock_;
109 DatabaseManager* database_; 109 DatabaseManager* manager_;
110 110
111 public: 111 public:
112 DatabaseAccessor(Adapter& adapter) : 112 DatabaseAccessor(Adapter& adapter) :
113 lock_(adapter.databaseMutex_), 113 lock_(adapter.managerMutex_),
114 database_(adapter.database_.get()) 114 manager_(adapter.manager_.get())
115 { 115 {
116 if (database_ == NULL) 116 if (manager_ == NULL)
117 { 117 {
118 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); 118 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
119 } 119 }
120 } 120 }
121 121
122 DatabaseManager& GetDatabase() const 122 DatabaseManager& GetManager() const
123 { 123 {
124 assert(database_ != NULL); 124 assert(manager_ != NULL);
125 return *database_; 125 return *manager_;
126 } 126 }
127 }; 127 };
128 }; 128 };
129 129
130 130
349 { 349 {
350 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 350 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
351 351
352 try 352 try
353 { 353 {
354 //DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter); // TODO 354 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
355 355 adapter->GetBackend().AddAttachment(accessor.GetManager(), id, *attachment);
356 adapter->GetBackend().AddAttachment(id, *attachment);
357 return OrthancPluginErrorCode_Success; 356 return OrthancPluginErrorCode_Success;
358 } 357 }
359 ORTHANC_PLUGINS_DATABASE_CATCH; 358 ORTHANC_PLUGINS_DATABASE_CATCH;
360 } 359 }
361 360
366 { 365 {
367 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 366 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
368 367
369 try 368 try
370 { 369 {
371 adapter->GetBackend().AttachChild(parent, child); 370 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
371 adapter->GetBackend().AttachChild(accessor.GetManager(), parent, child);
372 return OrthancPluginErrorCode_Success; 372 return OrthancPluginErrorCode_Success;
373 } 373 }
374 ORTHANC_PLUGINS_DATABASE_CATCH; 374 ORTHANC_PLUGINS_DATABASE_CATCH;
375 } 375 }
376 376
379 { 379 {
380 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 380 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
381 381
382 try 382 try
383 { 383 {
384 adapter->GetBackend().ClearChanges(); 384 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
385 adapter->GetBackend().ClearChanges(accessor.GetManager());
385 return OrthancPluginErrorCode_Success; 386 return OrthancPluginErrorCode_Success;
386 } 387 }
387 ORTHANC_PLUGINS_DATABASE_CATCH; 388 ORTHANC_PLUGINS_DATABASE_CATCH;
388 } 389 }
389 390
392 { 393 {
393 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 394 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
394 395
395 try 396 try
396 { 397 {
397 adapter->GetBackend().ClearExportedResources(); 398 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
399 adapter->GetBackend().ClearExportedResources(accessor.GetManager());
398 return OrthancPluginErrorCode_Success; 400 return OrthancPluginErrorCode_Success;
399 } 401 }
400 ORTHANC_PLUGINS_DATABASE_CATCH; 402 ORTHANC_PLUGINS_DATABASE_CATCH;
401 } 403 }
402 404
408 { 410 {
409 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 411 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
410 412
411 try 413 try
412 { 414 {
413 *id = adapter->GetBackend().CreateResource(publicId, resourceType); 415 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
416
417 *id = adapter->GetBackend().CreateResource(accessor.GetManager(), publicId, resourceType);
414 return OrthancPluginErrorCode_Success; 418 return OrthancPluginErrorCode_Success;
415 } 419 }
416 ORTHANC_PLUGINS_DATABASE_CATCH; 420 ORTHANC_PLUGINS_DATABASE_CATCH;
417 } 421 }
418 422
425 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 429 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
426 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 430 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
427 431
428 try 432 try
429 { 433 {
430 adapter->GetBackend().DeleteAttachment(*output, id, contentType); 434 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
435 adapter->GetBackend().DeleteAttachment(*output, accessor.GetManager(), id, contentType);
431 return OrthancPluginErrorCode_Success; 436 return OrthancPluginErrorCode_Success;
432 } 437 }
433 ORTHANC_PLUGINS_DATABASE_CATCH; 438 ORTHANC_PLUGINS_DATABASE_CATCH;
434 } 439 }
435 440
440 { 445 {
441 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 446 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
442 447
443 try 448 try
444 { 449 {
445 adapter->GetBackend().DeleteMetadata(id, metadataType); 450 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
451 adapter->GetBackend().DeleteMetadata(accessor.GetManager(), id, metadataType);
446 return OrthancPluginErrorCode_Success; 452 return OrthancPluginErrorCode_Success;
447 } 453 }
448 ORTHANC_PLUGINS_DATABASE_CATCH; 454 ORTHANC_PLUGINS_DATABASE_CATCH;
449 } 455 }
450 456
456 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 462 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
457 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 463 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
458 464
459 try 465 try
460 { 466 {
461 adapter->GetBackend().DeleteResource(*output, id); 467 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
468 adapter->GetBackend().DeleteResource(*output, accessor.GetManager(), id);
462 return OrthancPluginErrorCode_Success; 469 return OrthancPluginErrorCode_Success;
463 } 470 }
464 ORTHANC_PLUGINS_DATABASE_CATCH; 471 ORTHANC_PLUGINS_DATABASE_CATCH;
465 } 472 }
466 473
473 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 480 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
474 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 481 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
475 482
476 try 483 try
477 { 484 {
485 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
486
478 std::list<int64_t> target; 487 std::list<int64_t> target;
479 adapter->GetBackend().GetAllInternalIds(target, resourceType); 488 adapter->GetBackend().GetAllInternalIds(target, accessor.GetManager(), resourceType);
480 489
481 for (std::list<int64_t>::const_iterator 490 for (std::list<int64_t>::const_iterator
482 it = target.begin(); it != target.end(); ++it) 491 it = target.begin(); it != target.end(); ++it)
483 { 492 {
484 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), 493 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
499 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 508 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
500 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 509 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
501 510
502 try 511 try
503 { 512 {
513 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
514
504 std::list<std::string> ids; 515 std::list<std::string> ids;
505 adapter->GetBackend().GetAllPublicIds(ids, resourceType); 516 adapter->GetBackend().GetAllPublicIds(ids, accessor.GetManager(), resourceType);
506 517
507 for (std::list<std::string>::const_iterator 518 for (std::list<std::string>::const_iterator
508 it = ids.begin(); it != ids.end(); ++it) 519 it = ids.begin(); it != ids.end(); ++it)
509 { 520 {
510 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), 521 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
528 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 539 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
529 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 540 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
530 541
531 try 542 try
532 { 543 {
544 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
545
533 std::list<std::string> ids; 546 std::list<std::string> ids;
534 adapter->GetBackend().GetAllPublicIds(ids, resourceType, since, limit); 547 adapter->GetBackend().GetAllPublicIds(ids, accessor.GetManager(), resourceType, since, limit);
535 548
536 for (std::list<std::string>::const_iterator 549 for (std::list<std::string>::const_iterator
537 it = ids.begin(); it != ids.end(); ++it) 550 it = ids.begin(); it != ids.end(); ++it)
538 { 551 {
539 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), 552 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
556 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 569 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
557 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change); 570 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change);
558 571
559 try 572 try
560 { 573 {
574 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
575
561 bool done; 576 bool done;
562 adapter->GetBackend().GetChanges(*output, done, since, maxResult); 577 adapter->GetBackend().GetChanges(*output, done, accessor.GetManager(), since, maxResult);
563 578
564 if (done) 579 if (done)
565 { 580 {
566 OrthancPluginDatabaseAnswerChangesDone(adapter->GetBackend().GetContext(), 581 OrthancPluginDatabaseAnswerChangesDone(adapter->GetBackend().GetContext(),
567 output->GetDatabase()); 582 output->GetDatabase());
581 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 596 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
582 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 597 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
583 598
584 try 599 try
585 { 600 {
601 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
602
586 std::list<int64_t> target; 603 std::list<int64_t> target;
587 adapter->GetBackend().GetChildrenInternalId(target, id); 604 adapter->GetBackend().GetChildrenInternalId(target, accessor.GetManager(), id);
588 605
589 for (std::list<int64_t>::const_iterator 606 for (std::list<int64_t>::const_iterator
590 it = target.begin(); it != target.end(); ++it) 607 it = target.begin(); it != target.end(); ++it)
591 { 608 {
592 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), 609 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
607 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 624 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
608 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 625 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
609 626
610 try 627 try
611 { 628 {
629 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
630
612 std::list<std::string> ids; 631 std::list<std::string> ids;
613 adapter->GetBackend().GetChildrenPublicId(ids, id); 632 adapter->GetBackend().GetChildrenPublicId(ids, accessor.GetManager(), id);
614 633
615 for (std::list<std::string>::const_iterator 634 for (std::list<std::string>::const_iterator
616 it = ids.begin(); it != ids.end(); ++it) 635 it = ids.begin(); it != ids.end(); ++it)
617 { 636 {
618 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), 637 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
635 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 654 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
636 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource); 655 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource);
637 656
638 try 657 try
639 { 658 {
659 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
660
640 bool done; 661 bool done;
641 adapter->GetBackend().GetExportedResources(*output, done, since, maxResult); 662 adapter->GetBackend().GetExportedResources(*output, done, accessor.GetManager(), since, maxResult);
642 663
643 if (done) 664 if (done)
644 { 665 {
645 OrthancPluginDatabaseAnswerExportedResourcesDone(adapter->GetBackend().GetContext(), 666 OrthancPluginDatabaseAnswerExportedResourcesDone(adapter->GetBackend().GetContext(),
646 output->GetDatabase()); 667 output->GetDatabase());
658 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 679 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
659 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change); 680 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change);
660 681
661 try 682 try
662 { 683 {
663 adapter->GetBackend().GetLastChange(*output); 684 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
685 adapter->GetBackend().GetLastChange(*output, accessor.GetManager());
664 return OrthancPluginErrorCode_Success; 686 return OrthancPluginErrorCode_Success;
665 } 687 }
666 ORTHANC_PLUGINS_DATABASE_CATCH; 688 ORTHANC_PLUGINS_DATABASE_CATCH;
667 } 689 }
668 690
674 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 696 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
675 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource); 697 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource);
676 698
677 try 699 try
678 { 700 {
679 adapter->GetBackend().GetLastExportedResource(*output); 701 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
702 adapter->GetBackend().GetLastExportedResource(*output, accessor.GetManager());
680 return OrthancPluginErrorCode_Success; 703 return OrthancPluginErrorCode_Success;
681 } 704 }
682 ORTHANC_PLUGINS_DATABASE_CATCH; 705 ORTHANC_PLUGINS_DATABASE_CATCH;
683 } 706 }
684 707
691 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 714 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
692 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_DicomTag); 715 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_DicomTag);
693 716
694 try 717 try
695 { 718 {
696 adapter->GetBackend().GetMainDicomTags(*output, id); 719 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
720 adapter->GetBackend().GetMainDicomTags(*output, accessor.GetManager(), id);
697 return OrthancPluginErrorCode_Success; 721 return OrthancPluginErrorCode_Success;
698 } 722 }
699 ORTHANC_PLUGINS_DATABASE_CATCH; 723 ORTHANC_PLUGINS_DATABASE_CATCH;
700 } 724 }
701 725
708 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 732 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
709 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 733 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
710 734
711 try 735 try
712 { 736 {
713 std::string s = adapter->GetBackend().GetPublicId(id); 737 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
738
739 std::string s = adapter->GetBackend().GetPublicId(accessor.GetManager(), id);
714 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), 740 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
715 output->GetDatabase(), 741 output->GetDatabase(),
716 s.c_str()); 742 s.c_str());
717 743
718 return OrthancPluginErrorCode_Success; 744 return OrthancPluginErrorCode_Success;
727 { 753 {
728 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 754 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
729 755
730 try 756 try
731 { 757 {
732 *target = adapter->GetBackend().GetResourcesCount(resourceType); 758 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
759 *target = adapter->GetBackend().GetResourcesCount(accessor.GetManager(), resourceType);
733 return OrthancPluginErrorCode_Success; 760 return OrthancPluginErrorCode_Success;
734 } 761 }
735 ORTHANC_PLUGINS_DATABASE_CATCH; 762 ORTHANC_PLUGINS_DATABASE_CATCH;
736 } 763 }
737 764
742 { 769 {
743 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 770 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
744 771
745 try 772 try
746 { 773 {
747 *resourceType = adapter->GetBackend().GetResourceType(id); 774 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
775 *resourceType = adapter->GetBackend().GetResourceType(accessor.GetManager(), id);
748 return OrthancPluginErrorCode_Success; 776 return OrthancPluginErrorCode_Success;
749 } 777 }
750 ORTHANC_PLUGINS_DATABASE_CATCH; 778 ORTHANC_PLUGINS_DATABASE_CATCH;
751 } 779 }
752 780
756 { 784 {
757 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 785 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
758 786
759 try 787 try
760 { 788 {
761 *target = adapter->GetBackend().GetTotalCompressedSize(); 789 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
790 *target = adapter->GetBackend().GetTotalCompressedSize(accessor.GetManager());
762 return OrthancPluginErrorCode_Success; 791 return OrthancPluginErrorCode_Success;
763 } 792 }
764 ORTHANC_PLUGINS_DATABASE_CATCH; 793 ORTHANC_PLUGINS_DATABASE_CATCH;
765 } 794 }
766 795
770 { 799 {
771 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 800 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
772 801
773 try 802 try
774 { 803 {
775 *target = adapter->GetBackend().GetTotalUncompressedSize(); 804 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
805 *target = adapter->GetBackend().GetTotalUncompressedSize(accessor.GetManager());
776 return OrthancPluginErrorCode_Success; 806 return OrthancPluginErrorCode_Success;
777 } 807 }
778 ORTHANC_PLUGINS_DATABASE_CATCH; 808 ORTHANC_PLUGINS_DATABASE_CATCH;
779 } 809 }
780 810
785 { 815 {
786 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 816 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
787 817
788 try 818 try
789 { 819 {
790 *existing = adapter->GetBackend().IsExistingResource(id); 820 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
821 *existing = adapter->GetBackend().IsExistingResource(accessor.GetManager(), id);
791 return OrthancPluginErrorCode_Success; 822 return OrthancPluginErrorCode_Success;
792 } 823 }
793 ORTHANC_PLUGINS_DATABASE_CATCH; 824 ORTHANC_PLUGINS_DATABASE_CATCH;
794 } 825 }
795 826
800 { 831 {
801 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 832 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
802 833
803 try 834 try
804 { 835 {
805 *isProtected = adapter->GetBackend().IsProtectedPatient(id); 836 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
837 *isProtected = adapter->GetBackend().IsProtectedPatient(accessor.GetManager(), id);
806 return OrthancPluginErrorCode_Success; 838 return OrthancPluginErrorCode_Success;
807 } 839 }
808 ORTHANC_PLUGINS_DATABASE_CATCH; 840 ORTHANC_PLUGINS_DATABASE_CATCH;
809 } 841 }
810 842
817 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 849 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
818 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 850 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
819 851
820 try 852 try
821 { 853 {
854 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
855
822 std::list<int32_t> target; 856 std::list<int32_t> target;
823 adapter->GetBackend().ListAvailableMetadata(target, id); 857 adapter->GetBackend().ListAvailableMetadata(target, accessor.GetManager(), id);
824 858
825 for (std::list<int32_t>::const_iterator 859 for (std::list<int32_t>::const_iterator
826 it = target.begin(); it != target.end(); ++it) 860 it = target.begin(); it != target.end(); ++it)
827 { 861 {
828 OrthancPluginDatabaseAnswerInt32(adapter->GetBackend().GetContext(), 862 OrthancPluginDatabaseAnswerInt32(adapter->GetBackend().GetContext(),
844 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 878 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
845 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 879 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
846 880
847 try 881 try
848 { 882 {
883 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
884
849 std::list<int32_t> target; 885 std::list<int32_t> target;
850 adapter->GetBackend().ListAvailableAttachments(target, id); 886 adapter->GetBackend().ListAvailableAttachments(target, accessor.GetManager(), id);
851 887
852 for (std::list<int32_t>::const_iterator 888 for (std::list<int32_t>::const_iterator
853 it = target.begin(); it != target.end(); ++it) 889 it = target.begin(); it != target.end(); ++it)
854 { 890 {
855 OrthancPluginDatabaseAnswerInt32(adapter->GetBackend().GetContext(), 891 OrthancPluginDatabaseAnswerInt32(adapter->GetBackend().GetContext(),
868 { 904 {
869 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 905 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
870 906
871 try 907 try
872 { 908 {
909 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
910
873 int64_t id; 911 int64_t id;
874 OrthancPluginResourceType type; 912 OrthancPluginResourceType type;
875 if (!adapter->GetBackend().LookupResource(id, type, change->publicId) || 913 if (!adapter->GetBackend().LookupResource(id, type, accessor.GetManager(), change->publicId) ||
876 type != change->resourceType) 914 type != change->resourceType)
877 { 915 {
878 throw Orthanc::OrthancException(Orthanc::ErrorCode_Database); 916 throw Orthanc::OrthancException(Orthanc::ErrorCode_Database);
879 } 917 }
880 else 918 else
881 { 919 {
882 adapter->GetBackend().LogChange(change->changeType, id, type, change->date); 920 adapter->GetBackend().LogChange(accessor.GetManager(), change->changeType, id, type, change->date);
883 } 921 }
884 922
885 return OrthancPluginErrorCode_Success; 923 return OrthancPluginErrorCode_Success;
886 } 924 }
887 ORTHANC_PLUGINS_DATABASE_CATCH; 925 ORTHANC_PLUGINS_DATABASE_CATCH;
893 { 931 {
894 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 932 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
895 933
896 try 934 try
897 { 935 {
898 adapter->GetBackend().LogExportedResource(*exported); 936 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
937 adapter->GetBackend().LogExportedResource(accessor.GetManager(), *exported);
899 return OrthancPluginErrorCode_Success; 938 return OrthancPluginErrorCode_Success;
900 } 939 }
901 ORTHANC_PLUGINS_DATABASE_CATCH; 940 ORTHANC_PLUGINS_DATABASE_CATCH;
902 } 941 }
903 942
911 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 950 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
912 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Attachment); 951 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Attachment);
913 952
914 try 953 try
915 { 954 {
916 adapter->GetBackend().LookupAttachment(*output, id, contentType); 955 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
956 adapter->GetBackend().LookupAttachment(*output, accessor.GetManager(), id, contentType);
917 return OrthancPluginErrorCode_Success; 957 return OrthancPluginErrorCode_Success;
918 } 958 }
919 ORTHANC_PLUGINS_DATABASE_CATCH; 959 ORTHANC_PLUGINS_DATABASE_CATCH;
920 } 960 }
921 961
928 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 968 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
929 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 969 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
930 970
931 try 971 try
932 { 972 {
973 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
974
933 std::string s; 975 std::string s;
934 if (adapter->GetBackend().LookupGlobalProperty(s, MISSING_SERVER_IDENTIFIER, property)) 976 if (adapter->GetBackend().LookupGlobalProperty(s, accessor.GetManager(), MISSING_SERVER_IDENTIFIER, property))
935 { 977 {
936 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), 978 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
937 output->GetDatabase(), 979 output->GetDatabase(),
938 s.c_str()); 980 s.c_str());
939 } 981 }
954 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 996 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
955 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 997 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
956 998
957 try 999 try
958 { 1000 {
1001 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1002
959 std::list<int64_t> target; 1003 std::list<int64_t> target;
960 adapter->GetBackend().LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value); 1004 adapter->GetBackend().LookupIdentifier(target, accessor.GetManager(), resourceType,
1005 tag->group, tag->element, constraint, tag->value);
961 1006
962 for (std::list<int64_t>::const_iterator 1007 for (std::list<int64_t>::const_iterator
963 it = target.begin(); it != target.end(); ++it) 1008 it = target.begin(); it != target.end(); ++it)
964 { 1009 {
965 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), 1010 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
984 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1029 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
985 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1030 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
986 1031
987 try 1032 try
988 { 1033 {
1034 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1035
989 std::list<int64_t> target; 1036 std::list<int64_t> target;
990 adapter->GetBackend().LookupIdentifierRange(target, resourceType, group, element, start, end); 1037 adapter->GetBackend().LookupIdentifierRange(target, accessor.GetManager(), resourceType, group, element, start, end);
991 1038
992 for (std::list<int64_t>::const_iterator 1039 for (std::list<int64_t>::const_iterator
993 it = target.begin(); it != target.end(); ++it) 1040 it = target.begin(); it != target.end(); ++it)
994 { 1041 {
995 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), 1042 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
1011 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1058 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1012 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1059 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
1013 1060
1014 try 1061 try
1015 { 1062 {
1063 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1064
1016 std::string s; 1065 std::string s;
1017 if (adapter->GetBackend().LookupMetadata(s, id, metadata)) 1066 if (adapter->GetBackend().LookupMetadata(s, accessor.GetManager(), id, metadata))
1018 { 1067 {
1019 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), 1068 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
1020 output->GetDatabase(), s.c_str()); 1069 output->GetDatabase(), s.c_str());
1021 } 1070 }
1022 1071
1034 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1083 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1035 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1084 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
1036 1085
1037 try 1086 try
1038 { 1087 {
1088 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1089
1039 int64_t parent; 1090 int64_t parent;
1040 if (adapter->GetBackend().LookupParent(parent, id)) 1091 if (adapter->GetBackend().LookupParent(parent, accessor.GetManager(), id))
1041 { 1092 {
1042 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), 1093 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
1043 output->GetDatabase(), parent); 1094 output->GetDatabase(), parent);
1044 } 1095 }
1045 1096
1057 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1108 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1058 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1109 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
1059 1110
1060 try 1111 try
1061 { 1112 {
1113 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1114
1062 int64_t id; 1115 int64_t id;
1063 OrthancPluginResourceType type; 1116 OrthancPluginResourceType type;
1064 if (adapter->GetBackend().LookupResource(id, type, publicId)) 1117 if (adapter->GetBackend().LookupResource(id, type, accessor.GetManager(), publicId))
1065 { 1118 {
1066 OrthancPluginDatabaseAnswerResource(adapter->GetBackend().GetContext(), 1119 OrthancPluginDatabaseAnswerResource(adapter->GetBackend().GetContext(),
1067 output->GetDatabase(), 1120 output->GetDatabase(),
1068 id, type); 1121 id, type);
1069 } 1122 }
1081 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1134 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1082 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1135 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
1083 1136
1084 try 1137 try
1085 { 1138 {
1139 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1140
1086 int64_t id; 1141 int64_t id;
1087 if (adapter->GetBackend().SelectPatientToRecycle(id)) 1142 if (adapter->GetBackend().SelectPatientToRecycle(id, accessor.GetManager()))
1088 { 1143 {
1089 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), 1144 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
1090 output->GetDatabase(), id); 1145 output->GetDatabase(), id);
1091 } 1146 }
1092 1147
1104 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1159 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1105 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1160 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
1106 1161
1107 try 1162 try
1108 { 1163 {
1164 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1165
1109 int64_t id; 1166 int64_t id;
1110 if (adapter->GetBackend().SelectPatientToRecycle(id, patientIdToAvoid)) 1167 if (adapter->GetBackend().SelectPatientToRecycle(id, accessor.GetManager(), patientIdToAvoid))
1111 { 1168 {
1112 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(), 1169 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
1113 output->GetDatabase(), id); 1170 output->GetDatabase(), id);
1114 } 1171 }
1115 1172
1125 { 1182 {
1126 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1183 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1127 1184
1128 try 1185 try
1129 { 1186 {
1130 adapter->GetBackend().SetGlobalProperty(MISSING_SERVER_IDENTIFIER, property, value); 1187 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1188 adapter->GetBackend().SetGlobalProperty(accessor.GetManager(), MISSING_SERVER_IDENTIFIER, property, value);
1131 return OrthancPluginErrorCode_Success; 1189 return OrthancPluginErrorCode_Success;
1132 } 1190 }
1133 ORTHANC_PLUGINS_DATABASE_CATCH; 1191 ORTHANC_PLUGINS_DATABASE_CATCH;
1134 } 1192 }
1135 1193
1140 { 1198 {
1141 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1199 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1142 1200
1143 try 1201 try
1144 { 1202 {
1145 adapter->GetBackend().SetMainDicomTag(id, tag->group, tag->element, tag->value); 1203 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1204 adapter->GetBackend().SetMainDicomTag(accessor.GetManager(), id, tag->group, tag->element, tag->value);
1146 return OrthancPluginErrorCode_Success; 1205 return OrthancPluginErrorCode_Success;
1147 } 1206 }
1148 ORTHANC_PLUGINS_DATABASE_CATCH; 1207 ORTHANC_PLUGINS_DATABASE_CATCH;
1149 } 1208 }
1150 1209
1155 { 1214 {
1156 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1215 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1157 1216
1158 try 1217 try
1159 { 1218 {
1160 adapter->GetBackend().SetIdentifierTag(id, tag->group, tag->element, tag->value); 1219 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1220 adapter->GetBackend().SetIdentifierTag(accessor.GetManager(), id, tag->group, tag->element, tag->value);
1161 return OrthancPluginErrorCode_Success; 1221 return OrthancPluginErrorCode_Success;
1162 } 1222 }
1163 ORTHANC_PLUGINS_DATABASE_CATCH; 1223 ORTHANC_PLUGINS_DATABASE_CATCH;
1164 } 1224 }
1165 1225
1171 { 1231 {
1172 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1232 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1173 1233
1174 try 1234 try
1175 { 1235 {
1176 adapter->GetBackend().SetMetadata(id, metadata, value); 1236 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1237 adapter->GetBackend().SetMetadata(accessor.GetManager(), id, metadata, value);
1177 return OrthancPluginErrorCode_Success; 1238 return OrthancPluginErrorCode_Success;
1178 } 1239 }
1179 ORTHANC_PLUGINS_DATABASE_CATCH; 1240 ORTHANC_PLUGINS_DATABASE_CATCH;
1180 } 1241 }
1181 1242
1186 { 1247 {
1187 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1248 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1188 1249
1189 try 1250 try
1190 { 1251 {
1191 adapter->GetBackend().SetProtectedPatient(id, (isProtected != 0)); 1252 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1253 adapter->GetBackend().SetProtectedPatient(accessor.GetManager(), id, (isProtected != 0));
1192 return OrthancPluginErrorCode_Success; 1254 return OrthancPluginErrorCode_Success;
1193 } 1255 }
1194 ORTHANC_PLUGINS_DATABASE_CATCH; 1256 ORTHANC_PLUGINS_DATABASE_CATCH;
1195 } 1257 }
1196 1258
1199 { 1261 {
1200 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1262 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1201 1263
1202 try 1264 try
1203 { 1265 {
1204 adapter->GetBackend().StartTransaction(TransactionType_ReadWrite); 1266 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1267 accessor.GetManager().StartTransaction(TransactionType_ReadWrite);
1205 return OrthancPluginErrorCode_Success; 1268 return OrthancPluginErrorCode_Success;
1206 } 1269 }
1207 ORTHANC_PLUGINS_DATABASE_CATCH; 1270 ORTHANC_PLUGINS_DATABASE_CATCH;
1208 } 1271 }
1209 1272
1212 { 1275 {
1213 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1276 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1214 1277
1215 try 1278 try
1216 { 1279 {
1217 adapter->GetBackend().RollbackTransaction(); 1280 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1281 accessor.GetManager().RollbackTransaction();
1218 return OrthancPluginErrorCode_Success; 1282 return OrthancPluginErrorCode_Success;
1219 } 1283 }
1220 ORTHANC_PLUGINS_DATABASE_CATCH; 1284 ORTHANC_PLUGINS_DATABASE_CATCH;
1221 } 1285 }
1222 1286
1225 { 1289 {
1226 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1290 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1227 1291
1228 try 1292 try
1229 { 1293 {
1230 adapter->GetBackend().CommitTransaction(); 1294 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1295 accessor.GetManager().CommitTransaction();
1231 return OrthancPluginErrorCode_Success; 1296 return OrthancPluginErrorCode_Success;
1232 } 1297 }
1233 ORTHANC_PLUGINS_DATABASE_CATCH; 1298 ORTHANC_PLUGINS_DATABASE_CATCH;
1234 } 1299 }
1235 1300
1238 { 1303 {
1239 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1304 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1240 1305
1241 try 1306 try
1242 { 1307 {
1243 //adapter->OpenConnection(); // TODO 1308 adapter->OpenConnection();
1244 adapter->GetBackend().Open();
1245 return OrthancPluginErrorCode_Success; 1309 return OrthancPluginErrorCode_Success;
1246 } 1310 }
1247 ORTHANC_PLUGINS_DATABASE_CATCH; 1311 ORTHANC_PLUGINS_DATABASE_CATCH;
1248 } 1312 }
1249 1313
1252 { 1316 {
1253 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1317 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1254 1318
1255 try 1319 try
1256 { 1320 {
1257 adapter->GetBackend().Close(); 1321 adapter->CloseConnection();
1258 //adapter->CloseConnection(); // TODO
1259 return OrthancPluginErrorCode_Success; 1322 return OrthancPluginErrorCode_Success;
1260 } 1323 }
1261 ORTHANC_PLUGINS_DATABASE_CATCH; 1324 ORTHANC_PLUGINS_DATABASE_CATCH;
1262 } 1325 }
1263 1326
1267 { 1330 {
1268 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1331 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1269 1332
1270 try 1333 try
1271 { 1334 {
1272 *version = adapter->GetBackend().GetDatabaseVersion(); 1335 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1336 *version = adapter->GetBackend().GetDatabaseVersion(accessor.GetManager());
1273 return OrthancPluginErrorCode_Success; 1337 return OrthancPluginErrorCode_Success;
1274 } 1338 }
1275 ORTHANC_PLUGINS_DATABASE_CATCH; 1339 ORTHANC_PLUGINS_DATABASE_CATCH;
1276 } 1340 }
1277 1341
1282 { 1346 {
1283 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1347 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1284 1348
1285 try 1349 try
1286 { 1350 {
1287 adapter->GetBackend().UpgradeDatabase(targetVersion, storageArea); 1351 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1352 adapter->GetBackend().UpgradeDatabase(accessor.GetManager(), targetVersion, storageArea);
1288 return OrthancPluginErrorCode_Success; 1353 return OrthancPluginErrorCode_Success;
1289 } 1354 }
1290 ORTHANC_PLUGINS_DATABASE_CATCH; 1355 ORTHANC_PLUGINS_DATABASE_CATCH;
1291 } 1356 }
1292 1357
1296 { 1361 {
1297 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1362 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1298 1363
1299 try 1364 try
1300 { 1365 {
1301 adapter->GetBackend().ClearMainDicomTags(internalId); 1366 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1367 adapter->GetBackend().ClearMainDicomTags(accessor.GetManager(), internalId);
1302 return OrthancPluginErrorCode_Success; 1368 return OrthancPluginErrorCode_Success;
1303 } 1369 }
1304 ORTHANC_PLUGINS_DATABASE_CATCH; 1370 ORTHANC_PLUGINS_DATABASE_CATCH;
1305 } 1371 }
1306 1372
1320 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1386 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1321 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_MatchingResource); 1387 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_MatchingResource);
1322 1388
1323 try 1389 try
1324 { 1390 {
1391 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1392
1325 std::vector<Orthanc::DatabaseConstraint> lookup; 1393 std::vector<Orthanc::DatabaseConstraint> lookup;
1326 lookup.reserve(constraintsCount); 1394 lookup.reserve(constraintsCount);
1327 1395
1328 for (uint32_t i = 0; i < constraintsCount; i++) 1396 for (uint32_t i = 0; i < constraintsCount; i++)
1329 { 1397 {
1330 lookup.push_back(Orthanc::DatabaseConstraint(constraints[i])); 1398 lookup.push_back(Orthanc::DatabaseConstraint(constraints[i]));
1331 } 1399 }
1332 1400
1333 adapter->GetBackend().LookupResources(*output, lookup, queryLevel, limit, (requestSomeInstance != 0)); 1401 adapter->GetBackend().LookupResources(*output, accessor.GetManager(), lookup, queryLevel, limit, (requestSomeInstance != 0));
1334 return OrthancPluginErrorCode_Success; 1402 return OrthancPluginErrorCode_Success;
1335 } 1403 }
1336 ORTHANC_PLUGINS_DATABASE_CATCH; 1404 ORTHANC_PLUGINS_DATABASE_CATCH;
1337 } 1405 }
1338 #endif 1406 #endif
1348 { 1416 {
1349 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1417 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1350 1418
1351 try 1419 try
1352 { 1420 {
1353 adapter->GetBackend().CreateInstance(*target, hashPatient, hashStudy, hashSeries, hashInstance); 1421 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1422 adapter->GetBackend().CreateInstance(*target, accessor.GetManager(), hashPatient, hashStudy, hashSeries, hashInstance);
1354 return OrthancPluginErrorCode_Success; 1423 return OrthancPluginErrorCode_Success;
1355 } 1424 }
1356 ORTHANC_PLUGINS_DATABASE_CATCH; 1425 ORTHANC_PLUGINS_DATABASE_CATCH;
1357 } 1426 }
1358 #endif 1427 #endif
1370 { 1439 {
1371 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1440 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1372 1441
1373 try 1442 try
1374 { 1443 {
1375 adapter->GetBackend().SetResourcesContent(countIdentifierTags, identifierTags, 1444 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1376 countMainDicomTags, mainDicomTags, 1445 adapter->GetBackend().SetResourcesContent(accessor.GetManager(), countIdentifierTags, identifierTags,
1377 countMetadata, metadata); 1446 countMainDicomTags, mainDicomTags, countMetadata, metadata);
1378 return OrthancPluginErrorCode_Success; 1447 return OrthancPluginErrorCode_Success;
1379 } 1448 }
1380 ORTHANC_PLUGINS_DATABASE_CATCH; 1449 ORTHANC_PLUGINS_DATABASE_CATCH;
1381 } 1450 }
1382 #endif 1451 #endif
1392 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1461 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1393 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1462 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
1394 1463
1395 try 1464 try
1396 { 1465 {
1466 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1467
1397 std::list<std::string> values; 1468 std::list<std::string> values;
1398 adapter->GetBackend().GetChildrenMetadata(values, resourceId, metadata); 1469 adapter->GetBackend().GetChildrenMetadata(values, accessor.GetManager(), resourceId, metadata);
1399 1470
1400 for (std::list<std::string>::const_iterator 1471 for (std::list<std::string>::const_iterator
1401 it = values.begin(); it != values.end(); ++it) 1472 it = values.begin(); it != values.end(); ++it)
1402 { 1473 {
1403 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(), 1474 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
1417 { 1488 {
1418 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1489 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1419 1490
1420 try 1491 try
1421 { 1492 {
1422 *result = adapter->GetBackend().GetLastChangeIndex(); 1493 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1494 *result = adapter->GetBackend().GetLastChangeIndex(accessor.GetManager());
1423 return OrthancPluginErrorCode_Success; 1495 return OrthancPluginErrorCode_Success;
1424 } 1496 }
1425 ORTHANC_PLUGINS_DATABASE_CATCH; 1497 ORTHANC_PLUGINS_DATABASE_CATCH;
1426 } 1498 }
1427 1499
1432 { 1504 {
1433 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload); 1505 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1434 1506
1435 try 1507 try
1436 { 1508 {
1437 adapter->GetBackend().TagMostRecentPatient(patientId); 1509 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1510 adapter->GetBackend().TagMostRecentPatient(accessor.GetManager(), patientId);
1438 return OrthancPluginErrorCode_Success; 1511 return OrthancPluginErrorCode_Success;
1439 } 1512 }
1440 ORTHANC_PLUGINS_DATABASE_CATCH; 1513 ORTHANC_PLUGINS_DATABASE_CATCH;
1441 } 1514 }
1442 1515
1452 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1525 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1453 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Metadata); 1526 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Metadata);
1454 1527
1455 try 1528 try
1456 { 1529 {
1530 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1531
1457 std::map<int32_t, std::string> result; 1532 std::map<int32_t, std::string> result;
1458 adapter->GetBackend().GetAllMetadata(result, resourceId); 1533 adapter->GetBackend().GetAllMetadata(result, accessor.GetManager(), resourceId);
1459 1534
1460 for (std::map<int32_t, std::string>::const_iterator 1535 for (std::map<int32_t, std::string>::const_iterator
1461 it = result.begin(); it != result.end(); ++it) 1536 it = result.begin(); it != result.end(); ++it)
1462 { 1537 {
1463 OrthancPluginDatabaseAnswerMetadata(adapter->GetBackend().GetContext(), 1538 OrthancPluginDatabaseAnswerMetadata(adapter->GetBackend().GetContext(),
1487 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput())); 1562 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1488 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_String); 1563 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_String);
1489 1564
1490 try 1565 try
1491 { 1566 {
1567 DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter);
1568
1492 std::string parent; 1569 std::string parent;
1493 if (adapter->GetBackend().LookupResourceAndParent(*id, *type, parent, publicId)) 1570 if (adapter->GetBackend().LookupResourceAndParent(*id, *type, parent, accessor.GetManager(), publicId))
1494 { 1571 {
1495 *isExisting = 1; 1572 *isExisting = 1;
1496 1573
1497 if (!parent.empty()) 1574 if (!parent.empty())
1498 { 1575 {