Mercurial > hg > orthanc-databases

comparison Framework/Plugins/DatabaseBackendAdapterV2.cpp @ 224:61c309e06797

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
added internal class DatabaseBackendAdapterV2::Adapter
author Sebastien Jodogne <s.jodogne@gmail.com>
date Thu, 01 Apr 2021 16:09:59 +0200
parents c8e06b41feec
children 94c9908e6aca
comparison
equal deleted inserted replaced
223:af049cd66661 224:61c309e06797
23 #include "DatabaseBackendAdapterV2.h" 23 #include "DatabaseBackendAdapterV2.h"
24 #include "GlobalProperties.h" 24 #include "GlobalProperties.h"
25 25
26 #include <OrthancException.h> 26 #include <OrthancException.h>
27 27
28 #include <boost/thread/mutex.hpp>
29 #include <list>
28 #include <stdexcept> 30 #include <stdexcept>
29 #include <list>
30 #include <string> 31 #include <string>
31 32
32 33
33 #define ORTHANC_PLUGINS_DATABASE_CATCH \ 34 #define ORTHANC_PLUGINS_DATABASE_CATCH \
34 catch (::Orthanc::OrthancException& e) \ 35 catch (::Orthanc::OrthancException& e) \
35 { \ 36 { \
36 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \ 37 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \
37 } \ 38 } \
38 catch (::std::runtime_error& e) \ 39 catch (::std::runtime_error& e) \
39 { \ 40 { \
40 LogError(backend, e); \ 41 LogError(adapter->GetBackend(), e); \
41 return OrthancPluginErrorCode_DatabasePlugin; \ 42 return OrthancPluginErrorCode_DatabasePlugin; \
42 } \ 43 } \
43 catch (...) \ 44 catch (...) \
44 { \ 45 { \
45 OrthancPluginLogError(backend->GetContext(), "Native exception"); \ 46 OrthancPluginLogError(adapter->GetBackend().GetContext(), "Native exception"); \
46 return OrthancPluginErrorCode_DatabasePlugin; \ 47 return OrthancPluginErrorCode_DatabasePlugin; \
47 } 48 }
48 49
49 50
50 namespace OrthancDatabases 51 namespace OrthancDatabases
51 { 52 {
53 class DatabaseBackendAdapterV2::Adapter : public boost::noncopyable
54 {
55 private:
56 std::unique_ptr<IDatabaseBackend> backend_;
57 boost::mutex databaseMutex_;
58 std::unique_ptr<DatabaseManager> database_;
59
60 public:
61 Adapter(IDatabaseBackend* backend) :
62 backend_(backend)
63 {
64 if (backend == NULL)
65 {
66 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
67 }
68 }
69
70 IDatabaseBackend& GetBackend() const
71 {
72 return *backend_;
73 }
74
75 void OpenConnection()
76 {
77 boost::mutex::scoped_lock lock(databaseMutex_);
78
79 if (database_.get() == NULL)
80 {
81 database_.reset(new DatabaseManager(backend_->CreateDatabaseFactory()));
82 database_->Open();
83 }
84 else
85 {
86 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
87 }
88 }
89
90 void CloseConnection()
91 {
92 boost::mutex::scoped_lock lock(databaseMutex_);
93
94 if (database_.get() == NULL)
95 {
96 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
97 }
98 else
99 {
100 database_->Close();
101 database_.reset(NULL);
102 }
103 }
104
105 class DatabaseAccessor : public boost::noncopyable
106 {
107 private:
108 boost::mutex::scoped_lock lock_;
109 DatabaseManager* database_;
110
111 public:
112 DatabaseAccessor(Adapter& adapter) :
113 lock_(adapter.databaseMutex_),
114 database_(adapter.database_.get())
115 {
116 if (database_ == NULL)
117 {
118 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
119 }
120 }
121
122 DatabaseManager& GetDatabase() const
123 {
124 assert(database_ != NULL);
125 return *database_;
126 }
127 };
128 };
129
130
52 class DatabaseBackendAdapterV2::Output : public IDatabaseBackendOutput 131 class DatabaseBackendAdapterV2::Output : public IDatabaseBackendOutput
53 { 132 {
54 public: 133 public:
55 enum AllowedAnswers 134 enum AllowedAnswers
56 { 135 {
254 } 333 }
255 #endif 334 #endif
256 }; 335 };
257 336
258 337
259 static void LogError(IDatabaseBackend* backend, 338 static void LogError(IDatabaseBackend& backend,
260 const std::runtime_error& e) 339 const std::runtime_error& e)
261 { 340 {
262 const std::string message = "Exception in database back-end: " + std::string(e.what()); 341 const std::string message = "Exception in database back-end: " + std::string(e.what());
263 OrthancPluginLogError(backend->GetContext(), message.c_str()); 342 OrthancPluginLogError(backend.GetContext(), message.c_str());
264 } 343 }
265 344
266 345
267 static OrthancPluginErrorCode AddAttachment(void* payload, 346 static OrthancPluginErrorCode AddAttachment(void* payload,
268 int64_t id, 347 int64_t id,
269 const OrthancPluginAttachment* attachment) 348 const OrthancPluginAttachment* attachment)
270 { 349 {
271 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 350 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
272 351
273 try 352 try
274 { 353 {
275 backend->AddAttachment(id, *attachment); 354 //DatabaseBackendAdapterV2::Adapter::DatabaseAccessor accessor(*adapter); // TODO
355
356 adapter->GetBackend().AddAttachment(id, *attachment);
276 return OrthancPluginErrorCode_Success; 357 return OrthancPluginErrorCode_Success;
277 } 358 }
278 ORTHANC_PLUGINS_DATABASE_CATCH; 359 ORTHANC_PLUGINS_DATABASE_CATCH;
279 } 360 }
280 361
281 362
282 static OrthancPluginErrorCode AttachChild(void* payload, 363 static OrthancPluginErrorCode AttachChild(void* payload,
283 int64_t parent, 364 int64_t parent,
284 int64_t child) 365 int64_t child)
285 { 366 {
286 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 367 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
287 368
288 try 369 try
289 { 370 {
290 backend->AttachChild(parent, child); 371 adapter->GetBackend().AttachChild(parent, child);
291 return OrthancPluginErrorCode_Success; 372 return OrthancPluginErrorCode_Success;
292 } 373 }
293 ORTHANC_PLUGINS_DATABASE_CATCH; 374 ORTHANC_PLUGINS_DATABASE_CATCH;
294 } 375 }
295 376
296 377
297 static OrthancPluginErrorCode ClearChanges(void* payload) 378 static OrthancPluginErrorCode ClearChanges(void* payload)
298 { 379 {
299 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 380 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
300 381
301 try 382 try
302 { 383 {
303 backend->ClearChanges(); 384 adapter->GetBackend().ClearChanges();
304 return OrthancPluginErrorCode_Success; 385 return OrthancPluginErrorCode_Success;
305 } 386 }
306 ORTHANC_PLUGINS_DATABASE_CATCH; 387 ORTHANC_PLUGINS_DATABASE_CATCH;
307 } 388 }
308 389
309 390
310 static OrthancPluginErrorCode ClearExportedResources(void* payload) 391 static OrthancPluginErrorCode ClearExportedResources(void* payload)
311 { 392 {
312 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 393 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
313 394
314 try 395 try
315 { 396 {
316 backend->ClearExportedResources(); 397 adapter->GetBackend().ClearExportedResources();
317 return OrthancPluginErrorCode_Success; 398 return OrthancPluginErrorCode_Success;
318 } 399 }
319 ORTHANC_PLUGINS_DATABASE_CATCH; 400 ORTHANC_PLUGINS_DATABASE_CATCH;
320 } 401 }
321 402
323 static OrthancPluginErrorCode CreateResource(int64_t* id, 404 static OrthancPluginErrorCode CreateResource(int64_t* id,
324 void* payload, 405 void* payload,
325 const char* publicId, 406 const char* publicId,
326 OrthancPluginResourceType resourceType) 407 OrthancPluginResourceType resourceType)
327 { 408 {
328 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 409 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
329 410
330 try 411 try
331 { 412 {
332 *id = backend->CreateResource(publicId, resourceType); 413 *id = adapter->GetBackend().CreateResource(publicId, resourceType);
333 return OrthancPluginErrorCode_Success; 414 return OrthancPluginErrorCode_Success;
334 } 415 }
335 ORTHANC_PLUGINS_DATABASE_CATCH; 416 ORTHANC_PLUGINS_DATABASE_CATCH;
336 } 417 }
337 418
338 419
339 static OrthancPluginErrorCode DeleteAttachment(void* payload, 420 static OrthancPluginErrorCode DeleteAttachment(void* payload,
340 int64_t id, 421 int64_t id,
341 int32_t contentType) 422 int32_t contentType)
342 { 423 {
343 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 424 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
344 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 425 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
345 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 426 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
346 427
347 try 428 try
348 { 429 {
349 backend->DeleteAttachment(*output, id, contentType); 430 adapter->GetBackend().DeleteAttachment(*output, id, contentType);
350 return OrthancPluginErrorCode_Success; 431 return OrthancPluginErrorCode_Success;
351 } 432 }
352 ORTHANC_PLUGINS_DATABASE_CATCH; 433 ORTHANC_PLUGINS_DATABASE_CATCH;
353 } 434 }
354 435
355 436
356 static OrthancPluginErrorCode DeleteMetadata(void* payload, 437 static OrthancPluginErrorCode DeleteMetadata(void* payload,
357 int64_t id, 438 int64_t id,
358 int32_t metadataType) 439 int32_t metadataType)
359 { 440 {
360 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 441 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
361 442
362 try 443 try
363 { 444 {
364 backend->DeleteMetadata(id, metadataType); 445 adapter->GetBackend().DeleteMetadata(id, metadataType);
365 return OrthancPluginErrorCode_Success; 446 return OrthancPluginErrorCode_Success;
366 } 447 }
367 ORTHANC_PLUGINS_DATABASE_CATCH; 448 ORTHANC_PLUGINS_DATABASE_CATCH;
368 } 449 }
369 450
370 451
371 static OrthancPluginErrorCode DeleteResource(void* payload, 452 static OrthancPluginErrorCode DeleteResource(void* payload,
372 int64_t id) 453 int64_t id)
373 { 454 {
374 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 455 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
375 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 456 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
376 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 457 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
377 458
378 try 459 try
379 { 460 {
380 backend->DeleteResource(*output, id); 461 adapter->GetBackend().DeleteResource(*output, id);
381 return OrthancPluginErrorCode_Success; 462 return OrthancPluginErrorCode_Success;
382 } 463 }
383 ORTHANC_PLUGINS_DATABASE_CATCH; 464 ORTHANC_PLUGINS_DATABASE_CATCH;
384 } 465 }
385 466
386 467
387 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context, 468 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context,
388 void* payload, 469 void* payload,
389 OrthancPluginResourceType resourceType) 470 OrthancPluginResourceType resourceType)
390 { 471 {
391 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 472 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
392 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 473 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
393 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 474 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
394 475
395 try 476 try
396 { 477 {
397 std::list<int64_t> target; 478 std::list<int64_t> target;
398 backend->GetAllInternalIds(target, resourceType); 479 adapter->GetBackend().GetAllInternalIds(target, resourceType);
399 480
400 for (std::list<int64_t>::const_iterator 481 for (std::list<int64_t>::const_iterator
401 it = target.begin(); it != target.end(); ++it) 482 it = target.begin(); it != target.end(); ++it)
402 { 483 {
403 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 484 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
404 output->GetDatabase(), *it); 485 output->GetDatabase(), *it);
405 } 486 }
406 487
407 return OrthancPluginErrorCode_Success; 488 return OrthancPluginErrorCode_Success;
408 } 489 }
412 493
413 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context, 494 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context,
414 void* payload, 495 void* payload,
415 OrthancPluginResourceType resourceType) 496 OrthancPluginResourceType resourceType)
416 { 497 {
417 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 498 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
418 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 499 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
419 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 500 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
420 501
421 try 502 try
422 { 503 {
423 std::list<std::string> ids; 504 std::list<std::string> ids;
424 backend->GetAllPublicIds(ids, resourceType); 505 adapter->GetBackend().GetAllPublicIds(ids, resourceType);
425 506
426 for (std::list<std::string>::const_iterator 507 for (std::list<std::string>::const_iterator
427 it = ids.begin(); it != ids.end(); ++it) 508 it = ids.begin(); it != ids.end(); ++it)
428 { 509 {
429 OrthancPluginDatabaseAnswerString(backend->GetContext(), 510 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
430 output->GetDatabase(), 511 output->GetDatabase(),
431 it->c_str()); 512 it->c_str());
432 } 513 }
433 514
434 return OrthancPluginErrorCode_Success; 515 return OrthancPluginErrorCode_Success;
441 void* payload, 522 void* payload,
442 OrthancPluginResourceType resourceType, 523 OrthancPluginResourceType resourceType,
443 uint64_t since, 524 uint64_t since,
444 uint64_t limit) 525 uint64_t limit)
445 { 526 {
446 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 527 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
447 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 528 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
448 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 529 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
449 530
450 try 531 try
451 { 532 {
452 std::list<std::string> ids; 533 std::list<std::string> ids;
453 backend->GetAllPublicIds(ids, resourceType, since, limit); 534 adapter->GetBackend().GetAllPublicIds(ids, resourceType, since, limit);
454 535
455 for (std::list<std::string>::const_iterator 536 for (std::list<std::string>::const_iterator
456 it = ids.begin(); it != ids.end(); ++it) 537 it = ids.begin(); it != ids.end(); ++it)
457 { 538 {
458 OrthancPluginDatabaseAnswerString(backend->GetContext(), 539 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
459 output->GetDatabase(), 540 output->GetDatabase(),
460 it->c_str()); 541 it->c_str());
461 } 542 }
462 543
463 return OrthancPluginErrorCode_Success; 544 return OrthancPluginErrorCode_Success;
469 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context, 550 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context,
470 void* payload, 551 void* payload,
471 int64_t since, 552 int64_t since,
472 uint32_t maxResult) 553 uint32_t maxResult)
473 { 554 {
474 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 555 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
475 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 556 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
476 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change); 557 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change);
477 558
478 try 559 try
479 { 560 {
480 bool done; 561 bool done;
481 backend->GetChanges(*output, done, since, maxResult); 562 adapter->GetBackend().GetChanges(*output, done, since, maxResult);
482 563
483 if (done) 564 if (done)
484 { 565 {
485 OrthancPluginDatabaseAnswerChangesDone(backend->GetContext(), 566 OrthancPluginDatabaseAnswerChangesDone(adapter->GetBackend().GetContext(),
486 output->GetDatabase()); 567 output->GetDatabase());
487 } 568 }
488 569
489 return OrthancPluginErrorCode_Success; 570 return OrthancPluginErrorCode_Success;
490 } 571 }
494 575
495 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context, 576 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context,
496 void* payload, 577 void* payload,
497 int64_t id) 578 int64_t id)
498 { 579 {
499 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 580 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
500 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 581 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
501 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 582 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
502 583
503 try 584 try
504 { 585 {
505 std::list<int64_t> target; 586 std::list<int64_t> target;
506 backend->GetChildrenInternalId(target, id); 587 adapter->GetBackend().GetChildrenInternalId(target, id);
507 588
508 for (std::list<int64_t>::const_iterator 589 for (std::list<int64_t>::const_iterator
509 it = target.begin(); it != target.end(); ++it) 590 it = target.begin(); it != target.end(); ++it)
510 { 591 {
511 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 592 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
512 output->GetDatabase(), *it); 593 output->GetDatabase(), *it);
513 } 594 }
514 595
515 return OrthancPluginErrorCode_Success; 596 return OrthancPluginErrorCode_Success;
516 } 597 }
520 601
521 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context, 602 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context,
522 void* payload, 603 void* payload,
523 int64_t id) 604 int64_t id)
524 { 605 {
525 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 606 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
526 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 607 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
527 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 608 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
528 609
529 try 610 try
530 { 611 {
531 std::list<std::string> ids; 612 std::list<std::string> ids;
532 backend->GetChildrenPublicId(ids, id); 613 adapter->GetBackend().GetChildrenPublicId(ids, id);
533 614
534 for (std::list<std::string>::const_iterator 615 for (std::list<std::string>::const_iterator
535 it = ids.begin(); it != ids.end(); ++it) 616 it = ids.begin(); it != ids.end(); ++it)
536 { 617 {
537 OrthancPluginDatabaseAnswerString(backend->GetContext(), 618 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
538 output->GetDatabase(), 619 output->GetDatabase(),
539 it->c_str()); 620 it->c_str());
540 } 621 }
541 622
542 return OrthancPluginErrorCode_Success; 623 return OrthancPluginErrorCode_Success;
548 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context, 629 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context,
549 void* payload, 630 void* payload,
550 int64_t since, 631 int64_t since,
551 uint32_t maxResult) 632 uint32_t maxResult)
552 { 633 {
553 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 634 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
554 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 635 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
555 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource); 636 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource);
556 637
557 try 638 try
558 { 639 {
559 bool done; 640 bool done;
560 backend->GetExportedResources(*output, done, since, maxResult); 641 adapter->GetBackend().GetExportedResources(*output, done, since, maxResult);
561 642
562 if (done) 643 if (done)
563 { 644 {
564 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetContext(), 645 OrthancPluginDatabaseAnswerExportedResourcesDone(adapter->GetBackend().GetContext(),
565 output->GetDatabase()); 646 output->GetDatabase());
566 } 647 }
567 return OrthancPluginErrorCode_Success; 648 return OrthancPluginErrorCode_Success;
568 } 649 }
569 ORTHANC_PLUGINS_DATABASE_CATCH; 650 ORTHANC_PLUGINS_DATABASE_CATCH;
571 652
572 653
573 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context, 654 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context,
574 void* payload) 655 void* payload)
575 { 656 {
576 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 657 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
577 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 658 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
578 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change); 659 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Change);
579 660
580 try 661 try
581 { 662 {
582 backend->GetLastChange(*output); 663 adapter->GetBackend().GetLastChange(*output);
583 return OrthancPluginErrorCode_Success; 664 return OrthancPluginErrorCode_Success;
584 } 665 }
585 ORTHANC_PLUGINS_DATABASE_CATCH; 666 ORTHANC_PLUGINS_DATABASE_CATCH;
586 } 667 }
587 668
588 669
589 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context, 670 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context,
590 void* payload) 671 void* payload)
591 { 672 {
592 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 673 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
593 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 674 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
594 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource); 675 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_ExportedResource);
595 676
596 try 677 try
597 { 678 {
598 backend->GetLastExportedResource(*output); 679 adapter->GetBackend().GetLastExportedResource(*output);
599 return OrthancPluginErrorCode_Success; 680 return OrthancPluginErrorCode_Success;
600 } 681 }
601 ORTHANC_PLUGINS_DATABASE_CATCH; 682 ORTHANC_PLUGINS_DATABASE_CATCH;
602 } 683 }
603 684
604 685
605 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context, 686 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context,
606 void* payload, 687 void* payload,
607 int64_t id) 688 int64_t id)
608 { 689 {
609 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 690 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
610 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 691 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
611 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_DicomTag); 692 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_DicomTag);
612 693
613 try 694 try
614 { 695 {
615 backend->GetMainDicomTags(*output, id); 696 adapter->GetBackend().GetMainDicomTags(*output, id);
616 return OrthancPluginErrorCode_Success; 697 return OrthancPluginErrorCode_Success;
617 } 698 }
618 ORTHANC_PLUGINS_DATABASE_CATCH; 699 ORTHANC_PLUGINS_DATABASE_CATCH;
619 } 700 }
620 701
621 702
622 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context, 703 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context,
623 void* payload, 704 void* payload,
624 int64_t id) 705 int64_t id)
625 { 706 {
626 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 707 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
627 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 708 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
628 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 709 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
629 710
630 try 711 try
631 { 712 {
632 std::string s = backend->GetPublicId(id); 713 std::string s = adapter->GetBackend().GetPublicId(id);
633 OrthancPluginDatabaseAnswerString(backend->GetContext(), 714 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
634 output->GetDatabase(), 715 output->GetDatabase(),
635 s.c_str()); 716 s.c_str());
636 717
637 return OrthancPluginErrorCode_Success; 718 return OrthancPluginErrorCode_Success;
638 } 719 }
642 723
643 static OrthancPluginErrorCode GetResourceCount(uint64_t* target, 724 static OrthancPluginErrorCode GetResourceCount(uint64_t* target,
644 void* payload, 725 void* payload,
645 OrthancPluginResourceType resourceType) 726 OrthancPluginResourceType resourceType)
646 { 727 {
647 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 728 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
648 729
649 try 730 try
650 { 731 {
651 *target = backend->GetResourcesCount(resourceType); 732 *target = adapter->GetBackend().GetResourcesCount(resourceType);
652 return OrthancPluginErrorCode_Success; 733 return OrthancPluginErrorCode_Success;
653 } 734 }
654 ORTHANC_PLUGINS_DATABASE_CATCH; 735 ORTHANC_PLUGINS_DATABASE_CATCH;
655 } 736 }
656 737
657 738
658 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType, 739 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType,
659 void* payload, 740 void* payload,
660 int64_t id) 741 int64_t id)
661 { 742 {
662 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 743 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
663 744
664 try 745 try
665 { 746 {
666 *resourceType = backend->GetResourceType(id); 747 *resourceType = adapter->GetBackend().GetResourceType(id);
667 return OrthancPluginErrorCode_Success; 748 return OrthancPluginErrorCode_Success;
668 } 749 }
669 ORTHANC_PLUGINS_DATABASE_CATCH; 750 ORTHANC_PLUGINS_DATABASE_CATCH;
670 } 751 }
671 752
672 753
673 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target, 754 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target,
674 void* payload) 755 void* payload)
675 { 756 {
676 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 757 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
677 758
678 try 759 try
679 { 760 {
680 *target = backend->GetTotalCompressedSize(); 761 *target = adapter->GetBackend().GetTotalCompressedSize();
681 return OrthancPluginErrorCode_Success; 762 return OrthancPluginErrorCode_Success;
682 } 763 }
683 ORTHANC_PLUGINS_DATABASE_CATCH; 764 ORTHANC_PLUGINS_DATABASE_CATCH;
684 } 765 }
685 766
686 767
687 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target, 768 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target,
688 void* payload) 769 void* payload)
689 { 770 {
690 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 771 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
691 772
692 try 773 try
693 { 774 {
694 *target = backend->GetTotalUncompressedSize(); 775 *target = adapter->GetBackend().GetTotalUncompressedSize();
695 return OrthancPluginErrorCode_Success; 776 return OrthancPluginErrorCode_Success;
696 } 777 }
697 ORTHANC_PLUGINS_DATABASE_CATCH; 778 ORTHANC_PLUGINS_DATABASE_CATCH;
698 } 779 }
699 780
700 781
701 static OrthancPluginErrorCode IsExistingResource(int32_t* existing, 782 static OrthancPluginErrorCode IsExistingResource(int32_t* existing,
702 void* payload, 783 void* payload,
703 int64_t id) 784 int64_t id)
704 { 785 {
705 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 786 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
706 787
707 try 788 try
708 { 789 {
709 *existing = backend->IsExistingResource(id); 790 *existing = adapter->GetBackend().IsExistingResource(id);
710 return OrthancPluginErrorCode_Success; 791 return OrthancPluginErrorCode_Success;
711 } 792 }
712 ORTHANC_PLUGINS_DATABASE_CATCH; 793 ORTHANC_PLUGINS_DATABASE_CATCH;
713 } 794 }
714 795
715 796
716 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected, 797 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected,
717 void* payload, 798 void* payload,
718 int64_t id) 799 int64_t id)
719 { 800 {
720 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 801 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
721 802
722 try 803 try
723 { 804 {
724 *isProtected = backend->IsProtectedPatient(id); 805 *isProtected = adapter->GetBackend().IsProtectedPatient(id);
725 return OrthancPluginErrorCode_Success; 806 return OrthancPluginErrorCode_Success;
726 } 807 }
727 ORTHANC_PLUGINS_DATABASE_CATCH; 808 ORTHANC_PLUGINS_DATABASE_CATCH;
728 } 809 }
729 810
730 811
731 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context, 812 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context,
732 void* payload, 813 void* payload,
733 int64_t id) 814 int64_t id)
734 { 815 {
735 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 816 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
736 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 817 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
737 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 818 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
738 819
739 try 820 try
740 { 821 {
741 std::list<int32_t> target; 822 std::list<int32_t> target;
742 backend->ListAvailableMetadata(target, id); 823 adapter->GetBackend().ListAvailableMetadata(target, id);
743 824
744 for (std::list<int32_t>::const_iterator 825 for (std::list<int32_t>::const_iterator
745 it = target.begin(); it != target.end(); ++it) 826 it = target.begin(); it != target.end(); ++it)
746 { 827 {
747 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), 828 OrthancPluginDatabaseAnswerInt32(adapter->GetBackend().GetContext(),
748 output->GetDatabase(), 829 output->GetDatabase(),
749 *it); 830 *it);
750 } 831 }
751 832
752 return OrthancPluginErrorCode_Success; 833 return OrthancPluginErrorCode_Success;
757 838
758 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context, 839 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context,
759 void* payload, 840 void* payload,
760 int64_t id) 841 int64_t id)
761 { 842 {
762 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 843 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
763 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 844 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
764 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 845 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
765 846
766 try 847 try
767 { 848 {
768 std::list<int32_t> target; 849 std::list<int32_t> target;
769 backend->ListAvailableAttachments(target, id); 850 adapter->GetBackend().ListAvailableAttachments(target, id);
770 851
771 for (std::list<int32_t>::const_iterator 852 for (std::list<int32_t>::const_iterator
772 it = target.begin(); it != target.end(); ++it) 853 it = target.begin(); it != target.end(); ++it)
773 { 854 {
774 OrthancPluginDatabaseAnswerInt32(backend->GetContext(), 855 OrthancPluginDatabaseAnswerInt32(adapter->GetBackend().GetContext(),
775 output->GetDatabase(), 856 output->GetDatabase(),
776 *it); 857 *it);
777 } 858 }
778 859
779 return OrthancPluginErrorCode_Success; 860 return OrthancPluginErrorCode_Success;
783 864
784 865
785 static OrthancPluginErrorCode LogChange(void* payload, 866 static OrthancPluginErrorCode LogChange(void* payload,
786 const OrthancPluginChange* change) 867 const OrthancPluginChange* change)
787 { 868 {
788 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 869 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
789 870
790 try 871 try
791 { 872 {
792 int64_t id; 873 int64_t id;
793 OrthancPluginResourceType type; 874 OrthancPluginResourceType type;
794 if (!backend->LookupResource(id, type, change->publicId) || 875 if (!adapter->GetBackend().LookupResource(id, type, change->publicId) ||
795 type != change->resourceType) 876 type != change->resourceType)
796 { 877 {
797 throw Orthanc::OrthancException(Orthanc::ErrorCode_Database); 878 throw Orthanc::OrthancException(Orthanc::ErrorCode_Database);
798 } 879 }
799 else 880 else
800 { 881 {
801 backend->LogChange(change->changeType, id, type, change->date); 882 adapter->GetBackend().LogChange(change->changeType, id, type, change->date);
802 } 883 }
803 884
804 return OrthancPluginErrorCode_Success; 885 return OrthancPluginErrorCode_Success;
805 } 886 }
806 ORTHANC_PLUGINS_DATABASE_CATCH; 887 ORTHANC_PLUGINS_DATABASE_CATCH;
808 889
809 890
810 static OrthancPluginErrorCode LogExportedResource(void* payload, 891 static OrthancPluginErrorCode LogExportedResource(void* payload,
811 const OrthancPluginExportedResource* exported) 892 const OrthancPluginExportedResource* exported)
812 { 893 {
813 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 894 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
814 895
815 try 896 try
816 { 897 {
817 backend->LogExportedResource(*exported); 898 adapter->GetBackend().LogExportedResource(*exported);
818 return OrthancPluginErrorCode_Success; 899 return OrthancPluginErrorCode_Success;
819 } 900 }
820 ORTHANC_PLUGINS_DATABASE_CATCH; 901 ORTHANC_PLUGINS_DATABASE_CATCH;
821 } 902 }
822 903
824 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context, 905 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context,
825 void* payload, 906 void* payload,
826 int64_t id, 907 int64_t id,
827 int32_t contentType) 908 int32_t contentType)
828 { 909 {
829 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 910 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
830 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 911 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
831 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Attachment); 912 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Attachment);
832 913
833 try 914 try
834 { 915 {
835 backend->LookupAttachment(*output, id, contentType); 916 adapter->GetBackend().LookupAttachment(*output, id, contentType);
836 return OrthancPluginErrorCode_Success; 917 return OrthancPluginErrorCode_Success;
837 } 918 }
838 ORTHANC_PLUGINS_DATABASE_CATCH; 919 ORTHANC_PLUGINS_DATABASE_CATCH;
839 } 920 }
840 921
841 922
842 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context, 923 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context,
843 void* payload, 924 void* payload,
844 int32_t property) 925 int32_t property)
845 { 926 {
846 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 927 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
847 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 928 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
848 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 929 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
849 930
850 try 931 try
851 { 932 {
852 std::string s; 933 std::string s;
853 if (backend->LookupGlobalProperty(s, MISSING_SERVER_IDENTIFIER, property)) 934 if (adapter->GetBackend().LookupGlobalProperty(s, MISSING_SERVER_IDENTIFIER, property))
854 { 935 {
855 OrthancPluginDatabaseAnswerString(backend->GetContext(), 936 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
856 output->GetDatabase(), 937 output->GetDatabase(),
857 s.c_str()); 938 s.c_str());
858 } 939 }
859 940
860 return OrthancPluginErrorCode_Success; 941 return OrthancPluginErrorCode_Success;
867 void* payload, 948 void* payload,
868 OrthancPluginResourceType resourceType, 949 OrthancPluginResourceType resourceType,
869 const OrthancPluginDicomTag* tag, 950 const OrthancPluginDicomTag* tag,
870 OrthancPluginIdentifierConstraint constraint) 951 OrthancPluginIdentifierConstraint constraint)
871 { 952 {
872 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 953 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
873 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 954 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
874 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 955 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
875 956
876 try 957 try
877 { 958 {
878 std::list<int64_t> target; 959 std::list<int64_t> target;
879 backend->LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value); 960 adapter->GetBackend().LookupIdentifier(target, resourceType, tag->group, tag->element, constraint, tag->value);
880 961
881 for (std::list<int64_t>::const_iterator 962 for (std::list<int64_t>::const_iterator
882 it = target.begin(); it != target.end(); ++it) 963 it = target.begin(); it != target.end(); ++it)
883 { 964 {
884 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 965 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
885 output->GetDatabase(), *it); 966 output->GetDatabase(), *it);
886 } 967 }
887 968
888 return OrthancPluginErrorCode_Success; 969 return OrthancPluginErrorCode_Success;
889 } 970 }
897 uint16_t group, 978 uint16_t group,
898 uint16_t element, 979 uint16_t element,
899 const char* start, 980 const char* start,
900 const char* end) 981 const char* end)
901 { 982 {
902 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 983 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
903 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 984 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
904 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 985 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
905 986
906 try 987 try
907 { 988 {
908 std::list<int64_t> target; 989 std::list<int64_t> target;
909 backend->LookupIdentifierRange(target, resourceType, group, element, start, end); 990 adapter->GetBackend().LookupIdentifierRange(target, resourceType, group, element, start, end);
910 991
911 for (std::list<int64_t>::const_iterator 992 for (std::list<int64_t>::const_iterator
912 it = target.begin(); it != target.end(); ++it) 993 it = target.begin(); it != target.end(); ++it)
913 { 994 {
914 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 995 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
915 output->GetDatabase(), *it); 996 output->GetDatabase(), *it);
916 } 997 }
917 998
918 return OrthancPluginErrorCode_Success; 999 return OrthancPluginErrorCode_Success;
919 } 1000 }
924 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context, 1005 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context,
925 void* payload, 1006 void* payload,
926 int64_t id, 1007 int64_t id,
927 int32_t metadata) 1008 int32_t metadata)
928 { 1009 {
929 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1010 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
930 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 1011 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
931 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1012 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
932 1013
933 try 1014 try
934 { 1015 {
935 std::string s; 1016 std::string s;
936 if (backend->LookupMetadata(s, id, metadata)) 1017 if (adapter->GetBackend().LookupMetadata(s, id, metadata))
937 { 1018 {
938 OrthancPluginDatabaseAnswerString(backend->GetContext(), 1019 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
939 output->GetDatabase(), s.c_str()); 1020 output->GetDatabase(), s.c_str());
940 } 1021 }
941 1022
942 return OrthancPluginErrorCode_Success; 1023 return OrthancPluginErrorCode_Success;
943 } 1024 }
947 1028
948 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context, 1029 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context,
949 void* payload, 1030 void* payload,
950 int64_t id) 1031 int64_t id)
951 { 1032 {
952 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1033 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
953 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 1034 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
954 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1035 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
955 1036
956 try 1037 try
957 { 1038 {
958 int64_t parent; 1039 int64_t parent;
959 if (backend->LookupParent(parent, id)) 1040 if (adapter->GetBackend().LookupParent(parent, id))
960 { 1041 {
961 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 1042 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
962 output->GetDatabase(), parent); 1043 output->GetDatabase(), parent);
963 } 1044 }
964 1045
965 return OrthancPluginErrorCode_Success; 1046 return OrthancPluginErrorCode_Success;
966 } 1047 }
970 1051
971 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context, 1052 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context,
972 void* payload, 1053 void* payload,
973 const char* publicId) 1054 const char* publicId)
974 { 1055 {
975 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1056 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
976 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 1057 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
977 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1058 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
978 1059
979 try 1060 try
980 { 1061 {
981 int64_t id; 1062 int64_t id;
982 OrthancPluginResourceType type; 1063 OrthancPluginResourceType type;
983 if (backend->LookupResource(id, type, publicId)) 1064 if (adapter->GetBackend().LookupResource(id, type, publicId))
984 { 1065 {
985 OrthancPluginDatabaseAnswerResource(backend->GetContext(), 1066 OrthancPluginDatabaseAnswerResource(adapter->GetBackend().GetContext(),
986 output->GetDatabase(), 1067 output->GetDatabase(),
987 id, type); 1068 id, type);
988 } 1069 }
989 1070
990 return OrthancPluginErrorCode_Success; 1071 return OrthancPluginErrorCode_Success;
994 1075
995 1076
996 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context, 1077 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context,
997 void* payload) 1078 void* payload)
998 { 1079 {
999 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1080 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1000 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 1081 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1001 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1082 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
1002 1083
1003 try 1084 try
1004 { 1085 {
1005 int64_t id; 1086 int64_t id;
1006 if (backend->SelectPatientToRecycle(id)) 1087 if (adapter->GetBackend().SelectPatientToRecycle(id))
1007 { 1088 {
1008 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 1089 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
1009 output->GetDatabase(), id); 1090 output->GetDatabase(), id);
1010 } 1091 }
1011 1092
1012 return OrthancPluginErrorCode_Success; 1093 return OrthancPluginErrorCode_Success;
1013 } 1094 }
1017 1098
1018 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context, 1099 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context,
1019 void* payload, 1100 void* payload,
1020 int64_t patientIdToAvoid) 1101 int64_t patientIdToAvoid)
1021 { 1102 {
1022 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1103 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1023 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 1104 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1024 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1105 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
1025 1106
1026 try 1107 try
1027 { 1108 {
1028 int64_t id; 1109 int64_t id;
1029 if (backend->SelectPatientToRecycle(id, patientIdToAvoid)) 1110 if (adapter->GetBackend().SelectPatientToRecycle(id, patientIdToAvoid))
1030 { 1111 {
1031 OrthancPluginDatabaseAnswerInt64(backend->GetContext(), 1112 OrthancPluginDatabaseAnswerInt64(adapter->GetBackend().GetContext(),
1032 output->GetDatabase(), id); 1113 output->GetDatabase(), id);
1033 } 1114 }
1034 1115
1035 return OrthancPluginErrorCode_Success; 1116 return OrthancPluginErrorCode_Success;
1036 } 1117 }
1040 1121
1041 static OrthancPluginErrorCode SetGlobalProperty(void* payload, 1122 static OrthancPluginErrorCode SetGlobalProperty(void* payload,
1042 int32_t property, 1123 int32_t property,
1043 const char* value) 1124 const char* value)
1044 { 1125 {
1045 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1126 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1046 1127
1047 try 1128 try
1048 { 1129 {
1049 backend->SetGlobalProperty(MISSING_SERVER_IDENTIFIER, property, value); 1130 adapter->GetBackend().SetGlobalProperty(MISSING_SERVER_IDENTIFIER, property, value);
1050 return OrthancPluginErrorCode_Success; 1131 return OrthancPluginErrorCode_Success;
1051 } 1132 }
1052 ORTHANC_PLUGINS_DATABASE_CATCH; 1133 ORTHANC_PLUGINS_DATABASE_CATCH;
1053 } 1134 }
1054 1135
1055 1136
1056 static OrthancPluginErrorCode SetMainDicomTag(void* payload, 1137 static OrthancPluginErrorCode SetMainDicomTag(void* payload,
1057 int64_t id, 1138 int64_t id,
1058 const OrthancPluginDicomTag* tag) 1139 const OrthancPluginDicomTag* tag)
1059 { 1140 {
1060 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1141 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1061 1142
1062 try 1143 try
1063 { 1144 {
1064 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value); 1145 adapter->GetBackend().SetMainDicomTag(id, tag->group, tag->element, tag->value);
1065 return OrthancPluginErrorCode_Success; 1146 return OrthancPluginErrorCode_Success;
1066 } 1147 }
1067 ORTHANC_PLUGINS_DATABASE_CATCH; 1148 ORTHANC_PLUGINS_DATABASE_CATCH;
1068 } 1149 }
1069 1150
1070 1151
1071 static OrthancPluginErrorCode SetIdentifierTag(void* payload, 1152 static OrthancPluginErrorCode SetIdentifierTag(void* payload,
1072 int64_t id, 1153 int64_t id,
1073 const OrthancPluginDicomTag* tag) 1154 const OrthancPluginDicomTag* tag)
1074 { 1155 {
1075 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1156 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1076 1157
1077 try 1158 try
1078 { 1159 {
1079 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value); 1160 adapter->GetBackend().SetIdentifierTag(id, tag->group, tag->element, tag->value);
1080 return OrthancPluginErrorCode_Success; 1161 return OrthancPluginErrorCode_Success;
1081 } 1162 }
1082 ORTHANC_PLUGINS_DATABASE_CATCH; 1163 ORTHANC_PLUGINS_DATABASE_CATCH;
1083 } 1164 }
1084 1165
1086 static OrthancPluginErrorCode SetMetadata(void* payload, 1167 static OrthancPluginErrorCode SetMetadata(void* payload,
1087 int64_t id, 1168 int64_t id,
1088 int32_t metadata, 1169 int32_t metadata,
1089 const char* value) 1170 const char* value)
1090 { 1171 {
1091 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1172 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1092 1173
1093 try 1174 try
1094 { 1175 {
1095 backend->SetMetadata(id, metadata, value); 1176 adapter->GetBackend().SetMetadata(id, metadata, value);
1096 return OrthancPluginErrorCode_Success; 1177 return OrthancPluginErrorCode_Success;
1097 } 1178 }
1098 ORTHANC_PLUGINS_DATABASE_CATCH; 1179 ORTHANC_PLUGINS_DATABASE_CATCH;
1099 } 1180 }
1100 1181
1101 1182
1102 static OrthancPluginErrorCode SetProtectedPatient(void* payload, 1183 static OrthancPluginErrorCode SetProtectedPatient(void* payload,
1103 int64_t id, 1184 int64_t id,
1104 int32_t isProtected) 1185 int32_t isProtected)
1105 { 1186 {
1106 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1187 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1107 1188
1108 try 1189 try
1109 { 1190 {
1110 backend->SetProtectedPatient(id, (isProtected != 0)); 1191 adapter->GetBackend().SetProtectedPatient(id, (isProtected != 0));
1111 return OrthancPluginErrorCode_Success; 1192 return OrthancPluginErrorCode_Success;
1112 } 1193 }
1113 ORTHANC_PLUGINS_DATABASE_CATCH; 1194 ORTHANC_PLUGINS_DATABASE_CATCH;
1114 } 1195 }
1115 1196
1116 1197
1117 static OrthancPluginErrorCode StartTransaction(void* payload) 1198 static OrthancPluginErrorCode StartTransaction(void* payload)
1118 { 1199 {
1119 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1200 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1120 1201
1121 try 1202 try
1122 { 1203 {
1123 backend->StartTransaction(TransactionType_ReadWrite); 1204 adapter->GetBackend().StartTransaction(TransactionType_ReadWrite);
1124 return OrthancPluginErrorCode_Success; 1205 return OrthancPluginErrorCode_Success;
1125 } 1206 }
1126 ORTHANC_PLUGINS_DATABASE_CATCH; 1207 ORTHANC_PLUGINS_DATABASE_CATCH;
1127 } 1208 }
1128 1209
1129 1210
1130 static OrthancPluginErrorCode RollbackTransaction(void* payload) 1211 static OrthancPluginErrorCode RollbackTransaction(void* payload)
1131 { 1212 {
1132 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1213 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1133 1214
1134 try 1215 try
1135 { 1216 {
1136 backend->RollbackTransaction(); 1217 adapter->GetBackend().RollbackTransaction();
1137 return OrthancPluginErrorCode_Success; 1218 return OrthancPluginErrorCode_Success;
1138 } 1219 }
1139 ORTHANC_PLUGINS_DATABASE_CATCH; 1220 ORTHANC_PLUGINS_DATABASE_CATCH;
1140 } 1221 }
1141 1222
1142 1223
1143 static OrthancPluginErrorCode CommitTransaction(void* payload) 1224 static OrthancPluginErrorCode CommitTransaction(void* payload)
1144 { 1225 {
1145 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1226 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1146 1227
1147 try 1228 try
1148 { 1229 {
1149 backend->CommitTransaction(); 1230 adapter->GetBackend().CommitTransaction();
1150 return OrthancPluginErrorCode_Success; 1231 return OrthancPluginErrorCode_Success;
1151 } 1232 }
1152 ORTHANC_PLUGINS_DATABASE_CATCH; 1233 ORTHANC_PLUGINS_DATABASE_CATCH;
1153 } 1234 }
1154 1235
1155 1236
1156 static OrthancPluginErrorCode Open(void* payload) 1237 static OrthancPluginErrorCode Open(void* payload)
1157 { 1238 {
1158 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1239 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1159 1240
1160 try 1241 try
1161 { 1242 {
1162 backend->Open(); 1243 //adapter->OpenConnection(); // TODO
1244 adapter->GetBackend().Open();
1163 return OrthancPluginErrorCode_Success; 1245 return OrthancPluginErrorCode_Success;
1164 } 1246 }
1165 ORTHANC_PLUGINS_DATABASE_CATCH; 1247 ORTHANC_PLUGINS_DATABASE_CATCH;
1166 } 1248 }
1167 1249
1168 1250
1169 static OrthancPluginErrorCode Close(void* payload) 1251 static OrthancPluginErrorCode Close(void* payload)
1170 { 1252 {
1171 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1253 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1172 1254
1173 try 1255 try
1174 { 1256 {
1175 backend->Close(); 1257 adapter->GetBackend().Close();
1258 //adapter->CloseConnection(); // TODO
1176 return OrthancPluginErrorCode_Success; 1259 return OrthancPluginErrorCode_Success;
1177 } 1260 }
1178 ORTHANC_PLUGINS_DATABASE_CATCH; 1261 ORTHANC_PLUGINS_DATABASE_CATCH;
1179 } 1262 }
1180 1263
1181 1264
1182 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version, 1265 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version,
1183 void* payload) 1266 void* payload)
1184 { 1267 {
1185 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1268 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1186 1269
1187 try 1270 try
1188 { 1271 {
1189 *version = backend->GetDatabaseVersion(); 1272 *version = adapter->GetBackend().GetDatabaseVersion();
1190 return OrthancPluginErrorCode_Success; 1273 return OrthancPluginErrorCode_Success;
1191 } 1274 }
1192 ORTHANC_PLUGINS_DATABASE_CATCH; 1275 ORTHANC_PLUGINS_DATABASE_CATCH;
1193 } 1276 }
1194 1277
1195 1278
1196 static OrthancPluginErrorCode UpgradeDatabase(void* payload, 1279 static OrthancPluginErrorCode UpgradeDatabase(void* payload,
1197 uint32_t targetVersion, 1280 uint32_t targetVersion,
1198 OrthancPluginStorageArea* storageArea) 1281 OrthancPluginStorageArea* storageArea)
1199 { 1282 {
1200 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1283 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1201 1284
1202 try 1285 try
1203 { 1286 {
1204 backend->UpgradeDatabase(targetVersion, storageArea); 1287 adapter->GetBackend().UpgradeDatabase(targetVersion, storageArea);
1205 return OrthancPluginErrorCode_Success; 1288 return OrthancPluginErrorCode_Success;
1206 } 1289 }
1207 ORTHANC_PLUGINS_DATABASE_CATCH; 1290 ORTHANC_PLUGINS_DATABASE_CATCH;
1208 } 1291 }
1209 1292
1210 1293
1211 static OrthancPluginErrorCode ClearMainDicomTags(void* payload, 1294 static OrthancPluginErrorCode ClearMainDicomTags(void* payload,
1212 int64_t internalId) 1295 int64_t internalId)
1213 { 1296 {
1214 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1297 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1215 1298
1216 try 1299 try
1217 { 1300 {
1218 backend->ClearMainDicomTags(internalId); 1301 adapter->GetBackend().ClearMainDicomTags(internalId);
1219 return OrthancPluginErrorCode_Success; 1302 return OrthancPluginErrorCode_Success;
1220 } 1303 }
1221 ORTHANC_PLUGINS_DATABASE_CATCH; 1304 ORTHANC_PLUGINS_DATABASE_CATCH;
1222 } 1305 }
1223 1306
1231 const OrthancPluginDatabaseConstraint* constraints, 1314 const OrthancPluginDatabaseConstraint* constraints,
1232 OrthancPluginResourceType queryLevel, 1315 OrthancPluginResourceType queryLevel,
1233 uint32_t limit, 1316 uint32_t limit,
1234 uint8_t requestSomeInstance) 1317 uint8_t requestSomeInstance)
1235 { 1318 {
1236 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1319 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1237 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 1320 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1238 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_MatchingResource); 1321 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_MatchingResource);
1239 1322
1240 try 1323 try
1241 { 1324 {
1242 std::vector<Orthanc::DatabaseConstraint> lookup; 1325 std::vector<Orthanc::DatabaseConstraint> lookup;
1245 for (uint32_t i = 0; i < constraintsCount; i++) 1328 for (uint32_t i = 0; i < constraintsCount; i++)
1246 { 1329 {
1247 lookup.push_back(Orthanc::DatabaseConstraint(constraints[i])); 1330 lookup.push_back(Orthanc::DatabaseConstraint(constraints[i]));
1248 } 1331 }
1249 1332
1250 backend->LookupResources(*output, lookup, queryLevel, limit, (requestSomeInstance != 0)); 1333 adapter->GetBackend().LookupResources(*output, lookup, queryLevel, limit, (requestSomeInstance != 0));
1251 return OrthancPluginErrorCode_Success; 1334 return OrthancPluginErrorCode_Success;
1252 } 1335 }
1253 ORTHANC_PLUGINS_DATABASE_CATCH; 1336 ORTHANC_PLUGINS_DATABASE_CATCH;
1254 } 1337 }
1255 #endif 1338 #endif
1261 const char* hashPatient, 1344 const char* hashPatient,
1262 const char* hashStudy, 1345 const char* hashStudy,
1263 const char* hashSeries, 1346 const char* hashSeries,
1264 const char* hashInstance) 1347 const char* hashInstance)
1265 { 1348 {
1266 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1349 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1267 1350
1268 try 1351 try
1269 { 1352 {
1270 backend->CreateInstance(*target, hashPatient, hashStudy, hashSeries, hashInstance); 1353 adapter->GetBackend().CreateInstance(*target, hashPatient, hashStudy, hashSeries, hashInstance);
1271 return OrthancPluginErrorCode_Success; 1354 return OrthancPluginErrorCode_Success;
1272 } 1355 }
1273 ORTHANC_PLUGINS_DATABASE_CATCH; 1356 ORTHANC_PLUGINS_DATABASE_CATCH;
1274 } 1357 }
1275 #endif 1358 #endif
1283 uint32_t countMainDicomTags, 1366 uint32_t countMainDicomTags,
1284 const OrthancPluginResourcesContentTags* mainDicomTags, 1367 const OrthancPluginResourcesContentTags* mainDicomTags,
1285 uint32_t countMetadata, 1368 uint32_t countMetadata,
1286 const OrthancPluginResourcesContentMetadata* metadata) 1369 const OrthancPluginResourcesContentMetadata* metadata)
1287 { 1370 {
1288 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1371 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1289 1372
1290 try 1373 try
1291 { 1374 {
1292 backend->SetResourcesContent(countIdentifierTags, identifierTags, 1375 adapter->GetBackend().SetResourcesContent(countIdentifierTags, identifierTags,
1293 countMainDicomTags, mainDicomTags, 1376 countMainDicomTags, mainDicomTags,
1294 countMetadata, metadata); 1377 countMetadata, metadata);
1295 return OrthancPluginErrorCode_Success; 1378 return OrthancPluginErrorCode_Success;
1296 } 1379 }
1297 ORTHANC_PLUGINS_DATABASE_CATCH; 1380 ORTHANC_PLUGINS_DATABASE_CATCH;
1303 static OrthancPluginErrorCode GetChildrenMetadata(OrthancPluginDatabaseContext* context, 1386 static OrthancPluginErrorCode GetChildrenMetadata(OrthancPluginDatabaseContext* context,
1304 void* payload, 1387 void* payload,
1305 int64_t resourceId, 1388 int64_t resourceId,
1306 int32_t metadata) 1389 int32_t metadata)
1307 { 1390 {
1308 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1391 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1309 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 1392 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1310 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None); 1393 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_None);
1311 1394
1312 try 1395 try
1313 { 1396 {
1314 std::list<std::string> values; 1397 std::list<std::string> values;
1315 backend->GetChildrenMetadata(values, resourceId, metadata); 1398 adapter->GetBackend().GetChildrenMetadata(values, resourceId, metadata);
1316 1399
1317 for (std::list<std::string>::const_iterator 1400 for (std::list<std::string>::const_iterator
1318 it = values.begin(); it != values.end(); ++it) 1401 it = values.begin(); it != values.end(); ++it)
1319 { 1402 {
1320 OrthancPluginDatabaseAnswerString(backend->GetContext(), 1403 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
1321 output->GetDatabase(), 1404 output->GetDatabase(),
1322 it->c_str()); 1405 it->c_str());
1323 } 1406 }
1324 1407
1325 return OrthancPluginErrorCode_Success; 1408 return OrthancPluginErrorCode_Success;
1330 1413
1331 // New primitive since Orthanc 1.5.2 1414 // New primitive since Orthanc 1.5.2
1332 static OrthancPluginErrorCode GetLastChangeIndex(int64_t* result, 1415 static OrthancPluginErrorCode GetLastChangeIndex(int64_t* result,
1333 void* payload) 1416 void* payload)
1334 { 1417 {
1335 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1418 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1336 1419
1337 try 1420 try
1338 { 1421 {
1339 *result = backend->GetLastChangeIndex(); 1422 *result = adapter->GetBackend().GetLastChangeIndex();
1340 return OrthancPluginErrorCode_Success; 1423 return OrthancPluginErrorCode_Success;
1341 } 1424 }
1342 ORTHANC_PLUGINS_DATABASE_CATCH; 1425 ORTHANC_PLUGINS_DATABASE_CATCH;
1343 } 1426 }
1344 1427
1345 1428
1346 // New primitive since Orthanc 1.5.2 1429 // New primitive since Orthanc 1.5.2
1347 static OrthancPluginErrorCode TagMostRecentPatient(void* payload, 1430 static OrthancPluginErrorCode TagMostRecentPatient(void* payload,
1348 int64_t patientId) 1431 int64_t patientId)
1349 { 1432 {
1350 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1433 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1351 1434
1352 try 1435 try
1353 { 1436 {
1354 backend->TagMostRecentPatient(patientId); 1437 adapter->GetBackend().TagMostRecentPatient(patientId);
1355 return OrthancPluginErrorCode_Success; 1438 return OrthancPluginErrorCode_Success;
1356 } 1439 }
1357 ORTHANC_PLUGINS_DATABASE_CATCH; 1440 ORTHANC_PLUGINS_DATABASE_CATCH;
1358 } 1441 }
1359 1442
1363 // New primitive since Orthanc 1.5.4 1446 // New primitive since Orthanc 1.5.4
1364 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseContext* context, 1447 static OrthancPluginErrorCode GetAllMetadata(OrthancPluginDatabaseContext* context,
1365 void* payload, 1448 void* payload,
1366 int64_t resourceId) 1449 int64_t resourceId)
1367 { 1450 {
1368 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1451 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1369 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 1452 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1370 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Metadata); 1453 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_Metadata);
1371 1454
1372 try 1455 try
1373 { 1456 {
1374 std::map<int32_t, std::string> result; 1457 std::map<int32_t, std::string> result;
1375 backend->GetAllMetadata(result, resourceId); 1458 adapter->GetBackend().GetAllMetadata(result, resourceId);
1376 1459
1377 for (std::map<int32_t, std::string>::const_iterator 1460 for (std::map<int32_t, std::string>::const_iterator
1378 it = result.begin(); it != result.end(); ++it) 1461 it = result.begin(); it != result.end(); ++it)
1379 { 1462 {
1380 OrthancPluginDatabaseAnswerMetadata(backend->GetContext(), 1463 OrthancPluginDatabaseAnswerMetadata(adapter->GetBackend().GetContext(),
1381 output->GetDatabase(), 1464 output->GetDatabase(),
1382 resourceId, it->first, it->second.c_str()); 1465 resourceId, it->first, it->second.c_str());
1383 } 1466 }
1384 1467
1385 return OrthancPluginErrorCode_Success; 1468 return OrthancPluginErrorCode_Success;
1398 int64_t* id, 1481 int64_t* id,
1399 OrthancPluginResourceType* type, 1482 OrthancPluginResourceType* type,
1400 void* payload, 1483 void* payload,
1401 const char* publicId) 1484 const char* publicId)
1402 { 1485 {
1403 IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload); 1486 DatabaseBackendAdapterV2::Adapter* adapter = reinterpret_cast<DatabaseBackendAdapterV2::Adapter*>(payload);
1404 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(backend->CreateOutput())); 1487 std::unique_ptr<DatabaseBackendAdapterV2::Output> output(dynamic_cast<DatabaseBackendAdapterV2::Output*>(adapter->GetBackend().CreateOutput()));
1405 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_String); 1488 output->SetAllowedAnswers(DatabaseBackendAdapterV2::Output::AllowedAnswers_String);
1406 1489
1407 try 1490 try
1408 { 1491 {
1409 std::string parent; 1492 std::string parent;
1410 if (backend->LookupResourceAndParent(*id, *type, parent, publicId)) 1493 if (adapter->GetBackend().LookupResourceAndParent(*id, *type, parent, publicId))
1411 { 1494 {
1412 *isExisting = 1; 1495 *isExisting = 1;
1413 1496
1414 if (!parent.empty()) 1497 if (!parent.empty())
1415 { 1498 {
1416 OrthancPluginDatabaseAnswerString(backend->GetContext(), 1499 OrthancPluginDatabaseAnswerString(adapter->GetBackend().GetContext(),
1417 output->GetDatabase(), 1500 output->GetDatabase(),
1418 parent.c_str()); 1501 parent.c_str());
1419 } 1502 }
1420 } 1503 }
1421 else 1504 else
1435 { 1518 {
1436 return new Output(context_, database_); 1519 return new Output(context_, database_);
1437 } 1520 }
1438 1521
1439 1522
1440 static std::unique_ptr<IDatabaseBackend> backend_; 1523 static std::unique_ptr<DatabaseBackendAdapterV2::Adapter> adapter_;
1441 1524
1442 void DatabaseBackendAdapterV2::Register(IDatabaseBackend* backend) 1525 void DatabaseBackendAdapterV2::Register(IDatabaseBackend* backend)
1443 { 1526 {
1444 if (backend == NULL) 1527 if (backend == NULL)
1445 { 1528 {
1446 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); 1529 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
1447 } 1530 }
1448 1531
1449 if (backend_.get() != NULL) 1532 if (adapter_.get() != NULL)
1450 { 1533 {
1451 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); 1534 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
1452 } 1535 }
1453 1536
1454 backend_.reset(backend); 1537 adapter_.reset(new Adapter(backend));
1455 1538
1456 OrthancPluginDatabaseBackend params; 1539 OrthancPluginDatabaseBackend params;
1457 memset(&params, 0, sizeof(params)); 1540 memset(&params, 0, sizeof(params));
1458 1541
1459 OrthancPluginDatabaseExtensions extensions; 1542 OrthancPluginDatabaseExtensions extensions;
1527 extensions.setResourcesContent = SetResourcesContent; // Fast setting tags/metadata 1610 extensions.setResourcesContent = SetResourcesContent; // Fast setting tags/metadata
1528 extensions.getChildrenMetadata = GetChildrenMetadata; 1611 extensions.getChildrenMetadata = GetChildrenMetadata;
1529 extensions.getLastChangeIndex = GetLastChangeIndex; 1612 extensions.getLastChangeIndex = GetLastChangeIndex;
1530 extensions.tagMostRecentPatient = TagMostRecentPatient; 1613 extensions.tagMostRecentPatient = TagMostRecentPatient;
1531 1614
1532 if (backend_->HasCreateInstance()) 1615 if (adapter_->GetBackend().HasCreateInstance())
1533 { 1616 {
1534 extensions.createInstance = CreateInstance; // Fast creation of resources 1617 extensions.createInstance = CreateInstance; // Fast creation of resources
1535 } 1618 }
1536 #endif 1619 #endif
1537 1620
1542 extensions.getAllMetadata = GetAllMetadata; 1625 extensions.getAllMetadata = GetAllMetadata;
1543 performanceWarning = false; 1626 performanceWarning = false;
1544 # endif 1627 # endif
1545 #endif 1628 #endif
1546 1629
1547 OrthancPluginContext* context = backend_->GetContext(); 1630 OrthancPluginContext* context = adapter_->GetBackend().GetContext();
1548 1631
1549 if (performanceWarning) 1632 if (performanceWarning)
1550 { 1633 {
1551 char info[1024]; 1634 char info[1024];
1552 sprintf(info, 1635 sprintf(info,
1562 1645
1563 OrthancPluginLogWarning(context, info); 1646 OrthancPluginLogWarning(context, info);
1564 } 1647 }
1565 1648
1566 OrthancPluginDatabaseContext* database = 1649 OrthancPluginDatabaseContext* database =
1567 OrthancPluginRegisterDatabaseBackendV2(context, &params, &extensions, backend_.get()); 1650 OrthancPluginRegisterDatabaseBackendV2(context, &params, &extensions, adapter_.get());
1568 if (database == NULL) 1651 if (database == NULL)
1569 { 1652 {
1570 throw std::runtime_error("Unable to register the database backend"); 1653 throw std::runtime_error("Unable to register the database backend");
1571 } 1654 }
1572 1655
1573 backend_->SetOutputFactory(new Factory(context, database)); 1656 adapter_->GetBackend().SetOutputFactory(new Factory(context, database));
1574 } 1657 }
1575 1658
1576 1659
1577 void DatabaseBackendAdapterV2::Finalize() 1660 void DatabaseBackendAdapterV2::Finalize()
1578 { 1661 {
1579 backend_.reset(NULL); 1662 adapter_.reset(NULL);
1580 } 1663 }
1581 } 1664 }