Mercurial > hg > orthanc-databases
comparison Framework/Plugins/DatabaseBackendAdapterV3.cpp @ 225:94c9908e6aca
removed DatabaseManager member out of class IndexBackend
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 01 Apr 2021 19:18:19 +0200 |
parents | af049cd66661 |
children | a4918d57435c |
comparison
equal
deleted
inserted
replaced
224:61c309e06797 | 225:94c9908e6aca |
---|---|
54 | 54 |
55 namespace OrthancDatabases | 55 namespace OrthancDatabases |
56 { | 56 { |
57 static bool isBackendInUse_ = false; // Only for sanity checks | 57 static bool isBackendInUse_ = false; // Only for sanity checks |
58 | 58 |
59 | |
60 // TODO - TURN THIS INTO A CONNECTION POOL | |
61 class DatabaseBackendAdapterV3::Adapter : public boost::noncopyable | |
62 { | |
63 private: | |
64 std::unique_ptr<IndexBackend> backend_; | |
65 boost::mutex managerMutex_; | |
66 std::unique_ptr<DatabaseManager> manager_; | |
67 | |
68 public: | |
69 Adapter(IndexBackend* backend) : | |
70 backend_(backend) | |
71 { | |
72 if (backend == NULL) | |
73 { | |
74 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | |
75 } | |
76 } | |
77 | |
78 IndexBackend& GetBackend() const | |
79 { | |
80 return *backend_; | |
81 } | |
82 | |
83 void OpenConnection() | |
84 { | |
85 boost::mutex::scoped_lock lock(managerMutex_); | |
86 | |
87 if (manager_.get() == NULL) | |
88 { | |
89 manager_.reset(new DatabaseManager(backend_->CreateDatabaseFactory())); | |
90 manager_->Open(); | |
91 } | |
92 else | |
93 { | |
94 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
95 } | |
96 } | |
97 | |
98 void CloseConnection() | |
99 { | |
100 boost::mutex::scoped_lock lock(managerMutex_); | |
101 | |
102 if (manager_.get() == NULL) | |
103 { | |
104 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
105 } | |
106 else | |
107 { | |
108 manager_->Close(); | |
109 manager_.reset(NULL); | |
110 } | |
111 } | |
112 | |
113 class DatabaseAccessor : public boost::noncopyable | |
114 { | |
115 private: | |
116 boost::mutex::scoped_lock lock_; | |
117 DatabaseManager* manager_; | |
118 | |
119 public: | |
120 DatabaseAccessor(Adapter& adapter) : | |
121 lock_(adapter.managerMutex_), | |
122 manager_(adapter.manager_.get()) | |
123 { | |
124 if (manager_ == NULL) | |
125 { | |
126 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
127 } | |
128 } | |
129 | |
130 DatabaseManager& GetManager() const | |
131 { | |
132 assert(manager_ != NULL); | |
133 return *manager_; | |
134 } | |
135 }; | |
136 }; | |
137 | |
138 | |
59 class DatabaseBackendAdapterV3::Output : public IDatabaseBackendOutput | 139 class DatabaseBackendAdapterV3::Output : public IDatabaseBackendOutput |
60 { | 140 { |
61 private: | 141 private: |
62 struct Metadata | 142 struct Metadata |
63 { | 143 { |
614 | 694 |
615 | 695 |
616 class DatabaseBackendAdapterV3::Transaction : public boost::noncopyable | 696 class DatabaseBackendAdapterV3::Transaction : public boost::noncopyable |
617 { | 697 { |
618 private: | 698 private: |
619 boost::mutex::scoped_lock lock_; // TODO - REMOVE | 699 Adapter& adapter_; |
620 IndexBackend& backend_; | 700 std::unique_ptr<Adapter::DatabaseAccessor> accessor_; |
621 std::unique_ptr<Output> output_; | 701 std::unique_ptr<Output> output_; |
622 | 702 |
623 static boost::mutex& GetMutex() // TODO - REMOVE | |
624 { | |
625 static boost::mutex mutex_; | |
626 return mutex_; | |
627 } | |
628 | |
629 public: | 703 public: |
630 Transaction(IndexBackend& backend) : | 704 Transaction(Adapter& adapter) : |
631 lock_(GetMutex()), | 705 adapter_(adapter), |
632 backend_(backend), | 706 accessor_(new Adapter::DatabaseAccessor(adapter)), |
633 output_(new Output) | 707 output_(new Output) |
634 { | 708 { |
635 } | 709 } |
636 | 710 |
637 ~Transaction() | 711 ~Transaction() |
638 { | 712 { |
639 } | 713 } |
640 | 714 |
641 IndexBackend& GetBackend() const | 715 IndexBackend& GetBackend() const |
642 { | 716 { |
643 return backend_; | 717 return adapter_.GetBackend(); |
644 } | 718 } |
645 | 719 |
646 Output& GetOutput() const | 720 Output& GetOutput() const |
647 { | 721 { |
648 return *output_; | 722 return *output_; |
649 } | 723 } |
650 | 724 |
651 OrthancPluginContext* GetContext() const | 725 DatabaseManager& GetManager() const |
652 { | 726 { |
653 return backend_.GetContext(); | 727 return accessor_->GetManager(); |
654 } | 728 } |
655 }; | 729 }; |
656 | 730 |
657 | 731 |
658 static OrthancPluginErrorCode ReadAnswersCount(OrthancPluginDatabaseTransaction* transaction, | 732 static OrthancPluginErrorCode ReadAnswersCount(OrthancPluginDatabaseTransaction* transaction, |
779 } | 853 } |
780 | 854 |
781 | 855 |
782 static OrthancPluginErrorCode Open(void* database) | 856 static OrthancPluginErrorCode Open(void* database) |
783 { | 857 { |
784 IndexBackend* backend = reinterpret_cast<IndexBackend*>(database); | 858 DatabaseBackendAdapterV3::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV3::Adapter*>(database); |
785 | 859 |
786 try | 860 try |
787 { | 861 { |
788 backend->Open(); | 862 adapter->OpenConnection(); |
789 return OrthancPluginErrorCode_Success; | 863 return OrthancPluginErrorCode_Success; |
790 } | 864 } |
791 ORTHANC_PLUGINS_DATABASE_CATCH(backend->GetContext()); | 865 ORTHANC_PLUGINS_DATABASE_CATCH(adapter->GetBackend().GetContext()); |
792 } | 866 } |
793 | 867 |
794 | 868 |
795 static OrthancPluginErrorCode Close(void* database) | 869 static OrthancPluginErrorCode Close(void* database) |
796 { | 870 { |
797 IndexBackend* backend = reinterpret_cast<IndexBackend*>(database); | 871 DatabaseBackendAdapterV3::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV3::Adapter*>(database); |
798 | 872 |
799 try | 873 try |
800 { | 874 { |
801 backend->Close(); | 875 adapter->CloseConnection(); |
802 return OrthancPluginErrorCode_Success; | 876 return OrthancPluginErrorCode_Success; |
803 } | 877 } |
804 ORTHANC_PLUGINS_DATABASE_CATCH(backend->GetContext()); | 878 ORTHANC_PLUGINS_DATABASE_CATCH(adapter->GetBackend().GetContext()); |
805 } | 879 } |
806 | 880 |
807 | 881 |
808 static OrthancPluginErrorCode DestructDatabase(void* database) | 882 static OrthancPluginErrorCode DestructDatabase(void* database) |
809 { | 883 { |
810 IndexBackend* backend = reinterpret_cast<IndexBackend*>(database); | 884 DatabaseBackendAdapterV3::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV3::Adapter*>(database); |
811 | 885 |
812 if (backend == NULL) | 886 if (adapter == NULL) |
813 { | 887 { |
814 return OrthancPluginErrorCode_InternalError; | 888 return OrthancPluginErrorCode_InternalError; |
815 } | 889 } |
816 else | 890 else |
817 { | 891 { |
819 { | 893 { |
820 isBackendInUse_ = false; | 894 isBackendInUse_ = false; |
821 } | 895 } |
822 else | 896 else |
823 { | 897 { |
824 OrthancPluginLogError(backend->GetContext(), "More than one index backend was registered, internal error"); | 898 OrthancPluginLogError(adapter->GetBackend().GetContext(), "More than one index backend was registered, internal error"); |
825 } | 899 } |
826 | 900 |
827 delete backend; | 901 delete adapter; |
828 | 902 |
829 return OrthancPluginErrorCode_Success; | 903 return OrthancPluginErrorCode_Success; |
830 } | 904 } |
831 } | 905 } |
832 | 906 |
833 | 907 |
834 static OrthancPluginErrorCode GetDatabaseVersion(void* database, | 908 static OrthancPluginErrorCode GetDatabaseVersion(void* database, |
835 uint32_t* version) | 909 uint32_t* version) |
836 { | 910 { |
837 IndexBackend* backend = reinterpret_cast<IndexBackend*>(database); | 911 DatabaseBackendAdapterV3::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV3::Adapter*>(database); |
838 | 912 |
839 try | 913 try |
840 { | 914 { |
841 *version = backend->GetDatabaseVersion(); | 915 DatabaseBackendAdapterV3::Adapter::DatabaseAccessor accessor(*adapter); |
842 return OrthancPluginErrorCode_Success; | 916 *version = adapter->GetBackend().GetDatabaseVersion(accessor.GetManager()); |
843 } | 917 return OrthancPluginErrorCode_Success; |
844 ORTHANC_PLUGINS_DATABASE_CATCH(backend->GetContext()); | 918 } |
919 ORTHANC_PLUGINS_DATABASE_CATCH(adapter->GetBackend().GetContext()); | |
845 } | 920 } |
846 | 921 |
847 | 922 |
848 static OrthancPluginErrorCode UpgradeDatabase(void* database, | 923 static OrthancPluginErrorCode UpgradeDatabase(void* database, |
849 OrthancPluginStorageArea* storageArea, | 924 OrthancPluginStorageArea* storageArea, |
850 uint32_t targetVersion) | 925 uint32_t targetVersion) |
851 { | 926 { |
852 IndexBackend* backend = reinterpret_cast<IndexBackend*>(database); | 927 DatabaseBackendAdapterV3::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV3::Adapter*>(database); |
853 | 928 |
854 try | 929 try |
855 { | 930 { |
856 backend->UpgradeDatabase(targetVersion, storageArea); | 931 DatabaseBackendAdapterV3::Adapter::DatabaseAccessor accessor(*adapter); |
857 return OrthancPluginErrorCode_Success; | 932 adapter->GetBackend().UpgradeDatabase(accessor.GetManager(), targetVersion, storageArea); |
858 } | 933 return OrthancPluginErrorCode_Success; |
859 ORTHANC_PLUGINS_DATABASE_CATCH(backend->GetContext()); | 934 } |
935 ORTHANC_PLUGINS_DATABASE_CATCH(adapter->GetBackend().GetContext()); | |
860 } | 936 } |
861 | 937 |
862 | 938 |
863 static OrthancPluginErrorCode StartTransaction(void* database, | 939 static OrthancPluginErrorCode StartTransaction(void* database, |
864 OrthancPluginDatabaseTransaction** target /* out */, | 940 OrthancPluginDatabaseTransaction** target /* out */, |
865 OrthancPluginDatabaseTransactionType type) | 941 OrthancPluginDatabaseTransactionType type) |
866 { | 942 { |
867 IndexBackend* backend = reinterpret_cast<IndexBackend*>(database); | 943 DatabaseBackendAdapterV3::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV3::Adapter*>(database); |
868 | 944 |
869 try | 945 try |
870 { | 946 { |
871 std::unique_ptr<DatabaseBackendAdapterV3::Transaction> transaction(new DatabaseBackendAdapterV3::Transaction(*backend)); | 947 std::unique_ptr<DatabaseBackendAdapterV3::Transaction> transaction(new DatabaseBackendAdapterV3::Transaction(*adapter)); |
872 | 948 |
873 switch (type) | 949 switch (type) |
874 { | 950 { |
875 case OrthancPluginDatabaseTransactionType_ReadOnly: | 951 case OrthancPluginDatabaseTransactionType_ReadOnly: |
876 backend->StartTransaction(TransactionType_ReadOnly); | 952 transaction->GetManager().StartTransaction(TransactionType_ReadOnly); |
877 break; | 953 break; |
878 | 954 |
879 case OrthancPluginDatabaseTransactionType_ReadWrite: | 955 case OrthancPluginDatabaseTransactionType_ReadWrite: |
880 backend->StartTransaction(TransactionType_ReadWrite); | 956 transaction->GetManager().StartTransaction(TransactionType_ReadWrite); |
881 break; | 957 break; |
882 | 958 |
883 default: | 959 default: |
884 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | 960 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); |
885 } | 961 } |
886 | 962 |
887 *target = reinterpret_cast<OrthancPluginDatabaseTransaction*>(transaction.release()); | 963 *target = reinterpret_cast<OrthancPluginDatabaseTransaction*>(transaction.release()); |
888 | 964 |
889 return OrthancPluginErrorCode_Success; | 965 return OrthancPluginErrorCode_Success; |
890 } | 966 } |
891 ORTHANC_PLUGINS_DATABASE_CATCH(backend->GetContext()); | 967 ORTHANC_PLUGINS_DATABASE_CATCH(adapter->GetBackend().GetContext()); |
892 } | 968 } |
893 | 969 |
894 | 970 |
895 static OrthancPluginErrorCode DestructTransaction(OrthancPluginDatabaseTransaction* transaction) | 971 static OrthancPluginErrorCode DestructTransaction(OrthancPluginDatabaseTransaction* transaction) |
896 { | 972 { |
911 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 987 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
912 | 988 |
913 try | 989 try |
914 { | 990 { |
915 t->GetOutput().Clear(); | 991 t->GetOutput().Clear(); |
916 t->GetBackend().RollbackTransaction(); | 992 t->GetManager().RollbackTransaction(); |
917 return OrthancPluginErrorCode_Success; | 993 return OrthancPluginErrorCode_Success; |
918 } | 994 } |
919 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 995 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
920 } | 996 } |
921 | 997 |
922 | 998 |
923 static OrthancPluginErrorCode Commit(OrthancPluginDatabaseTransaction* transaction, | 999 static OrthancPluginErrorCode Commit(OrthancPluginDatabaseTransaction* transaction, |
924 int64_t fileSizeDelta /* TODO - not used? */) | 1000 int64_t fileSizeDelta /* TODO - not used? */) |
926 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1002 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
927 | 1003 |
928 try | 1004 try |
929 { | 1005 { |
930 t->GetOutput().Clear(); | 1006 t->GetOutput().Clear(); |
931 t->GetBackend().CommitTransaction(); | 1007 t->GetManager().CommitTransaction(); |
932 return OrthancPluginErrorCode_Success; | 1008 return OrthancPluginErrorCode_Success; |
933 } | 1009 } |
934 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1010 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
935 } | 1011 } |
936 | 1012 |
937 | 1013 |
938 static OrthancPluginErrorCode AddAttachment(OrthancPluginDatabaseTransaction* transaction, | 1014 static OrthancPluginErrorCode AddAttachment(OrthancPluginDatabaseTransaction* transaction, |
939 int64_t id, | 1015 int64_t id, |
942 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1018 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
943 | 1019 |
944 try | 1020 try |
945 { | 1021 { |
946 t->GetOutput().Clear(); | 1022 t->GetOutput().Clear(); |
947 t->GetBackend().AddAttachment(id, *attachment); | 1023 t->GetBackend().AddAttachment(t->GetManager(), id, *attachment); |
948 return OrthancPluginErrorCode_Success; | 1024 return OrthancPluginErrorCode_Success; |
949 } | 1025 } |
950 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1026 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
951 } | 1027 } |
952 | 1028 |
953 | 1029 |
954 static OrthancPluginErrorCode ClearChanges(OrthancPluginDatabaseTransaction* transaction) | 1030 static OrthancPluginErrorCode ClearChanges(OrthancPluginDatabaseTransaction* transaction) |
955 { | 1031 { |
956 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1032 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
957 | 1033 |
958 try | 1034 try |
959 { | 1035 { |
960 t->GetOutput().Clear(); | 1036 t->GetOutput().Clear(); |
961 t->GetBackend().ClearChanges(); | 1037 t->GetBackend().ClearChanges(t->GetManager()); |
962 return OrthancPluginErrorCode_Success; | 1038 return OrthancPluginErrorCode_Success; |
963 } | 1039 } |
964 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1040 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
965 } | 1041 } |
966 | 1042 |
967 | 1043 |
968 static OrthancPluginErrorCode ClearExportedResources(OrthancPluginDatabaseTransaction* transaction) | 1044 static OrthancPluginErrorCode ClearExportedResources(OrthancPluginDatabaseTransaction* transaction) |
969 { | 1045 { |
970 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1046 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
971 | 1047 |
972 try | 1048 try |
973 { | 1049 { |
974 t->GetOutput().Clear(); | 1050 t->GetOutput().Clear(); |
975 t->GetBackend().ClearExportedResources(); | 1051 t->GetBackend().ClearExportedResources(t->GetManager()); |
976 return OrthancPluginErrorCode_Success; | 1052 return OrthancPluginErrorCode_Success; |
977 } | 1053 } |
978 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1054 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
979 } | 1055 } |
980 | 1056 |
981 | 1057 |
982 static OrthancPluginErrorCode ClearMainDicomTags(OrthancPluginDatabaseTransaction* transaction, | 1058 static OrthancPluginErrorCode ClearMainDicomTags(OrthancPluginDatabaseTransaction* transaction, |
983 int64_t resourceId) | 1059 int64_t resourceId) |
985 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1061 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
986 | 1062 |
987 try | 1063 try |
988 { | 1064 { |
989 t->GetOutput().Clear(); | 1065 t->GetOutput().Clear(); |
990 t->GetBackend().ClearMainDicomTags(resourceId); | 1066 t->GetBackend().ClearMainDicomTags(t->GetManager(), resourceId); |
991 return OrthancPluginErrorCode_Success; | 1067 return OrthancPluginErrorCode_Success; |
992 } | 1068 } |
993 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1069 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
994 } | 1070 } |
995 | 1071 |
996 | 1072 |
997 static OrthancPluginErrorCode CreateInstance(OrthancPluginDatabaseTransaction* transaction, | 1073 static OrthancPluginErrorCode CreateInstance(OrthancPluginDatabaseTransaction* transaction, |
998 OrthancPluginCreateInstanceResult* target /* out */, | 1074 OrthancPluginCreateInstanceResult* target /* out */, |
1007 { | 1083 { |
1008 t->GetOutput().Clear(); | 1084 t->GetOutput().Clear(); |
1009 | 1085 |
1010 if (t->GetBackend().HasCreateInstance()) | 1086 if (t->GetBackend().HasCreateInstance()) |
1011 { | 1087 { |
1012 t->GetBackend().CreateInstance(*target, hashPatient, hashStudy, hashSeries, hashInstance); | 1088 t->GetBackend().CreateInstance(*target, t->GetManager(), hashPatient, hashStudy, hashSeries, hashInstance); |
1013 } | 1089 } |
1014 else | 1090 else |
1015 { | 1091 { |
1016 t->GetBackend().CreateInstanceGeneric(*target, hashPatient, hashStudy, hashSeries, hashInstance); | 1092 t->GetBackend().CreateInstanceGeneric(*target, t->GetManager(), hashPatient, hashStudy, hashSeries, hashInstance); |
1017 } | 1093 } |
1018 | 1094 |
1019 return OrthancPluginErrorCode_Success; | 1095 return OrthancPluginErrorCode_Success; |
1020 } | 1096 } |
1021 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1097 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1022 } | 1098 } |
1023 | 1099 |
1024 | 1100 |
1025 static OrthancPluginErrorCode DeleteAttachment(OrthancPluginDatabaseTransaction* transaction, | 1101 static OrthancPluginErrorCode DeleteAttachment(OrthancPluginDatabaseTransaction* transaction, |
1026 int64_t id, | 1102 int64_t id, |
1029 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1105 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1030 | 1106 |
1031 try | 1107 try |
1032 { | 1108 { |
1033 t->GetOutput().Clear(); | 1109 t->GetOutput().Clear(); |
1034 t->GetBackend().DeleteAttachment(t->GetOutput(), id, contentType); | 1110 t->GetBackend().DeleteAttachment(t->GetOutput(), t->GetManager(), id, contentType); |
1035 return OrthancPluginErrorCode_Success; | 1111 return OrthancPluginErrorCode_Success; |
1036 } | 1112 } |
1037 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1113 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1038 } | 1114 } |
1039 | 1115 |
1040 | 1116 |
1041 static OrthancPluginErrorCode DeleteMetadata(OrthancPluginDatabaseTransaction* transaction, | 1117 static OrthancPluginErrorCode DeleteMetadata(OrthancPluginDatabaseTransaction* transaction, |
1042 int64_t id, | 1118 int64_t id, |
1045 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1121 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1046 | 1122 |
1047 try | 1123 try |
1048 { | 1124 { |
1049 t->GetOutput().Clear(); | 1125 t->GetOutput().Clear(); |
1050 t->GetBackend().DeleteMetadata(id, metadataType); | 1126 t->GetBackend().DeleteMetadata(t->GetManager(), id, metadataType); |
1051 return OrthancPluginErrorCode_Success; | 1127 return OrthancPluginErrorCode_Success; |
1052 } | 1128 } |
1053 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1129 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1054 } | 1130 } |
1055 | 1131 |
1056 | 1132 |
1057 static OrthancPluginErrorCode DeleteResource(OrthancPluginDatabaseTransaction* transaction, | 1133 static OrthancPluginErrorCode DeleteResource(OrthancPluginDatabaseTransaction* transaction, |
1058 int64_t id) | 1134 int64_t id) |
1060 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1136 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1061 | 1137 |
1062 try | 1138 try |
1063 { | 1139 { |
1064 t->GetOutput().Clear(); | 1140 t->GetOutput().Clear(); |
1065 t->GetBackend().DeleteResource(t->GetOutput(), id); | 1141 t->GetBackend().DeleteResource(t->GetOutput(), t->GetManager(), id); |
1066 return OrthancPluginErrorCode_Success; | 1142 return OrthancPluginErrorCode_Success; |
1067 } | 1143 } |
1068 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1144 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1069 } | 1145 } |
1070 | 1146 |
1071 | 1147 |
1072 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseTransaction* transaction, | 1148 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseTransaction* transaction, |
1073 int64_t id) | 1149 int64_t id) |
1077 try | 1153 try |
1078 { | 1154 { |
1079 t->GetOutput().Clear(); | 1155 t->GetOutput().Clear(); |
1080 | 1156 |
1081 std::map<int32_t, std::string> values; | 1157 std::map<int32_t, std::string> values; |
1082 t->GetBackend().GetAllMetadata(values, id); | 1158 t->GetBackend().GetAllMetadata(values, t->GetManager(), id); |
1083 | 1159 |
1084 for (std::map<int32_t, std::string>::const_iterator it = values.begin(); it != values.end(); ++it) | 1160 for (std::map<int32_t, std::string>::const_iterator it = values.begin(); it != values.end(); ++it) |
1085 { | 1161 { |
1086 t->GetOutput().AnswerMetadata(it->first, it->second); | 1162 t->GetOutput().AnswerMetadata(it->first, it->second); |
1087 } | 1163 } |
1088 | 1164 |
1089 return OrthancPluginErrorCode_Success; | 1165 return OrthancPluginErrorCode_Success; |
1090 } | 1166 } |
1091 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1167 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1092 } | 1168 } |
1093 | 1169 |
1094 | 1170 |
1095 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseTransaction* transaction, | 1171 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseTransaction* transaction, |
1096 OrthancPluginResourceType resourceType) | 1172 OrthancPluginResourceType resourceType) |
1100 try | 1176 try |
1101 { | 1177 { |
1102 t->GetOutput().Clear(); | 1178 t->GetOutput().Clear(); |
1103 | 1179 |
1104 std::list<std::string> values; | 1180 std::list<std::string> values; |
1105 t->GetBackend().GetAllPublicIds(values, resourceType); | 1181 t->GetBackend().GetAllPublicIds(values, t->GetManager(), resourceType); |
1106 t->GetOutput().AnswerStrings(values); | 1182 t->GetOutput().AnswerStrings(values); |
1107 | 1183 |
1108 return OrthancPluginErrorCode_Success; | 1184 return OrthancPluginErrorCode_Success; |
1109 } | 1185 } |
1110 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1186 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1111 } | 1187 } |
1112 | 1188 |
1113 | 1189 |
1114 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseTransaction* transaction, | 1190 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseTransaction* transaction, |
1115 OrthancPluginResourceType resourceType, | 1191 OrthancPluginResourceType resourceType, |
1121 try | 1197 try |
1122 { | 1198 { |
1123 t->GetOutput().Clear(); | 1199 t->GetOutput().Clear(); |
1124 | 1200 |
1125 std::list<std::string> values; | 1201 std::list<std::string> values; |
1126 t->GetBackend().GetAllPublicIds(values, resourceType, since, limit); | 1202 t->GetBackend().GetAllPublicIds(values, t->GetManager(), resourceType, since, limit); |
1127 t->GetOutput().AnswerStrings(values); | 1203 t->GetOutput().AnswerStrings(values); |
1128 | 1204 |
1129 return OrthancPluginErrorCode_Success; | 1205 return OrthancPluginErrorCode_Success; |
1130 } | 1206 } |
1131 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1207 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1132 } | 1208 } |
1133 | 1209 |
1134 | 1210 |
1135 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseTransaction* transaction, | 1211 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseTransaction* transaction, |
1136 uint8_t* targetDone /* out */, | 1212 uint8_t* targetDone /* out */, |
1142 try | 1218 try |
1143 { | 1219 { |
1144 t->GetOutput().Clear(); | 1220 t->GetOutput().Clear(); |
1145 | 1221 |
1146 bool done; | 1222 bool done; |
1147 t->GetBackend().GetChanges(t->GetOutput(), done, since, maxResults); | 1223 t->GetBackend().GetChanges(t->GetOutput(), done, t->GetManager(), since, maxResults); |
1148 *targetDone = (done ? 1 : 0); | 1224 *targetDone = (done ? 1 : 0); |
1149 | 1225 |
1150 return OrthancPluginErrorCode_Success; | 1226 return OrthancPluginErrorCode_Success; |
1151 } | 1227 } |
1152 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1228 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1153 } | 1229 } |
1154 | 1230 |
1155 | 1231 |
1156 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseTransaction* transaction, | 1232 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseTransaction* transaction, |
1157 int64_t id) | 1233 int64_t id) |
1161 try | 1237 try |
1162 { | 1238 { |
1163 t->GetOutput().Clear(); | 1239 t->GetOutput().Clear(); |
1164 | 1240 |
1165 std::list<int64_t> values; | 1241 std::list<int64_t> values; |
1166 t->GetBackend().GetChildrenInternalId(values, id); | 1242 t->GetBackend().GetChildrenInternalId(values, t->GetManager(), id); |
1167 t->GetOutput().AnswerIntegers64(values); | 1243 t->GetOutput().AnswerIntegers64(values); |
1168 | 1244 |
1169 return OrthancPluginErrorCode_Success; | 1245 return OrthancPluginErrorCode_Success; |
1170 } | 1246 } |
1171 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1247 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1172 } | 1248 } |
1173 | 1249 |
1174 | 1250 |
1175 static OrthancPluginErrorCode GetChildrenMetadata(OrthancPluginDatabaseTransaction* transaction, | 1251 static OrthancPluginErrorCode GetChildrenMetadata(OrthancPluginDatabaseTransaction* transaction, |
1176 int64_t resourceId, | 1252 int64_t resourceId, |
1181 try | 1257 try |
1182 { | 1258 { |
1183 t->GetOutput().Clear(); | 1259 t->GetOutput().Clear(); |
1184 | 1260 |
1185 std::list<std::string> values; | 1261 std::list<std::string> values; |
1186 t->GetBackend().GetChildrenMetadata(values, resourceId, metadata); | 1262 t->GetBackend().GetChildrenMetadata(values, t->GetManager(), resourceId, metadata); |
1187 t->GetOutput().AnswerStrings(values); | 1263 t->GetOutput().AnswerStrings(values); |
1188 | 1264 |
1189 return OrthancPluginErrorCode_Success; | 1265 return OrthancPluginErrorCode_Success; |
1190 } | 1266 } |
1191 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1267 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1192 } | 1268 } |
1193 | 1269 |
1194 | 1270 |
1195 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseTransaction* transaction, | 1271 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseTransaction* transaction, |
1196 int64_t id) | 1272 int64_t id) |
1200 try | 1276 try |
1201 { | 1277 { |
1202 t->GetOutput().Clear(); | 1278 t->GetOutput().Clear(); |
1203 | 1279 |
1204 std::list<std::string> values; | 1280 std::list<std::string> values; |
1205 t->GetBackend().GetChildrenPublicId(values, id); | 1281 t->GetBackend().GetChildrenPublicId(values, t->GetManager(), id); |
1206 t->GetOutput().AnswerStrings(values); | 1282 t->GetOutput().AnswerStrings(values); |
1207 | 1283 |
1208 return OrthancPluginErrorCode_Success; | 1284 return OrthancPluginErrorCode_Success; |
1209 } | 1285 } |
1210 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1286 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1211 } | 1287 } |
1212 | 1288 |
1213 | 1289 |
1214 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseTransaction* transaction, | 1290 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseTransaction* transaction, |
1215 uint8_t* targetDone /* out */, | 1291 uint8_t* targetDone /* out */, |
1221 try | 1297 try |
1222 { | 1298 { |
1223 t->GetOutput().Clear(); | 1299 t->GetOutput().Clear(); |
1224 | 1300 |
1225 bool done; | 1301 bool done; |
1226 t->GetBackend().GetExportedResources(t->GetOutput(), done, since, maxResults); | 1302 t->GetBackend().GetExportedResources(t->GetOutput(), done, t->GetManager(), since, maxResults); |
1227 *targetDone = (done ? 1 : 0); | 1303 *targetDone = (done ? 1 : 0); |
1228 | 1304 |
1229 return OrthancPluginErrorCode_Success; | 1305 return OrthancPluginErrorCode_Success; |
1230 } | 1306 } |
1231 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1307 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1232 } | 1308 } |
1233 | 1309 |
1234 | 1310 |
1235 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseTransaction* transaction) | 1311 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseTransaction* transaction) |
1236 { | 1312 { |
1237 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1313 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1238 | 1314 |
1239 try | 1315 try |
1240 { | 1316 { |
1241 t->GetOutput().Clear(); | 1317 t->GetOutput().Clear(); |
1242 t->GetBackend().GetLastChange(t->GetOutput()); | 1318 t->GetBackend().GetLastChange(t->GetOutput(), t->GetManager()); |
1243 return OrthancPluginErrorCode_Success; | 1319 return OrthancPluginErrorCode_Success; |
1244 } | 1320 } |
1245 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1321 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1246 } | 1322 } |
1247 | 1323 |
1248 | 1324 |
1249 static OrthancPluginErrorCode GetLastChangeIndex(OrthancPluginDatabaseTransaction* transaction, | 1325 static OrthancPluginErrorCode GetLastChangeIndex(OrthancPluginDatabaseTransaction* transaction, |
1250 int64_t* target) | 1326 int64_t* target) |
1252 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1328 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1253 | 1329 |
1254 try | 1330 try |
1255 { | 1331 { |
1256 t->GetOutput().Clear(); | 1332 t->GetOutput().Clear(); |
1257 *target = t->GetBackend().GetLastChangeIndex(); | 1333 *target = t->GetBackend().GetLastChangeIndex(t->GetManager()); |
1258 return OrthancPluginErrorCode_Success; | 1334 return OrthancPluginErrorCode_Success; |
1259 } | 1335 } |
1260 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1336 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1261 } | 1337 } |
1262 | 1338 |
1263 | 1339 |
1264 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseTransaction* transaction) | 1340 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseTransaction* transaction) |
1265 { | 1341 { |
1266 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1342 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1267 | 1343 |
1268 try | 1344 try |
1269 { | 1345 { |
1270 t->GetOutput().Clear(); | 1346 t->GetOutput().Clear(); |
1271 t->GetBackend().GetLastExportedResource(t->GetOutput()); | 1347 t->GetBackend().GetLastExportedResource(t->GetOutput(), t->GetManager()); |
1272 return OrthancPluginErrorCode_Success; | 1348 return OrthancPluginErrorCode_Success; |
1273 } | 1349 } |
1274 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1350 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1275 } | 1351 } |
1276 | 1352 |
1277 | 1353 |
1278 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseTransaction* transaction, | 1354 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseTransaction* transaction, |
1279 int64_t id) | 1355 int64_t id) |
1281 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1357 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1282 | 1358 |
1283 try | 1359 try |
1284 { | 1360 { |
1285 t->GetOutput().Clear(); | 1361 t->GetOutput().Clear(); |
1286 t->GetBackend().GetMainDicomTags(t->GetOutput(), id); | 1362 t->GetBackend().GetMainDicomTags(t->GetOutput(), t->GetManager(), id); |
1287 return OrthancPluginErrorCode_Success; | 1363 return OrthancPluginErrorCode_Success; |
1288 } | 1364 } |
1289 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1365 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1290 } | 1366 } |
1291 | 1367 |
1292 | 1368 |
1293 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseTransaction* transaction, | 1369 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseTransaction* transaction, |
1294 int64_t id) | 1370 int64_t id) |
1296 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1372 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1297 | 1373 |
1298 try | 1374 try |
1299 { | 1375 { |
1300 t->GetOutput().Clear(); | 1376 t->GetOutput().Clear(); |
1301 t->GetOutput().AnswerString(t->GetBackend().GetPublicId(id)); | 1377 t->GetOutput().AnswerString(t->GetBackend().GetPublicId(t->GetManager(), id)); |
1302 return OrthancPluginErrorCode_Success; | 1378 return OrthancPluginErrorCode_Success; |
1303 } | 1379 } |
1304 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1380 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1305 } | 1381 } |
1306 | 1382 |
1307 | 1383 |
1308 static OrthancPluginErrorCode GetResourcesCount(OrthancPluginDatabaseTransaction* transaction, | 1384 static OrthancPluginErrorCode GetResourcesCount(OrthancPluginDatabaseTransaction* transaction, |
1309 uint64_t* target /* out */, | 1385 uint64_t* target /* out */, |
1312 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1388 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1313 | 1389 |
1314 try | 1390 try |
1315 { | 1391 { |
1316 t->GetOutput().Clear(); | 1392 t->GetOutput().Clear(); |
1317 *target = t->GetBackend().GetResourcesCount(resourceType); | 1393 *target = t->GetBackend().GetResourcesCount(t->GetManager(), resourceType); |
1318 return OrthancPluginErrorCode_Success; | 1394 return OrthancPluginErrorCode_Success; |
1319 } | 1395 } |
1320 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1396 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1321 } | 1397 } |
1322 | 1398 |
1323 | 1399 |
1324 static OrthancPluginErrorCode GetResourceType(OrthancPluginDatabaseTransaction* transaction, | 1400 static OrthancPluginErrorCode GetResourceType(OrthancPluginDatabaseTransaction* transaction, |
1325 OrthancPluginResourceType* target /* out */, | 1401 OrthancPluginResourceType* target /* out */, |
1328 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1404 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1329 | 1405 |
1330 try | 1406 try |
1331 { | 1407 { |
1332 t->GetOutput().Clear(); | 1408 t->GetOutput().Clear(); |
1333 *target = t->GetBackend().GetResourceType(resourceId); | 1409 *target = t->GetBackend().GetResourceType(t->GetManager(), resourceId); |
1334 return OrthancPluginErrorCode_Success; | 1410 return OrthancPluginErrorCode_Success; |
1335 } | 1411 } |
1336 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1412 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1337 } | 1413 } |
1338 | 1414 |
1339 | 1415 |
1340 static OrthancPluginErrorCode GetTotalCompressedSize(OrthancPluginDatabaseTransaction* transaction, | 1416 static OrthancPluginErrorCode GetTotalCompressedSize(OrthancPluginDatabaseTransaction* transaction, |
1341 uint64_t* target /* out */) | 1417 uint64_t* target /* out */) |
1343 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1419 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1344 | 1420 |
1345 try | 1421 try |
1346 { | 1422 { |
1347 t->GetOutput().Clear(); | 1423 t->GetOutput().Clear(); |
1348 *target = t->GetBackend().GetTotalCompressedSize(); | 1424 *target = t->GetBackend().GetTotalCompressedSize(t->GetManager()); |
1349 return OrthancPluginErrorCode_Success; | 1425 return OrthancPluginErrorCode_Success; |
1350 } | 1426 } |
1351 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1427 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1352 } | 1428 } |
1353 | 1429 |
1354 | 1430 |
1355 static OrthancPluginErrorCode GetTotalUncompressedSize(OrthancPluginDatabaseTransaction* transaction, | 1431 static OrthancPluginErrorCode GetTotalUncompressedSize(OrthancPluginDatabaseTransaction* transaction, |
1356 uint64_t* target /* out */) | 1432 uint64_t* target /* out */) |
1358 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1434 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1359 | 1435 |
1360 try | 1436 try |
1361 { | 1437 { |
1362 t->GetOutput().Clear(); | 1438 t->GetOutput().Clear(); |
1363 *target = t->GetBackend().GetTotalUncompressedSize(); | 1439 *target = t->GetBackend().GetTotalUncompressedSize(t->GetManager()); |
1364 return OrthancPluginErrorCode_Success; | 1440 return OrthancPluginErrorCode_Success; |
1365 } | 1441 } |
1366 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1442 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1367 } | 1443 } |
1368 | 1444 |
1369 | 1445 |
1370 static OrthancPluginErrorCode IsDiskSizeAbove(OrthancPluginDatabaseTransaction* transaction, | 1446 static OrthancPluginErrorCode IsDiskSizeAbove(OrthancPluginDatabaseTransaction* transaction, |
1371 uint8_t* target, | 1447 uint8_t* target, |
1374 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1450 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1375 | 1451 |
1376 try | 1452 try |
1377 { | 1453 { |
1378 t->GetOutput().Clear(); | 1454 t->GetOutput().Clear(); |
1379 bool above = (t->GetBackend().GetTotalCompressedSize() >= threshold); | 1455 bool above = (t->GetBackend().GetTotalCompressedSize(t->GetManager()) >= threshold); |
1380 *target = (above ? 1 : 0); | 1456 *target = (above ? 1 : 0); |
1381 return OrthancPluginErrorCode_Success; | 1457 return OrthancPluginErrorCode_Success; |
1382 } | 1458 } |
1383 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1459 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1384 } | 1460 } |
1385 | 1461 |
1386 | 1462 |
1387 static OrthancPluginErrorCode IsExistingResource(OrthancPluginDatabaseTransaction* transaction, | 1463 static OrthancPluginErrorCode IsExistingResource(OrthancPluginDatabaseTransaction* transaction, |
1388 uint8_t* target, | 1464 uint8_t* target, |
1391 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1467 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1392 | 1468 |
1393 try | 1469 try |
1394 { | 1470 { |
1395 t->GetOutput().Clear(); | 1471 t->GetOutput().Clear(); |
1396 bool exists = t->GetBackend().IsExistingResource(resourceId); | 1472 bool exists = t->GetBackend().IsExistingResource(t->GetManager(), resourceId); |
1397 *target = (exists ? 1 : 0); | 1473 *target = (exists ? 1 : 0); |
1398 return OrthancPluginErrorCode_Success; | 1474 return OrthancPluginErrorCode_Success; |
1399 } | 1475 } |
1400 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1476 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1401 } | 1477 } |
1402 | 1478 |
1403 | 1479 |
1404 static OrthancPluginErrorCode IsProtectedPatient(OrthancPluginDatabaseTransaction* transaction, | 1480 static OrthancPluginErrorCode IsProtectedPatient(OrthancPluginDatabaseTransaction* transaction, |
1405 uint8_t* target, | 1481 uint8_t* target, |
1408 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1484 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1409 | 1485 |
1410 try | 1486 try |
1411 { | 1487 { |
1412 t->GetOutput().Clear(); | 1488 t->GetOutput().Clear(); |
1413 bool isProtected = t->GetBackend().IsProtectedPatient(resourceId); | 1489 bool isProtected = t->GetBackend().IsProtectedPatient(t->GetManager(), resourceId); |
1414 *target = (isProtected ? 1 : 0); | 1490 *target = (isProtected ? 1 : 0); |
1415 return OrthancPluginErrorCode_Success; | 1491 return OrthancPluginErrorCode_Success; |
1416 } | 1492 } |
1417 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1493 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1418 } | 1494 } |
1419 | 1495 |
1420 | 1496 |
1421 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseTransaction* transaction, | 1497 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseTransaction* transaction, |
1422 int64_t resourceId) | 1498 int64_t resourceId) |
1426 try | 1502 try |
1427 { | 1503 { |
1428 t->GetOutput().Clear(); | 1504 t->GetOutput().Clear(); |
1429 | 1505 |
1430 std::list<int32_t> values; | 1506 std::list<int32_t> values; |
1431 t->GetBackend().ListAvailableAttachments(values, resourceId); | 1507 t->GetBackend().ListAvailableAttachments(values, t->GetManager(), resourceId); |
1432 t->GetOutput().AnswerIntegers32(values); | 1508 t->GetOutput().AnswerIntegers32(values); |
1433 return OrthancPluginErrorCode_Success; | 1509 return OrthancPluginErrorCode_Success; |
1434 } | 1510 } |
1435 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1511 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1436 } | 1512 } |
1437 | 1513 |
1438 | 1514 |
1439 static OrthancPluginErrorCode LogChange(OrthancPluginDatabaseTransaction* transaction, | 1515 static OrthancPluginErrorCode LogChange(OrthancPluginDatabaseTransaction* transaction, |
1440 int32_t changeType, | 1516 int32_t changeType, |
1445 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1521 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1446 | 1522 |
1447 try | 1523 try |
1448 { | 1524 { |
1449 t->GetOutput().Clear(); | 1525 t->GetOutput().Clear(); |
1450 t->GetBackend().LogChange(changeType, resourceId, resourceType, date); | 1526 t->GetBackend().LogChange(t->GetManager(), changeType, resourceId, resourceType, date); |
1451 return OrthancPluginErrorCode_Success; | 1527 return OrthancPluginErrorCode_Success; |
1452 } | 1528 } |
1453 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1529 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1454 } | 1530 } |
1455 | 1531 |
1456 | 1532 |
1457 static OrthancPluginErrorCode LogExportedResource(OrthancPluginDatabaseTransaction* transaction, | 1533 static OrthancPluginErrorCode LogExportedResource(OrthancPluginDatabaseTransaction* transaction, |
1458 OrthancPluginResourceType resourceType, | 1534 OrthancPluginResourceType resourceType, |
1478 exported.studyInstanceUid = studyInstanceUid; | 1554 exported.studyInstanceUid = studyInstanceUid; |
1479 exported.seriesInstanceUid = seriesInstanceUid; | 1555 exported.seriesInstanceUid = seriesInstanceUid; |
1480 exported.sopInstanceUid = sopInstanceUid; | 1556 exported.sopInstanceUid = sopInstanceUid; |
1481 | 1557 |
1482 t->GetOutput().Clear(); | 1558 t->GetOutput().Clear(); |
1483 t->GetBackend().LogExportedResource(exported); | 1559 t->GetBackend().LogExportedResource(t->GetManager(), exported); |
1484 return OrthancPluginErrorCode_Success; | 1560 return OrthancPluginErrorCode_Success; |
1485 } | 1561 } |
1486 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1562 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1487 } | 1563 } |
1488 | 1564 |
1489 | 1565 |
1490 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseTransaction* transaction, | 1566 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseTransaction* transaction, |
1491 int64_t resourceId, | 1567 int64_t resourceId, |
1494 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1570 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1495 | 1571 |
1496 try | 1572 try |
1497 { | 1573 { |
1498 t->GetOutput().Clear(); | 1574 t->GetOutput().Clear(); |
1499 t->GetBackend().LookupAttachment(t->GetOutput(), resourceId, contentType); | 1575 t->GetBackend().LookupAttachment(t->GetOutput(), t->GetManager(), resourceId, contentType); |
1500 return OrthancPluginErrorCode_Success; | 1576 return OrthancPluginErrorCode_Success; |
1501 } | 1577 } |
1502 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1578 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1503 } | 1579 } |
1504 | 1580 |
1505 | 1581 |
1506 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseTransaction* transaction, | 1582 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseTransaction* transaction, |
1507 const char* serverIdentifier, | 1583 const char* serverIdentifier, |
1512 try | 1588 try |
1513 { | 1589 { |
1514 t->GetOutput().Clear(); | 1590 t->GetOutput().Clear(); |
1515 | 1591 |
1516 std::string s; | 1592 std::string s; |
1517 if (t->GetBackend().LookupGlobalProperty(s, serverIdentifier, property)) | 1593 if (t->GetBackend().LookupGlobalProperty(s, t->GetManager(), serverIdentifier, property)) |
1518 { | 1594 { |
1519 t->GetOutput().AnswerString(s); | 1595 t->GetOutput().AnswerString(s); |
1520 } | 1596 } |
1521 | 1597 |
1522 return OrthancPluginErrorCode_Success; | 1598 return OrthancPluginErrorCode_Success; |
1523 } | 1599 } |
1524 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1600 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1525 } | 1601 } |
1526 | 1602 |
1527 | 1603 |
1528 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseTransaction* transaction, | 1604 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseTransaction* transaction, |
1529 int64_t id, | 1605 int64_t id, |
1534 try | 1610 try |
1535 { | 1611 { |
1536 t->GetOutput().Clear(); | 1612 t->GetOutput().Clear(); |
1537 | 1613 |
1538 std::string s; | 1614 std::string s; |
1539 if (t->GetBackend().LookupMetadata(s, id, metadata)) | 1615 if (t->GetBackend().LookupMetadata(s, t->GetManager(), id, metadata)) |
1540 { | 1616 { |
1541 t->GetOutput().AnswerString(s); | 1617 t->GetOutput().AnswerString(s); |
1542 } | 1618 } |
1543 | 1619 |
1544 return OrthancPluginErrorCode_Success; | 1620 return OrthancPluginErrorCode_Success; |
1545 } | 1621 } |
1546 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1622 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1547 } | 1623 } |
1548 | 1624 |
1549 | 1625 |
1550 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseTransaction* transaction, | 1626 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseTransaction* transaction, |
1551 int64_t id) | 1627 int64_t id) |
1555 try | 1631 try |
1556 { | 1632 { |
1557 t->GetOutput().Clear(); | 1633 t->GetOutput().Clear(); |
1558 | 1634 |
1559 int64_t parentId; | 1635 int64_t parentId; |
1560 if (t->GetBackend().LookupParent(parentId, id)) | 1636 if (t->GetBackend().LookupParent(parentId, t->GetManager(), id)) |
1561 { | 1637 { |
1562 t->GetOutput().AnswerInteger64(parentId); | 1638 t->GetOutput().AnswerInteger64(parentId); |
1563 } | 1639 } |
1564 | 1640 |
1565 return OrthancPluginErrorCode_Success; | 1641 return OrthancPluginErrorCode_Success; |
1566 } | 1642 } |
1567 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1643 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1568 } | 1644 } |
1569 | 1645 |
1570 | 1646 |
1571 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseTransaction* transaction, | 1647 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseTransaction* transaction, |
1572 uint8_t* isExisting /* out */, | 1648 uint8_t* isExisting /* out */, |
1578 | 1654 |
1579 try | 1655 try |
1580 { | 1656 { |
1581 t->GetOutput().Clear(); | 1657 t->GetOutput().Clear(); |
1582 | 1658 |
1583 if (t->GetBackend().LookupResource(*id, *type, publicId)) | 1659 if (t->GetBackend().LookupResource(*id, *type, t->GetManager(), publicId)) |
1584 { | 1660 { |
1585 *isExisting = 1; | 1661 *isExisting = 1; |
1586 } | 1662 } |
1587 else | 1663 else |
1588 { | 1664 { |
1589 *isExisting = 0; | 1665 *isExisting = 0; |
1590 } | 1666 } |
1591 | 1667 |
1592 return OrthancPluginErrorCode_Success; | 1668 return OrthancPluginErrorCode_Success; |
1593 } | 1669 } |
1594 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1670 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1595 } | 1671 } |
1596 | 1672 |
1597 | 1673 |
1598 static OrthancPluginErrorCode LookupResources(OrthancPluginDatabaseTransaction* transaction, | 1674 static OrthancPluginErrorCode LookupResources(OrthancPluginDatabaseTransaction* transaction, |
1599 uint32_t constraintsCount, | 1675 uint32_t constraintsCount, |
1614 for (uint32_t i = 0; i < constraintsCount; i++) | 1690 for (uint32_t i = 0; i < constraintsCount; i++) |
1615 { | 1691 { |
1616 lookup.push_back(Orthanc::DatabaseConstraint(constraints[i])); | 1692 lookup.push_back(Orthanc::DatabaseConstraint(constraints[i])); |
1617 } | 1693 } |
1618 | 1694 |
1619 t->GetBackend().LookupResources(t->GetOutput(), lookup, queryLevel, limit, (requestSomeInstanceId != 0)); | 1695 t->GetBackend().LookupResources(t->GetOutput(), t->GetManager(), lookup, queryLevel, limit, (requestSomeInstanceId != 0)); |
1620 return OrthancPluginErrorCode_Success; | 1696 return OrthancPluginErrorCode_Success; |
1621 } | 1697 } |
1622 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1698 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1623 } | 1699 } |
1624 | 1700 |
1625 | 1701 |
1626 static OrthancPluginErrorCode LookupResourceAndParent(OrthancPluginDatabaseTransaction* transaction, | 1702 static OrthancPluginErrorCode LookupResourceAndParent(OrthancPluginDatabaseTransaction* transaction, |
1627 uint8_t* isExisting /* out */, | 1703 uint8_t* isExisting /* out */, |
1634 try | 1710 try |
1635 { | 1711 { |
1636 t->GetOutput().Clear(); | 1712 t->GetOutput().Clear(); |
1637 | 1713 |
1638 std::string parent; | 1714 std::string parent; |
1639 if (t->GetBackend().LookupResourceAndParent(*id, *type, parent, publicId)) | 1715 if (t->GetBackend().LookupResourceAndParent(*id, *type, parent, t->GetManager(), publicId)) |
1640 { | 1716 { |
1641 *isExisting = 1; | 1717 *isExisting = 1; |
1642 | 1718 |
1643 if (!parent.empty()) | 1719 if (!parent.empty()) |
1644 { | 1720 { |
1650 *isExisting = 0; | 1726 *isExisting = 0; |
1651 } | 1727 } |
1652 | 1728 |
1653 return OrthancPluginErrorCode_Success; | 1729 return OrthancPluginErrorCode_Success; |
1654 } | 1730 } |
1655 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1731 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1656 } | 1732 } |
1657 | 1733 |
1658 | 1734 |
1659 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseTransaction* transaction) | 1735 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseTransaction* transaction) |
1660 { | 1736 { |
1663 try | 1739 try |
1664 { | 1740 { |
1665 t->GetOutput().Clear(); | 1741 t->GetOutput().Clear(); |
1666 | 1742 |
1667 int64_t id; | 1743 int64_t id; |
1668 if (t->GetBackend().SelectPatientToRecycle(id)) | 1744 if (t->GetBackend().SelectPatientToRecycle(id, t->GetManager())) |
1669 { | 1745 { |
1670 t->GetOutput().AnswerInteger64(id); | 1746 t->GetOutput().AnswerInteger64(id); |
1671 } | 1747 } |
1672 | 1748 |
1673 return OrthancPluginErrorCode_Success; | 1749 return OrthancPluginErrorCode_Success; |
1674 } | 1750 } |
1675 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1751 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1676 } | 1752 } |
1677 | 1753 |
1678 | 1754 |
1679 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseTransaction* transaction, | 1755 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseTransaction* transaction, |
1680 int64_t patientIdToAvoid) | 1756 int64_t patientIdToAvoid) |
1684 try | 1760 try |
1685 { | 1761 { |
1686 t->GetOutput().Clear(); | 1762 t->GetOutput().Clear(); |
1687 | 1763 |
1688 int64_t id; | 1764 int64_t id; |
1689 if (t->GetBackend().SelectPatientToRecycle(id, patientIdToAvoid)) | 1765 if (t->GetBackend().SelectPatientToRecycle(id, t->GetManager(), patientIdToAvoid)) |
1690 { | 1766 { |
1691 t->GetOutput().AnswerInteger64(id); | 1767 t->GetOutput().AnswerInteger64(id); |
1692 } | 1768 } |
1693 | 1769 |
1694 return OrthancPluginErrorCode_Success; | 1770 return OrthancPluginErrorCode_Success; |
1695 } | 1771 } |
1696 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1772 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1697 } | 1773 } |
1698 | 1774 |
1699 | 1775 |
1700 static OrthancPluginErrorCode SetGlobalProperty(OrthancPluginDatabaseTransaction* transaction, | 1776 static OrthancPluginErrorCode SetGlobalProperty(OrthancPluginDatabaseTransaction* transaction, |
1701 const char* serverIdentifier, | 1777 const char* serverIdentifier, |
1705 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1781 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1706 | 1782 |
1707 try | 1783 try |
1708 { | 1784 { |
1709 t->GetOutput().Clear(); | 1785 t->GetOutput().Clear(); |
1710 t->GetBackend().SetGlobalProperty(serverIdentifier, property, value); | 1786 t->GetBackend().SetGlobalProperty(t->GetManager(), serverIdentifier, property, value); |
1711 return OrthancPluginErrorCode_Success; | 1787 return OrthancPluginErrorCode_Success; |
1712 } | 1788 } |
1713 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1789 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1714 } | 1790 } |
1715 | 1791 |
1716 | 1792 |
1717 static OrthancPluginErrorCode SetMetadata(OrthancPluginDatabaseTransaction* transaction, | 1793 static OrthancPluginErrorCode SetMetadata(OrthancPluginDatabaseTransaction* transaction, |
1718 int64_t id, | 1794 int64_t id, |
1722 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1798 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1723 | 1799 |
1724 try | 1800 try |
1725 { | 1801 { |
1726 t->GetOutput().Clear(); | 1802 t->GetOutput().Clear(); |
1727 t->GetBackend().SetMetadata(id, metadata, value); | 1803 t->GetBackend().SetMetadata(t->GetManager(), id, metadata, value); |
1728 return OrthancPluginErrorCode_Success; | 1804 return OrthancPluginErrorCode_Success; |
1729 } | 1805 } |
1730 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1806 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1731 } | 1807 } |
1732 | 1808 |
1733 | 1809 |
1734 static OrthancPluginErrorCode SetProtectedPatient(OrthancPluginDatabaseTransaction* transaction, | 1810 static OrthancPluginErrorCode SetProtectedPatient(OrthancPluginDatabaseTransaction* transaction, |
1735 int64_t id, | 1811 int64_t id, |
1738 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1814 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1739 | 1815 |
1740 try | 1816 try |
1741 { | 1817 { |
1742 t->GetOutput().Clear(); | 1818 t->GetOutput().Clear(); |
1743 t->GetBackend().SetProtectedPatient(id, (isProtected != 0)); | 1819 t->GetBackend().SetProtectedPatient(t->GetManager(), id, (isProtected != 0)); |
1744 return OrthancPluginErrorCode_Success; | 1820 return OrthancPluginErrorCode_Success; |
1745 } | 1821 } |
1746 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | 1822 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1747 } | 1823 } |
1748 | 1824 |
1749 | 1825 |
1750 static OrthancPluginErrorCode SetResourcesContent(OrthancPluginDatabaseTransaction* transaction, | 1826 static OrthancPluginErrorCode SetResourcesContent(OrthancPluginDatabaseTransaction* transaction, |
1751 uint32_t countIdentifierTags, | 1827 uint32_t countIdentifierTags, |
1758 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); | 1834 DatabaseBackendAdapterV3::Transaction* t = reinterpret_cast<DatabaseBackendAdapterV3::Transaction*>(transaction); |
1759 | 1835 |
1760 try | 1836 try |
1761 { | 1837 { |
1762 t->GetOutput().Clear(); | 1838 t->GetOutput().Clear(); |
1763 t->GetBackend().SetResourcesContent(countIdentifierTags, identifierTags, | 1839 t->GetBackend().SetResourcesContent(t->GetManager(), countIdentifierTags, identifierTags, |
1764 countMainDicomTags, mainDicomTags, | 1840 countMainDicomTags, mainDicomTags, countMetadata, metadata); |
1765 countMetadata, metadata); | 1841 return OrthancPluginErrorCode_Success; |
1766 return OrthancPluginErrorCode_Success; | 1842 } |
1767 } | 1843 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetBackend().GetContext()); |
1768 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); | |
1769 } | 1844 } |
1770 | 1845 |
1771 | 1846 |
1772 void DatabaseBackendAdapterV3::Register(IndexBackend* backend) | 1847 void DatabaseBackendAdapterV3::Register(IndexBackend* backend) |
1773 { | 1848 { |
1853 params.setProtectedPatient = SetProtectedPatient; | 1928 params.setProtectedPatient = SetProtectedPatient; |
1854 params.setResourcesContent = SetResourcesContent; | 1929 params.setResourcesContent = SetResourcesContent; |
1855 | 1930 |
1856 OrthancPluginContext* context = backend->GetContext(); | 1931 OrthancPluginContext* context = backend->GetContext(); |
1857 | 1932 |
1858 if (OrthancPluginRegisterDatabaseBackendV3(context, ¶ms, sizeof(params), backend) != OrthancPluginErrorCode_Success) | 1933 if (OrthancPluginRegisterDatabaseBackendV3(context, ¶ms, sizeof(params), new Adapter(backend)) != OrthancPluginErrorCode_Success) |
1859 { | 1934 { |
1860 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError, "Unable to register the database backend"); | 1935 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError, "Unable to register the database backend"); |
1861 } | 1936 } |
1862 | 1937 |
1863 backend->SetOutputFactory(new Factory); | 1938 backend->SetOutputFactory(new Factory); |