Mercurial > hg > orthanc
comparison Core/JobsEngine/SetOfInstancesJob.cpp @ 2842:ff0ed5ea9e4e
trailing step in SetOfInstancesJob
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Wed, 26 Sep 2018 15:55:42 +0200 |
parents | ea7aea6f6a95 |
children | 8b00e4cb4a6b |
comparison
equal
deleted
inserted
replaced
2841:bf019ee38498 | 2842:ff0ed5ea9e4e |
---|---|
37 #include "../OrthancException.h" | 37 #include "../OrthancException.h" |
38 #include "../SerializationToolbox.h" | 38 #include "../SerializationToolbox.h" |
39 | 39 |
40 namespace Orthanc | 40 namespace Orthanc |
41 { | 41 { |
42 SetOfInstancesJob::SetOfInstancesJob() : | 42 SetOfInstancesJob::SetOfInstancesJob(bool hasTrailingStep) : |
43 hasTrailingStep_(hasTrailingStep), | |
43 started_(false), | 44 started_(false), |
44 permissive_(false), | 45 permissive_(false), |
45 position_(0) | 46 position_(0) |
46 { | 47 { |
47 } | 48 } |
58 instances_.reserve(size); | 59 instances_.reserve(size); |
59 } | 60 } |
60 } | 61 } |
61 | 62 |
62 | 63 |
64 size_t SetOfInstancesJob::GetStepsCount() const | |
65 { | |
66 if (HasTrailingStep()) | |
67 { | |
68 return instances_.size() + 1; | |
69 } | |
70 else | |
71 { | |
72 return instances_.size(); | |
73 } | |
74 } | |
75 | |
76 | |
63 void SetOfInstancesJob::AddInstance(const std::string& instance) | 77 void SetOfInstancesJob::AddInstance(const std::string& instance) |
64 { | 78 { |
65 if (started_) | 79 if (started_) |
66 { | 80 { |
67 throw OrthancException(ErrorCode_BadSequenceOfCalls); | 81 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
73 } | 87 } |
74 | 88 |
75 | 89 |
76 void SetOfInstancesJob::SetPermissive(bool permissive) | 90 void SetOfInstancesJob::SetPermissive(bool permissive) |
77 { | 91 { |
78 if (IsStarted()) | 92 if (started_) |
79 { | 93 { |
80 throw OrthancException(ErrorCode_BadSequenceOfCalls); | 94 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
81 } | 95 } |
82 else | 96 else |
83 { | 97 { |
100 } | 114 } |
101 | 115 |
102 | 116 |
103 float SetOfInstancesJob::GetProgress() | 117 float SetOfInstancesJob::GetProgress() |
104 { | 118 { |
105 if (instances_.size() == 0) | 119 const size_t steps = GetStepsCount(); |
120 | |
121 if (steps == 0) | |
106 { | 122 { |
107 return 0; | 123 return 0; |
108 } | 124 } |
109 else | 125 else |
110 { | 126 { |
111 return (static_cast<float>(position_) / | 127 return (static_cast<float>(position_) / |
112 static_cast<float>(instances_.size())); | 128 static_cast<float>(steps)); |
113 } | 129 } |
114 } | 130 } |
115 | 131 |
116 | 132 |
117 const std::string& SetOfInstancesJob::GetInstance(size_t index) const | 133 const std::string& SetOfInstancesJob::GetInstance(size_t index) const |
118 { | 134 { |
119 if (index > instances_.size()) | 135 if (index >= instances_.size()) |
120 { | 136 { |
121 throw OrthancException(ErrorCode_ParameterOutOfRange); | 137 throw OrthancException(ErrorCode_ParameterOutOfRange); |
122 } | 138 } |
123 else | 139 else |
124 { | 140 { |
132 if (!started_) | 148 if (!started_) |
133 { | 149 { |
134 throw OrthancException(ErrorCode_InternalError); | 150 throw OrthancException(ErrorCode_InternalError); |
135 } | 151 } |
136 | 152 |
137 if (instances_.empty() && | 153 const size_t steps = GetStepsCount(); |
154 | |
155 if (steps == 0 && | |
138 position_ == 0) | 156 position_ == 0) |
139 { | 157 { |
140 // No instance to handle, we're done | 158 // Nothing to handle (no instance, nor trailing step): We're done |
141 position_ = 1; | 159 position_ = 1; |
142 return JobStepResult::Success(); | 160 return JobStepResult::Success(); |
143 } | 161 } |
144 | 162 |
145 if (position_ >= instances_.size()) | 163 if (position_ >= steps) |
146 { | 164 { |
147 // Already done | 165 // Already done |
148 throw OrthancException(ErrorCode_BadSequenceOfCalls); | 166 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
149 } | 167 } |
150 | 168 |
151 const std::string currentInstance = instances_[position_]; | 169 bool isTrailingStep = (hasTrailingStep_ && |
170 position_ + 1 == steps); | |
152 | 171 |
153 bool ok; | 172 bool ok; |
154 | 173 |
155 try | 174 try |
156 { | 175 { |
157 ok = HandleInstance(currentInstance); | 176 if (isTrailingStep) |
177 { | |
178 ok = HandleTrailingStep(); | |
179 } | |
180 else | |
181 { | |
182 // Not at the trailing step: Handle the current instance | |
183 ok = HandleInstance(instances_[position_]); | |
184 } | |
158 | 185 |
159 if (!ok && !permissive_) | 186 if (!ok && !permissive_) |
160 { | 187 { |
161 return JobStepResult::Failure(ErrorCode_InternalError); | 188 return JobStepResult::Failure(ErrorCode_InternalError); |
162 } | 189 } |
171 { | 198 { |
172 throw; | 199 throw; |
173 } | 200 } |
174 } | 201 } |
175 | 202 |
176 if (!ok) | 203 if (!ok && |
177 { | 204 !isTrailingStep) |
178 failedInstances_.insert(currentInstance); | 205 { |
206 failedInstances_.insert(instances_[position_]); | |
179 } | 207 } |
180 | 208 |
181 position_ += 1; | 209 position_ += 1; |
182 | 210 |
183 if (position_ == instances_.size()) | 211 if (position_ == steps) |
184 { | 212 { |
185 // We're done | 213 // We're done |
186 return JobStepResult::Success(); | 214 return JobStepResult::Success(); |
187 } | 215 } |
188 else | 216 else |
189 { | 217 { |
190 return JobStepResult::Continue(); | 218 return JobStepResult::Continue(); |
191 } | 219 } |
192 } | 220 } |
193 | 221 |
194 | 222 |
223 | |
224 static const char* KEY_DESCRIPTION = "Description"; | |
225 static const char* KEY_PERMISSIVE = "Permissive"; | |
226 static const char* KEY_POSITION = "Position"; | |
227 static const char* KEY_TYPE = "Type"; | |
228 static const char* KEY_INSTANCES = "Instances"; | |
229 static const char* KEY_FAILED_INSTANCES = "FailedInstances"; | |
230 static const char* KEY_TRAILING_STEP = "TrailingStep"; | |
231 | |
232 | |
195 void SetOfInstancesJob::GetPublicContent(Json::Value& value) | 233 void SetOfInstancesJob::GetPublicContent(Json::Value& value) |
196 { | 234 { |
197 value["Description"] = GetDescription(); | 235 value[KEY_DESCRIPTION] = GetDescription(); |
198 value["InstancesCount"] = static_cast<uint32_t>(instances_.size()); | 236 value["InstancesCount"] = static_cast<uint32_t>(instances_.size()); |
199 value["FailedInstancesCount"] = static_cast<uint32_t>(failedInstances_.size()); | 237 value["FailedInstancesCount"] = static_cast<uint32_t>(failedInstances_.size()); |
200 } | 238 } |
201 | 239 |
202 | 240 |
204 { | 242 { |
205 value = Json::objectValue; | 243 value = Json::objectValue; |
206 | 244 |
207 std::string type; | 245 std::string type; |
208 GetJobType(type); | 246 GetJobType(type); |
209 value["Type"] = type; | 247 value[KEY_TYPE] = type; |
210 | 248 |
211 value["Permissive"] = permissive_; | 249 value[KEY_PERMISSIVE] = permissive_; |
212 value["Position"] = static_cast<unsigned int>(position_); | 250 value[KEY_POSITION] = static_cast<unsigned int>(position_); |
213 value["Description"] = description_; | 251 value[KEY_DESCRIPTION] = description_; |
214 | 252 value[KEY_TRAILING_STEP] = hasTrailingStep_; |
215 SerializationToolbox::WriteArrayOfStrings(value, instances_, "Instances"); | 253 |
216 SerializationToolbox::WriteSetOfStrings(value, failedInstances_, "FailedInstances"); | 254 SerializationToolbox::WriteArrayOfStrings(value, instances_, KEY_INSTANCES); |
255 SerializationToolbox::WriteSetOfStrings(value, failedInstances_, KEY_FAILED_INSTANCES); | |
217 | 256 |
218 return true; | 257 return true; |
219 } | 258 } |
220 | 259 |
221 | 260 |
222 SetOfInstancesJob::SetOfInstancesJob(const Json::Value& value) : | 261 SetOfInstancesJob::SetOfInstancesJob(const Json::Value& value) : |
223 started_(false), | 262 started_(false), |
224 permissive_(SerializationToolbox::ReadBoolean(value, "Permissive")), | 263 permissive_(SerializationToolbox::ReadBoolean(value, KEY_PERMISSIVE)), |
225 position_(SerializationToolbox::ReadUnsignedInteger(value, "Position")), | 264 position_(SerializationToolbox::ReadUnsignedInteger(value, KEY_POSITION)), |
226 description_(SerializationToolbox::ReadString(value, "Description")) | 265 description_(SerializationToolbox::ReadString(value, KEY_DESCRIPTION)) |
227 { | 266 { |
228 SerializationToolbox::ReadArrayOfStrings(instances_, value, "Instances"); | 267 SerializationToolbox::ReadArrayOfStrings(instances_, value, KEY_INSTANCES); |
229 SerializationToolbox::ReadSetOfStrings(failedInstances_, value, "FailedInstances"); | 268 SerializationToolbox::ReadSetOfStrings(failedInstances_, value, KEY_FAILED_INSTANCES); |
230 | 269 |
231 if (position_ > instances_.size()) | 270 if (value.isMember(KEY_TRAILING_STEP)) |
271 { | |
272 hasTrailingStep_ = SerializationToolbox::ReadBoolean(value, KEY_TRAILING_STEP); | |
273 } | |
274 else | |
275 { | |
276 // Backward compatibility with Orthanc <= 1.4.2 | |
277 hasTrailingStep_ = false; | |
278 } | |
279 | |
280 if (position_ > GetStepsCount() + 1) | |
232 { | 281 { |
233 throw OrthancException(ErrorCode_BadFileFormat); | 282 throw OrthancException(ErrorCode_BadFileFormat); |
234 } | 283 } |
235 } | 284 } |
236 } | 285 } |