Mercurial > hg > orthanc

comparison Core/JobsEngine/SetOfInstancesJob.cpp @ 2842:ff0ed5ea9e4e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 }