Mercurial > hg > orthanc

comparison OrthancServer/Sources/Search/DatabaseConstraint.cpp @ 5809:023a99146dd0 attach-custom-data

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merged find-refactoring -> attach-custom-data
author Alain Mazy <am@orthanc.team>
date Tue, 24 Sep 2024 12:53:43 +0200
parents e2771185dad6
children
comparison
equal deleted inserted replaced
5808:63c025cf6958 5809:023a99146dd0
19 * You should have received a copy of the GNU General Public License 19 * You should have received a copy of the GNU General Public License
20 * along with this program. If not, see <http://www.gnu.org/licenses/>. 20 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 **/ 21 **/
22 22
23 23
24 #if !defined(ORTHANC_BUILDING_SERVER_LIBRARY) 24 #include "../PrecompiledHeadersServer.h"
25 # error Macro ORTHANC_BUILDING_SERVER_LIBRARY must be defined 25 #include "DatabaseConstraint.h"
26
27 #include "../../../OrthancFramework/Sources/OrthancException.h"
28
29 #if ORTHANC_ENABLE_PLUGINS == 1
30 # include "../../Plugins/Engine/PluginsEnumerations.h"
26 #endif 31 #endif
27 32
28 #if ORTHANC_BUILDING_SERVER_LIBRARY == 1 33 #include <boost/lexical_cast.hpp>
29 # include "../PrecompiledHeadersServer.h"
30 #endif
31
32 #include "DatabaseConstraint.h"
33
34 #if ORTHANC_BUILDING_SERVER_LIBRARY == 1
35 # include "../../../OrthancFramework/Sources/OrthancException.h"
36 #else
37 # include <OrthancException.h>
38 #endif
39
40 #include <cassert> 34 #include <cassert>
41 35
42 36
43 namespace Orthanc 37 namespace Orthanc
44 { 38 {
45 namespace Plugins
46 {
47 #if ORTHANC_ENABLE_PLUGINS == 1
48 OrthancPluginResourceType Convert(ResourceType type)
49 {
50 switch (type)
51 {
52 case ResourceType_Patient:
53 return OrthancPluginResourceType_Patient;
54
55 case ResourceType_Study:
56 return OrthancPluginResourceType_Study;
57
58 case ResourceType_Series:
59 return OrthancPluginResourceType_Series;
60
61 case ResourceType_Instance:
62 return OrthancPluginResourceType_Instance;
63
64 default:
65 throw OrthancException(ErrorCode_ParameterOutOfRange);
66 }
67 }
68 #endif
69
70
71 #if ORTHANC_ENABLE_PLUGINS == 1
72 ResourceType Convert(OrthancPluginResourceType type)
73 {
74 switch (type)
75 {
76 case OrthancPluginResourceType_Patient:
77 return ResourceType_Patient;
78
79 case OrthancPluginResourceType_Study:
80 return ResourceType_Study;
81
82 case OrthancPluginResourceType_Series:
83 return ResourceType_Series;
84
85 case OrthancPluginResourceType_Instance:
86 return ResourceType_Instance;
87
88 default:
89 throw OrthancException(ErrorCode_ParameterOutOfRange);
90 }
91 }
92 #endif
93
94
95 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
96 OrthancPluginConstraintType Convert(ConstraintType constraint)
97 {
98 switch (constraint)
99 {
100 case ConstraintType_Equal:
101 return OrthancPluginConstraintType_Equal;
102
103 case ConstraintType_GreaterOrEqual:
104 return OrthancPluginConstraintType_GreaterOrEqual;
105
106 case ConstraintType_SmallerOrEqual:
107 return OrthancPluginConstraintType_SmallerOrEqual;
108
109 case ConstraintType_Wildcard:
110 return OrthancPluginConstraintType_Wildcard;
111
112 case ConstraintType_List:
113 return OrthancPluginConstraintType_List;
114
115 default:
116 throw OrthancException(ErrorCode_ParameterOutOfRange);
117 }
118 }
119 #endif
120
121
122 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
123 ConstraintType Convert(OrthancPluginConstraintType constraint)
124 {
125 switch (constraint)
126 {
127 case OrthancPluginConstraintType_Equal:
128 return ConstraintType_Equal;
129
130 case OrthancPluginConstraintType_GreaterOrEqual:
131 return ConstraintType_GreaterOrEqual;
132
133 case OrthancPluginConstraintType_SmallerOrEqual:
134 return ConstraintType_SmallerOrEqual;
135
136 case OrthancPluginConstraintType_Wildcard:
137 return ConstraintType_Wildcard;
138
139 case OrthancPluginConstraintType_List:
140 return ConstraintType_List;
141
142 default:
143 throw OrthancException(ErrorCode_ParameterOutOfRange);
144 }
145 }
146 #endif
147 }
148
149 DatabaseConstraint::DatabaseConstraint(ResourceType level, 39 DatabaseConstraint::DatabaseConstraint(ResourceType level,
150 const DicomTag& tag, 40 const DicomTag& tag,
151 bool isIdentifier, 41 bool isIdentifier,
152 ConstraintType type, 42 ConstraintType type,
153 const std::vector<std::string>& values, 43 const std::vector<std::string>& values,
167 throw OrthancException(ErrorCode_ParameterOutOfRange); 57 throw OrthancException(ErrorCode_ParameterOutOfRange);
168 } 58 }
169 } 59 }
170 60
171 61
172 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
173 DatabaseConstraint::DatabaseConstraint(const OrthancPluginDatabaseConstraint& constraint) :
174 level_(Plugins::Convert(constraint.level)),
175 tag_(constraint.tagGroup, constraint.tagElement),
176 isIdentifier_(constraint.isIdentifierTag),
177 constraintType_(Plugins::Convert(constraint.type)),
178 caseSensitive_(constraint.isCaseSensitive),
179 mandatory_(constraint.isMandatory)
180 {
181 if (constraintType_ != ConstraintType_List &&
182 constraint.valuesCount != 1)
183 {
184 throw OrthancException(ErrorCode_ParameterOutOfRange);
185 }
186
187 values_.resize(constraint.valuesCount);
188
189 for (uint32_t i = 0; i < constraint.valuesCount; i++)
190 {
191 assert(constraint.values[i] != NULL);
192 values_[i].assign(constraint.values[i]);
193 }
194 }
195 #endif
196
197
198 const std::string& DatabaseConstraint::GetValue(size_t index) const 62 const std::string& DatabaseConstraint::GetValue(size_t index) const
199 { 63 {
200 if (index >= values_.size()) 64 if (index >= values_.size())
201 { 65 {
202 throw OrthancException(ErrorCode_ParameterOutOfRange); 66 throw OrthancException(ErrorCode_ParameterOutOfRange);
219 return values_[0]; 83 return values_[0];
220 } 84 }
221 } 85 }
222 86
223 87
224 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1 88 #if ORTHANC_ENABLE_PLUGINS == 1
225 void DatabaseConstraint::EncodeForPlugins(OrthancPluginDatabaseConstraint& constraint, 89 void DatabaseConstraint::EncodeForPlugins(OrthancPluginDatabaseConstraint& constraint,
226 std::vector<const char*>& tmpValues) const 90 std::vector<const char*>& tmpValues) const
227 { 91 {
228 memset(&constraint, 0, sizeof(constraint)); 92 memset(&constraint, 0, sizeof(constraint));
229 93
243 constraint.type = Plugins::Convert(constraintType_); 107 constraint.type = Plugins::Convert(constraintType_);
244 constraint.valuesCount = values_.size(); 108 constraint.valuesCount = values_.size();
245 constraint.values = (tmpValues.empty() ? NULL : &tmpValues[0]); 109 constraint.values = (tmpValues.empty() ? NULL : &tmpValues[0]);
246 } 110 }
247 #endif 111 #endif
248
249
250 void DatabaseConstraints::Clear()
251 {
252 for (size_t i = 0; i < constraints_.size(); i++)
253 {
254 assert(constraints_[i] != NULL);
255 delete constraints_[i];
256 }
257
258 constraints_.clear();
259 }
260
261
262 void DatabaseConstraints::AddConstraint(DatabaseConstraint* constraint)
263 {
264 if (constraint == NULL)
265 {
266 throw OrthancException(ErrorCode_NullPointer);
267 }
268 else
269 {
270 constraints_.push_back(constraint);
271 }
272 }
273
274
275 const DatabaseConstraint& DatabaseConstraints::GetConstraint(size_t index) const
276 {
277 if (index >= constraints_.size())
278 {
279 throw OrthancException(ErrorCode_ParameterOutOfRange);
280 }
281 else
282 {
283 assert(constraints_[index] != NULL);
284 return *constraints_[index];
285 }
286 }
287 } 112 }