Mercurial > hg > orthanc-databases

comparison Framework/Plugins/DatabaseBackendAdapterV3.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 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, &params, sizeof(params), backend) != OrthancPluginErrorCode_Success) 1933 if (OrthancPluginRegisterDatabaseBackendV3(context, &params, 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);