Mercurial > hg > orthanc-databases

comparison Framework/Plugins/StorageBackend.cpp @ 219:dd6cfc250747

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
removed useless class StorageAreaBuffer
author Sebastien Jodogne <s.jodogne@gmail.com>
date Mon, 29 Mar 2021 14:52:55 +0200
parents 696bc0c9fddb
children a4918d57435c
comparison
equal deleted inserted replaced
218:90eb271f85b2 219:dd6cfc250747
81 81
82 statement.Execute(args); 82 statement.Execute(args);
83 } 83 }
84 84
85 85
86 void StorageBackend::Read(StorageAreaBuffer& target, 86 void StorageBackend::Read(StorageBackend::IFileContentVisitor& target,
87 DatabaseManager::Transaction& transaction, 87 DatabaseManager::Transaction& transaction,
88 const std::string& uuid, 88 const std::string& uuid,
89 OrthancPluginContentType type) 89 OrthancPluginContentType type)
90 { 90 {
91 DatabaseManager::CachedStatement statement( 91 DatabaseManager::CachedStatement statement(
159 int64_t size, 159 int64_t size,
160 OrthancPluginContentType type) 160 OrthancPluginContentType type)
161 { 161 {
162 try 162 try
163 { 163 {
164 if (backend_.get() == NULL)
165 {
166 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
167 }
168
164 DatabaseManager::Transaction transaction(backend_->GetManager(), TransactionType_ReadWrite); 169 DatabaseManager::Transaction transaction(backend_->GetManager(), TransactionType_ReadWrite);
165 backend_->Create(transaction, uuid, content, static_cast<size_t>(size), type); 170 backend_->Create(transaction, uuid, content, static_cast<size_t>(size), type);
166 transaction.Commit(); 171 transaction.Commit();
167 return OrthancPluginErrorCode_Success; 172 return OrthancPluginErrorCode_Success;
168 } 173 }
169 ORTHANC_PLUGINS_DATABASE_CATCH; 174 ORTHANC_PLUGINS_DATABASE_CATCH;
170 } 175 }
171 176
172 177
173 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 9, 0) 178 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 9, 0)
174 static OrthancPluginErrorCode StorageReadWhole(OrthancPluginMemoryBuffer64 *target, 179 static OrthancPluginErrorCode StorageReadWhole(OrthancPluginMemoryBuffer64* target,
175 const char* uuid, 180 const char* uuid,
176 OrthancPluginContentType type) 181 OrthancPluginContentType type)
177 { 182 {
183 class Visitor : public StorageBackend::IFileContentVisitor
184 {
185 private:
186 OrthancPluginMemoryBuffer64* target_;
187 bool success_;
188
189 public:
190 Visitor(OrthancPluginMemoryBuffer64* target) :
191 target_(target),
192 success_(false)
193 {
194 }
195
196 bool IsSuccess() const
197 {
198 return success_;
199 }
200
201 virtual void Assign(const std::string& content) ORTHANC_OVERRIDE
202 {
203 if (success_)
204 {
205 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
206 }
207 else
208 {
209 assert(context_ != NULL);
210
211 if (OrthancPluginCreateMemoryBuffer64(context_, target_, static_cast<uint64_t>(content.size())) !=
212 OrthancPluginErrorCode_Success)
213 {
214 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotEnoughMemory);
215 }
216
217 if (!content.empty())
218 {
219 memcpy(target_->data, content.c_str(), content.size());
220 }
221
222 success_ = true;
223 }
224 }
225 };
226
178 try 227 try
179 { 228 {
180 StorageAreaBuffer buffer(context_); 229 if (backend_.get() == NULL)
181 230 {
231 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
232 }
233
234 if (target == NULL)
235 {
236 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
237 }
238
239 Visitor visitor(target);
240
182 { 241 {
183 DatabaseManager::Transaction transaction(backend_->GetManager(), TransactionType_ReadOnly); 242 DatabaseManager::Transaction transaction(backend_->GetManager(), TransactionType_ReadOnly);
184 backend_->Read(buffer, transaction, uuid, type); 243 backend_->Read(visitor, transaction, uuid, type);
244
245 if (!visitor.IsSuccess())
246 {
247 throw Orthanc::OrthancException(Orthanc::ErrorCode_Database);
248 }
249
185 transaction.Commit(); 250 transaction.Commit();
186 } 251 }
187
188 buffer.Move(target);
189 252
190 return OrthancPluginErrorCode_Success; 253 return OrthancPluginErrorCode_Success;
191 } 254 }
192 ORTHANC_PLUGINS_DATABASE_CATCH; 255 ORTHANC_PLUGINS_DATABASE_CATCH;
193 } 256 }
194 #else 257 #endif
195 static OrthancPluginErrorCode StorageRead(void** content, 258
259
260 static OrthancPluginErrorCode StorageRead(void** data,
196 int64_t* size, 261 int64_t* size,
197 const char* uuid, 262 const char* uuid,
198 OrthancPluginContentType type) 263 OrthancPluginContentType type)
199 { 264 {
265 class Visitor : public StorageBackend::IFileContentVisitor
266 {
267 private:
268 void** data_;
269 int64_t* size_;
270 bool success_;
271
272 public:
273 Visitor(void** data,
274 int64_t* size) :
275 data_(data),
276 size_(size),
277 success_(false)
278 {
279 }
280
281 bool IsSuccess() const
282 {
283 return success_;
284 }
285
286 virtual void Assign(const std::string& content) ORTHANC_OVERRIDE
287 {
288 if (success_)
289 {
290 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
291 }
292 else
293 {
294 if (content.empty())
295 {
296 *data_ = NULL;
297 *size_ = 0;
298 }
299 else
300 {
301 *size_ = static_cast<int64_t>(content.size());
302
303 if (static_cast<size_t>(*size_) != content.size())
304 {
305 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotEnoughMemory,
306 "File cannot be stored in a 63bit buffer");
307 }
308
309 *data_ = malloc(*size_);
310 if (*data_ == NULL)
311 {
312 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotEnoughMemory);
313 }
314
315 memcpy(*data_, content.c_str(), *size_);
316 }
317
318 success_ = true;
319 }
320 }
321 };
322
323
200 try 324 try
201 { 325 {
202 StorageAreaBuffer buffer(context_); 326 if (backend_.get() == NULL)
327 {
328 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
329 }
330
331 if (data == NULL ||
332 size == NULL)
333 {
334 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
335 }
336
337 Visitor visitor(data, size);
203 338
204 { 339 {
205 DatabaseManager::Transaction transaction(backend_->GetManager(), TransactionType_ReadOnly); 340 DatabaseManager::Transaction transaction(backend_->GetManager(), TransactionType_ReadOnly);
206 backend_->Read(buffer, transaction, uuid, type); 341 backend_->Read(visitor, transaction, uuid, type);
342
343 if (!visitor.IsSuccess())
344 {
345 throw Orthanc::OrthancException(Orthanc::ErrorCode_Database);
346 }
347
207 transaction.Commit(); 348 transaction.Commit();
208 } 349 }
209 350
210 *size = buffer.GetSize();
211 *content = buffer.ReleaseData();
212
213 return OrthancPluginErrorCode_Success; 351 return OrthancPluginErrorCode_Success;
214 } 352 }
215 ORTHANC_PLUGINS_DATABASE_CATCH; 353 ORTHANC_PLUGINS_DATABASE_CATCH;
216 } 354 }
217 #endif
218 355
219 356
220 static OrthancPluginErrorCode StorageRemove(const char* uuid, 357 static OrthancPluginErrorCode StorageRemove(const char* uuid,
221 OrthancPluginContentType type) 358 OrthancPluginContentType type)
222 { 359 {
250 { 387 {
251 context_ = context; 388 context_ = context;
252 backend_.reset(backend); 389 backend_.reset(backend);
253 backend_->GetManager().Open(); 390 backend_->GetManager().Open();
254 391
255 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 9, 0) 392 bool hasLoadedV2 = false;
256 OrthancPluginRegisterStorageArea2(context_, StorageCreate, StorageReadWhole, 393
257 NULL /* TODO - StorageReadRange */, StorageRemove); 394 #if defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) // Macro introduced in Orthanc 1.3.1
258 #else 395 # if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 9, 0)
259 OrthancPluginRegisterStorageArea(context_, StorageCreate, StorageRead, StorageRemove); 396 if (OrthancPluginCheckVersionAdvanced(context, 1, 9, 0) == 1)
397 {
398 OrthancPluginRegisterStorageArea2(context_, StorageCreate, StorageReadWhole,
399 NULL /* TODO - StorageReadRange */, StorageRemove);
400 hasLoadedV2 = true;
401 }
402 # endif
260 #endif 403 #endif
404
405 if (!hasLoadedV2)
406 {
407 OrthancPluginRegisterStorageArea(context_, StorageCreate, StorageRead, StorageRemove);
408 }
261 } 409 }
262 } 410 }
263 411
264 412
265 void StorageBackend::Finalize() 413 void StorageBackend::Finalize()
266 { 414 {
267 backend_.reset(NULL); 415 backend_.reset(NULL);
268 context_ = NULL; 416 context_ = NULL;
269 } 417 }
418
419
420 void StorageBackend::ReadToString(std::string& target,
421 DatabaseManager::Transaction& transaction,
422 const std::string& uuid,
423 OrthancPluginContentType type)
424 {
425 class Visitor : public StorageBackend::IFileContentVisitor
426 {
427 private:
428 std::string& target_;
429 bool success_;
430
431 public:
432 Visitor(std::string& target) :
433 target_(target),
434 success_(false)
435 {
436 }
437
438 bool IsSuccess() const
439 {
440 return success_;
441 }
442
443 virtual void Assign(const std::string& content) ORTHANC_OVERRIDE
444 {
445 if (success_)
446 {
447 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
448 }
449 else
450 {
451 target_.assign(content);
452 success_ = true;
453 }
454 }
455 };
456
457
458 Visitor visitor(target);
459
460 Read(visitor, transaction, uuid, type);
461
462 if (!visitor.IsSuccess())
463 {
464 throw Orthanc::OrthancException(Orthanc::ErrorCode_Database);
465 }
466 }
270 } 467 }