Mercurial > hg > orthanc-databases

comparison Framework/Plugins/DatabaseConstraint.cpp @ 569:f18e46d7dbf8 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 15:04:21 +0200
parents 1a74fc1bea2d
children
comparison
equal deleted inserted replaced
368:82f73188b58d 569:f18e46d7dbf8
1 /**
2 * Orthanc - A Lightweight, RESTful DICOM Store
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2023 Osimis S.A., Belgium
6 * Copyright (C) 2024-2024 Orthanc Team SRL, Belgium
7 * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
8 *
9 * This program is free software: you can redistribute it and/or
10 * modify it under the terms of the GNU Affero General Public License
11 * as published by the Free Software Foundation, either version 3 of
12 * the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Affero General Public License for more details.
18 *
19 * You should have received a copy of the GNU Affero General Public License
20 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 **/
22
23
24 /**
25 * NB: Until 2024-09-09, this file was synchronized with the following
26 * folder from the Orthanc main project:
27 * https://orthanc.uclouvain.be/hg/orthanc/file/default/OrthancServer/Sources/Search/
28 **/
29
30
31 #include "DatabaseConstraint.h"
32
33 #include <OrthancException.h>
34
35 #include <boost/lexical_cast.hpp>
36 #include <cassert>
37
38
39 namespace OrthancDatabases
40 {
41 DatabaseConstraint::DatabaseConstraint(Orthanc::ResourceType level,
42 const Orthanc::DicomTag& tag,
43 bool isIdentifier,
44 ConstraintType type,
45 const std::vector<std::string>& values,
46 bool caseSensitive,
47 bool mandatory) :
48 level_(level),
49 tag_(tag),
50 isIdentifier_(isIdentifier),
51 constraintType_(type),
52 values_(values),
53 caseSensitive_(caseSensitive),
54 mandatory_(mandatory)
55 {
56 if (type != ConstraintType_List &&
57 values_.size() != 1)
58 {
59 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
60 }
61 }
62
63
64 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
65 DatabaseConstraint::DatabaseConstraint(const OrthancPluginDatabaseConstraint& constraint) :
66 level_(MessagesToolbox::Convert(constraint.level)),
67 tag_(constraint.tagGroup, constraint.tagElement),
68 isIdentifier_(constraint.isIdentifierTag),
69 constraintType_(MessagesToolbox::Convert(constraint.type)),
70 caseSensitive_(constraint.isCaseSensitive),
71 mandatory_(constraint.isMandatory)
72 {
73 if (constraintType_ != ConstraintType_List &&
74 constraint.valuesCount != 1)
75 {
76 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
77 }
78
79 values_.resize(constraint.valuesCount);
80
81 for (uint32_t i = 0; i < constraint.valuesCount; i++)
82 {
83 assert(constraint.values[i] != NULL);
84 values_[i].assign(constraint.values[i]);
85 }
86 }
87 #endif
88
89
90 #if ORTHANC_PLUGINS_HAS_INTEGRATED_FIND == 1
91 DatabaseConstraint::DatabaseConstraint(const Orthanc::DatabasePluginMessages::DatabaseConstraint& constraint) :
92 level_(MessagesToolbox::Convert(constraint.level())),
93 tag_(constraint.tag_group(), constraint.tag_element()),
94 isIdentifier_(constraint.is_identifier_tag()),
95 caseSensitive_(constraint.is_case_sensitive()),
96 mandatory_(constraint.is_mandatory())
97 {
98 switch (constraint.type())
99 {
100 case Orthanc::DatabasePluginMessages::CONSTRAINT_EQUAL:
101 constraintType_ = ConstraintType_Equal;
102 break;
103
104 case Orthanc::DatabasePluginMessages::CONSTRAINT_SMALLER_OR_EQUAL:
105 constraintType_ = ConstraintType_SmallerOrEqual;
106 break;
107
108 case Orthanc::DatabasePluginMessages::CONSTRAINT_GREATER_OR_EQUAL:
109 constraintType_ = ConstraintType_GreaterOrEqual;
110 break;
111
112 case Orthanc::DatabasePluginMessages::CONSTRAINT_WILDCARD:
113 constraintType_ = ConstraintType_Wildcard;
114 break;
115
116 case Orthanc::DatabasePluginMessages::CONSTRAINT_LIST:
117 constraintType_ = ConstraintType_List;
118 break;
119
120 default:
121 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
122 }
123
124 if (constraintType_ != ConstraintType_List &&
125 constraint.values().size() != 1)
126 {
127 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
128 }
129
130 values_.resize(constraint.values().size());
131
132 for (int i = 0; i < constraint.values().size(); i++)
133 {
134 values_[i] = constraint.values(i);
135 }
136 }
137 #endif
138
139
140 const std::string& DatabaseConstraint::GetValue(size_t index) const
141 {
142 if (index >= values_.size())
143 {
144 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
145 }
146 else
147 {
148 return values_[index];
149 }
150 }
151
152
153 const std::string& DatabaseConstraint::GetSingleValue() const
154 {
155 if (values_.size() != 1)
156 {
157 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
158 }
159 else
160 {
161 return values_[0];
162 }
163 }
164
165
166 #if ORTHANC_PLUGINS_HAS_DATABASE_CONSTRAINT == 1
167 void DatabaseConstraint::EncodeForPlugins(OrthancPluginDatabaseConstraint& constraint,
168 std::vector<const char*>& tmpValues) const
169 {
170 memset(&constraint, 0, sizeof(constraint));
171
172 tmpValues.resize(values_.size());
173
174 for (size_t i = 0; i < values_.size(); i++)
175 {
176 tmpValues[i] = values_[i].c_str();
177 }
178
179 constraint.level = MessagesToolbox::ConvertToPlainC(level_);
180 constraint.tagGroup = tag_.GetGroup();
181 constraint.tagElement = tag_.GetElement();
182 constraint.isIdentifierTag = isIdentifier_;
183 constraint.isCaseSensitive = caseSensitive_;
184 constraint.isMandatory = mandatory_;
185 constraint.type = MessagesToolbox::ConvertToPlainC(constraintType_);
186 constraint.valuesCount = values_.size();
187 constraint.values = (tmpValues.empty() ? NULL : &tmpValues[0]);
188 }
189 #endif
190
191
192 void DatabaseConstraints::Clear()
193 {
194 for (size_t i = 0; i < constraints_.size(); i++)
195 {
196 assert(constraints_[i] != NULL);
197 delete constraints_[i];
198 }
199
200 constraints_.clear();
201 }
202
203
204 void DatabaseConstraints::AddConstraint(DatabaseConstraint* constraint)
205 {
206 if (constraint == NULL)
207 {
208 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
209 }
210 else
211 {
212 constraints_.push_back(constraint);
213 }
214 }
215
216
217 const DatabaseConstraint& DatabaseConstraints::GetConstraint(size_t index) const
218 {
219 if (index >= constraints_.size())
220 {
221 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
222 }
223 else
224 {
225 assert(constraints_[index] != NULL);
226 return *constraints_[index];
227 }
228 }
229
230
231 std::string DatabaseConstraints::Format() const
232 {
233 std::string s;
234
235 for (size_t i = 0; i < constraints_.size(); i++)
236 {
237 assert(constraints_[i] != NULL);
238 const DatabaseConstraint& constraint = *constraints_[i];
239 s += "Constraint " + boost::lexical_cast<std::string>(i) + " at " + EnumerationToString(constraint.GetLevel()) +
240 ": " + constraint.GetTag().Format();
241
242 switch (constraint.GetConstraintType())
243 {
244 case ConstraintType_Equal:
245 s += " == " + constraint.GetSingleValue();
246 break;
247
248 case ConstraintType_SmallerOrEqual:
249 s += " <= " + constraint.GetSingleValue();
250 break;
251
252 case ConstraintType_GreaterOrEqual:
253 s += " >= " + constraint.GetSingleValue();
254 break;
255
256 case ConstraintType_Wildcard:
257 s += " ~~ " + constraint.GetSingleValue();
258 break;
259
260 case ConstraintType_List:
261 {
262 s += " in [ ";
263 bool first = true;
264 for (size_t j = 0; j < constraint.GetValuesCount(); j++)
265 {
266 if (first)
267 {
268 first = false;
269 }
270 else
271 {
272 s += ", ";
273 }
274 s += constraint.GetValue(j);
275 }
276 s += "]";
277 break;
278 }
279
280 default:
281 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
282 }
283
284 s += "\n";
285 }
286
287 return s;
288 }
289 }