Mercurial > hg > orthanc-databases

comparison Framework/Plugins/OrthancCppDatabasePlugin.h @ 1:d17b2631bb67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
starting StorageBackend
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 04 Jul 2018 18:05:24 +0200
parents 7cea966b6829
children 9e419261f1c9
comparison
equal deleted inserted replaced
0:7cea966b6829 1:d17b2631bb67
26 * order to uncouple its evolution from the Orthanc core. 26 * order to uncouple its evolution from the Orthanc core.
27 **/ 27 **/
28 28
29 #pragma once 29 #pragma once
30 30
31 #if HAS_ORTHANC_EXCEPTION != 1
32 # error HAS_ORTHANC_EXCEPTION must be set to 1
33 #endif
34
35
31 #include <orthanc/OrthancCDatabasePlugin.h> 36 #include <orthanc/OrthancCDatabasePlugin.h>
32 37 #include <Core/OrthancException.h>
33 #define ORTHANC_PLUGINS_DATABASE_CATCH_COMMON \ 38
34 catch (::std::runtime_error& e) \ 39
35 { \ 40 #define ORTHANC_PLUGINS_DATABASE_CATCH \
36 LogError(backend, e); \
37 return OrthancPluginErrorCode_DatabasePlugin; \
38 } \
39 catch (::OrthancPlugins::DatabaseException& e) \
40 { \
41 return e.GetErrorCode(); \
42 } \
43 catch (...) \
44 { \
45 backend->GetOutput().LogError("Native exception"); \
46 return OrthancPluginErrorCode_DatabasePlugin; \
47 }
48
49 #if HAS_ORTHANC_EXCEPTION == 1
50 # include <Core/OrthancException.h>
51 # define ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC \
52 catch (::Orthanc::OrthancException& e) \ 41 catch (::Orthanc::OrthancException& e) \
53 { \ 42 { \
54 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \ 43 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); \
44 } \
45 catch (::std::runtime_error& e) \
46 { \
47 LogError(backend, e); \
48 return OrthancPluginErrorCode_DatabasePlugin; \
49 } \
50 catch (...) \
51 { \
52 backend->GetOutput().LogError("Native exception"); \
53 return OrthancPluginErrorCode_DatabasePlugin; \
55 } 54 }
56 #else
57 # define ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC
58 #endif
59 55
60 56
61 #include <stdexcept> 57 #include <stdexcept>
62 #include <list> 58 #include <list>
63 #include <string> 59 #include <string>
64 60
65 namespace OrthancPlugins 61 namespace OrthancPlugins
66 { 62 {
67 //! @cond Doxygen_Suppress
68 // This class mimics "boost::noncopyable"
69 class NonCopyable
70 {
71 private:
72 NonCopyable(const NonCopyable&);
73
74 NonCopyable& operator= (const NonCopyable&);
75
76 protected:
77 NonCopyable()
78 {
79 }
80
81 ~NonCopyable()
82 {
83 }
84 };
85 //! @endcond
86
87
88 /** 63 /**
89 * @ingroup Callbacks 64 * @ingroup Callbacks
90 **/ 65 **/
91 class DatabaseException 66 class DatabaseBackendOutput : public boost::noncopyable
92 {
93 private:
94 OrthancPluginErrorCode code_;
95
96 public:
97 DatabaseException() : code_(OrthancPluginErrorCode_DatabasePlugin)
98 {
99 }
100
101 DatabaseException(OrthancPluginErrorCode code) : code_(code)
102 {
103 }
104
105 OrthancPluginErrorCode GetErrorCode() const
106 {
107 return code_;
108 }
109 };
110
111
112 /**
113 * @ingroup Callbacks
114 **/
115 class DatabaseBackendOutput : public NonCopyable
116 { 67 {
117 friend class DatabaseBackendAdapter; 68 friend class DatabaseBackendAdapter;
118 69
119 private: 70 private:
120 enum AllowedAnswers 71 enum AllowedAnswers
296 247
297 248
298 /** 249 /**
299 * @ingroup Callbacks 250 * @ingroup Callbacks
300 **/ 251 **/
301 class IDatabaseBackend : public NonCopyable 252 class IDatabaseBackend : public boost::noncopyable
302 { 253 {
303 friend class DatabaseBackendAdapter; 254 friend class DatabaseBackendAdapter;
304 255
305 private: 256 private:
306 DatabaseBackendOutput* output_; 257 DatabaseBackendOutput* output_;
534 try 485 try
535 { 486 {
536 backend->AddAttachment(id, *attachment); 487 backend->AddAttachment(id, *attachment);
537 return OrthancPluginErrorCode_Success; 488 return OrthancPluginErrorCode_Success;
538 } 489 }
539 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 490 ORTHANC_PLUGINS_DATABASE_CATCH
540 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
541 } 491 }
542 492
543 493
544 static OrthancPluginErrorCode AttachChild(void* payload, 494 static OrthancPluginErrorCode AttachChild(void* payload,
545 int64_t parent, 495 int64_t parent,
551 try 501 try
552 { 502 {
553 backend->AttachChild(parent, child); 503 backend->AttachChild(parent, child);
554 return OrthancPluginErrorCode_Success; 504 return OrthancPluginErrorCode_Success;
555 } 505 }
556 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 506 ORTHANC_PLUGINS_DATABASE_CATCH
557 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
558 } 507 }
559 508
560 509
561 static OrthancPluginErrorCode ClearChanges(void* payload) 510 static OrthancPluginErrorCode ClearChanges(void* payload)
562 { 511 {
566 try 515 try
567 { 516 {
568 backend->ClearChanges(); 517 backend->ClearChanges();
569 return OrthancPluginErrorCode_Success; 518 return OrthancPluginErrorCode_Success;
570 } 519 }
571 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 520 ORTHANC_PLUGINS_DATABASE_CATCH
572 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
573 } 521 }
574 522
575 523
576 static OrthancPluginErrorCode ClearExportedResources(void* payload) 524 static OrthancPluginErrorCode ClearExportedResources(void* payload)
577 { 525 {
581 try 529 try
582 { 530 {
583 backend->ClearExportedResources(); 531 backend->ClearExportedResources();
584 return OrthancPluginErrorCode_Success; 532 return OrthancPluginErrorCode_Success;
585 } 533 }
586 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 534 ORTHANC_PLUGINS_DATABASE_CATCH
587 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
588 } 535 }
589 536
590 537
591 static OrthancPluginErrorCode CreateResource(int64_t* id, 538 static OrthancPluginErrorCode CreateResource(int64_t* id,
592 void* payload, 539 void* payload,
599 try 546 try
600 { 547 {
601 *id = backend->CreateResource(publicId, resourceType); 548 *id = backend->CreateResource(publicId, resourceType);
602 return OrthancPluginErrorCode_Success; 549 return OrthancPluginErrorCode_Success;
603 } 550 }
604 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 551 ORTHANC_PLUGINS_DATABASE_CATCH
605 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
606 } 552 }
607 553
608 554
609 static OrthancPluginErrorCode DeleteAttachment(void* payload, 555 static OrthancPluginErrorCode DeleteAttachment(void* payload,
610 int64_t id, 556 int64_t id,
616 try 562 try
617 { 563 {
618 backend->DeleteAttachment(id, contentType); 564 backend->DeleteAttachment(id, contentType);
619 return OrthancPluginErrorCode_Success; 565 return OrthancPluginErrorCode_Success;
620 } 566 }
621 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 567 ORTHANC_PLUGINS_DATABASE_CATCH
622 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
623 } 568 }
624 569
625 570
626 static OrthancPluginErrorCode DeleteMetadata(void* payload, 571 static OrthancPluginErrorCode DeleteMetadata(void* payload,
627 int64_t id, 572 int64_t id,
633 try 578 try
634 { 579 {
635 backend->DeleteMetadata(id, metadataType); 580 backend->DeleteMetadata(id, metadataType);
636 return OrthancPluginErrorCode_Success; 581 return OrthancPluginErrorCode_Success;
637 } 582 }
638 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 583 ORTHANC_PLUGINS_DATABASE_CATCH
639 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
640 } 584 }
641 585
642 586
643 static OrthancPluginErrorCode DeleteResource(void* payload, 587 static OrthancPluginErrorCode DeleteResource(void* payload,
644 int64_t id) 588 int64_t id)
649 try 593 try
650 { 594 {
651 backend->DeleteResource(id); 595 backend->DeleteResource(id);
652 return OrthancPluginErrorCode_Success; 596 return OrthancPluginErrorCode_Success;
653 } 597 }
654 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 598 ORTHANC_PLUGINS_DATABASE_CATCH
655 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
656 } 599 }
657 600
658 601
659 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context, 602 static OrthancPluginErrorCode GetAllInternalIds(OrthancPluginDatabaseContext* context,
660 void* payload, 603 void* payload,
675 backend->GetOutput().database_, *it); 618 backend->GetOutput().database_, *it);
676 } 619 }
677 620
678 return OrthancPluginErrorCode_Success; 621 return OrthancPluginErrorCode_Success;
679 } 622 }
680 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 623 ORTHANC_PLUGINS_DATABASE_CATCH
681 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
682 } 624 }
683 625
684 626
685 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context, 627 static OrthancPluginErrorCode GetAllPublicIds(OrthancPluginDatabaseContext* context,
686 void* payload, 628 void* payload,
702 it->c_str()); 644 it->c_str());
703 } 645 }
704 646
705 return OrthancPluginErrorCode_Success; 647 return OrthancPluginErrorCode_Success;
706 } 648 }
707 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 649 ORTHANC_PLUGINS_DATABASE_CATCH
708 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
709 } 650 }
710 651
711 652
712 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseContext* context, 653 static OrthancPluginErrorCode GetAllPublicIdsWithLimit(OrthancPluginDatabaseContext* context,
713 void* payload, 654 void* payload,
731 it->c_str()); 672 it->c_str());
732 } 673 }
733 674
734 return OrthancPluginErrorCode_Success; 675 return OrthancPluginErrorCode_Success;
735 } 676 }
736 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 677 ORTHANC_PLUGINS_DATABASE_CATCH
737 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
738 } 678 }
739 679
740 680
741 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context, 681 static OrthancPluginErrorCode GetChanges(OrthancPluginDatabaseContext* context,
742 void* payload, 682 void* payload,
757 backend->GetOutput().database_); 697 backend->GetOutput().database_);
758 } 698 }
759 699
760 return OrthancPluginErrorCode_Success; 700 return OrthancPluginErrorCode_Success;
761 } 701 }
762 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 702 ORTHANC_PLUGINS_DATABASE_CATCH
763 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
764 } 703 }
765 704
766 705
767 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context, 706 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseContext* context,
768 void* payload, 707 void* payload,
783 backend->GetOutput().database_, *it); 722 backend->GetOutput().database_, *it);
784 } 723 }
785 724
786 return OrthancPluginErrorCode_Success; 725 return OrthancPluginErrorCode_Success;
787 } 726 }
788 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 727 ORTHANC_PLUGINS_DATABASE_CATCH
789 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
790 } 728 }
791 729
792 730
793 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context, 731 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseContext* context,
794 void* payload, 732 void* payload,
810 it->c_str()); 748 it->c_str());
811 } 749 }
812 750
813 return OrthancPluginErrorCode_Success; 751 return OrthancPluginErrorCode_Success;
814 } 752 }
815 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 753 ORTHANC_PLUGINS_DATABASE_CATCH
816 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
817 } 754 }
818 755
819 756
820 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context, 757 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseContext* context,
821 void* payload, 758 void* payload,
835 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetOutput().context_, 772 OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetOutput().context_,
836 backend->GetOutput().database_); 773 backend->GetOutput().database_);
837 } 774 }
838 return OrthancPluginErrorCode_Success; 775 return OrthancPluginErrorCode_Success;
839 } 776 }
840 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 777 ORTHANC_PLUGINS_DATABASE_CATCH
841 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
842 } 778 }
843 779
844 780
845 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context, 781 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseContext* context,
846 void* payload) 782 void* payload)
851 try 787 try
852 { 788 {
853 backend->GetLastChange(); 789 backend->GetLastChange();
854 return OrthancPluginErrorCode_Success; 790 return OrthancPluginErrorCode_Success;
855 } 791 }
856 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 792 ORTHANC_PLUGINS_DATABASE_CATCH
857 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
858 } 793 }
859 794
860 795
861 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context, 796 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseContext* context,
862 void* payload) 797 void* payload)
867 try 802 try
868 { 803 {
869 backend->GetLastExportedResource(); 804 backend->GetLastExportedResource();
870 return OrthancPluginErrorCode_Success; 805 return OrthancPluginErrorCode_Success;
871 } 806 }
872 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 807 ORTHANC_PLUGINS_DATABASE_CATCH
873 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
874 } 808 }
875 809
876 810
877 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context, 811 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseContext* context,
878 void* payload, 812 void* payload,
884 try 818 try
885 { 819 {
886 backend->GetMainDicomTags(id); 820 backend->GetMainDicomTags(id);
887 return OrthancPluginErrorCode_Success; 821 return OrthancPluginErrorCode_Success;
888 } 822 }
889 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 823 ORTHANC_PLUGINS_DATABASE_CATCH
890 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
891 } 824 }
892 825
893 826
894 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context, 827 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseContext* context,
895 void* payload, 828 void* payload,
905 backend->GetOutput().database_, 838 backend->GetOutput().database_,
906 s.c_str()); 839 s.c_str());
907 840
908 return OrthancPluginErrorCode_Success; 841 return OrthancPluginErrorCode_Success;
909 } 842 }
910 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 843 ORTHANC_PLUGINS_DATABASE_CATCH
911 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
912 } 844 }
913 845
914 846
915 static OrthancPluginErrorCode GetResourceCount(uint64_t* target, 847 static OrthancPluginErrorCode GetResourceCount(uint64_t* target,
916 void* payload, 848 void* payload,
922 try 854 try
923 { 855 {
924 *target = backend->GetResourceCount(resourceType); 856 *target = backend->GetResourceCount(resourceType);
925 return OrthancPluginErrorCode_Success; 857 return OrthancPluginErrorCode_Success;
926 } 858 }
927 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 859 ORTHANC_PLUGINS_DATABASE_CATCH
928 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
929 } 860 }
930 861
931 862
932 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType, 863 static OrthancPluginErrorCode GetResourceType(OrthancPluginResourceType* resourceType,
933 void* payload, 864 void* payload,
939 try 870 try
940 { 871 {
941 *resourceType = backend->GetResourceType(id); 872 *resourceType = backend->GetResourceType(id);
942 return OrthancPluginErrorCode_Success; 873 return OrthancPluginErrorCode_Success;
943 } 874 }
944 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 875 ORTHANC_PLUGINS_DATABASE_CATCH
945 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
946 } 876 }
947 877
948 878
949 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target, 879 static OrthancPluginErrorCode GetTotalCompressedSize(uint64_t* target,
950 void* payload) 880 void* payload)
955 try 885 try
956 { 886 {
957 *target = backend->GetTotalCompressedSize(); 887 *target = backend->GetTotalCompressedSize();
958 return OrthancPluginErrorCode_Success; 888 return OrthancPluginErrorCode_Success;
959 } 889 }
960 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 890 ORTHANC_PLUGINS_DATABASE_CATCH
961 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
962 } 891 }
963 892
964 893
965 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target, 894 static OrthancPluginErrorCode GetTotalUncompressedSize(uint64_t* target,
966 void* payload) 895 void* payload)
971 try 900 try
972 { 901 {
973 *target = backend->GetTotalUncompressedSize(); 902 *target = backend->GetTotalUncompressedSize();
974 return OrthancPluginErrorCode_Success; 903 return OrthancPluginErrorCode_Success;
975 } 904 }
976 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 905 ORTHANC_PLUGINS_DATABASE_CATCH
977 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
978 } 906 }
979 907
980 908
981 static OrthancPluginErrorCode IsExistingResource(int32_t* existing, 909 static OrthancPluginErrorCode IsExistingResource(int32_t* existing,
982 void* payload, 910 void* payload,
988 try 916 try
989 { 917 {
990 *existing = backend->IsExistingResource(id); 918 *existing = backend->IsExistingResource(id);
991 return OrthancPluginErrorCode_Success; 919 return OrthancPluginErrorCode_Success;
992 } 920 }
993 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 921 ORTHANC_PLUGINS_DATABASE_CATCH
994 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
995 } 922 }
996 923
997 924
998 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected, 925 static OrthancPluginErrorCode IsProtectedPatient(int32_t* isProtected,
999 void* payload, 926 void* payload,
1005 try 932 try
1006 { 933 {
1007 *isProtected = backend->IsProtectedPatient(id); 934 *isProtected = backend->IsProtectedPatient(id);
1008 return OrthancPluginErrorCode_Success; 935 return OrthancPluginErrorCode_Success;
1009 } 936 }
1010 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 937 ORTHANC_PLUGINS_DATABASE_CATCH
1011 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1012 } 938 }
1013 939
1014 940
1015 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context, 941 static OrthancPluginErrorCode ListAvailableMetadata(OrthancPluginDatabaseContext* context,
1016 void* payload, 942 void* payload,
1032 *it); 958 *it);
1033 } 959 }
1034 960
1035 return OrthancPluginErrorCode_Success; 961 return OrthancPluginErrorCode_Success;
1036 } 962 }
1037 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 963 ORTHANC_PLUGINS_DATABASE_CATCH
1038 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1039 } 964 }
1040 965
1041 966
1042 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context, 967 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseContext* context,
1043 void* payload, 968 void* payload,
1059 *it); 984 *it);
1060 } 985 }
1061 986
1062 return OrthancPluginErrorCode_Success; 987 return OrthancPluginErrorCode_Success;
1063 } 988 }
1064 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 989 ORTHANC_PLUGINS_DATABASE_CATCH
1065 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1066 } 990 }
1067 991
1068 992
1069 static OrthancPluginErrorCode LogChange(void* payload, 993 static OrthancPluginErrorCode LogChange(void* payload,
1070 const OrthancPluginChange* change) 994 const OrthancPluginChange* change)
1075 try 999 try
1076 { 1000 {
1077 backend->LogChange(*change); 1001 backend->LogChange(*change);
1078 return OrthancPluginErrorCode_Success; 1002 return OrthancPluginErrorCode_Success;
1079 } 1003 }
1080 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1004 ORTHANC_PLUGINS_DATABASE_CATCH
1081 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1082 } 1005 }
1083 1006
1084 1007
1085 static OrthancPluginErrorCode LogExportedResource(void* payload, 1008 static OrthancPluginErrorCode LogExportedResource(void* payload,
1086 const OrthancPluginExportedResource* exported) 1009 const OrthancPluginExportedResource* exported)
1091 try 1014 try
1092 { 1015 {
1093 backend->LogExportedResource(*exported); 1016 backend->LogExportedResource(*exported);
1094 return OrthancPluginErrorCode_Success; 1017 return OrthancPluginErrorCode_Success;
1095 } 1018 }
1096 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1019 ORTHANC_PLUGINS_DATABASE_CATCH
1097 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1098 } 1020 }
1099 1021
1100 1022
1101 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context, 1023 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseContext* context,
1102 void* payload, 1024 void* payload,
1109 try 1031 try
1110 { 1032 {
1111 backend->LookupAttachment(id, contentType); 1033 backend->LookupAttachment(id, contentType);
1112 return OrthancPluginErrorCode_Success; 1034 return OrthancPluginErrorCode_Success;
1113 } 1035 }
1114 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1036 ORTHANC_PLUGINS_DATABASE_CATCH
1115 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1116 } 1037 }
1117 1038
1118 1039
1119 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context, 1040 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseContext* context,
1120 void* payload, 1041 void* payload,
1133 s.c_str()); 1054 s.c_str());
1134 } 1055 }
1135 1056
1136 return OrthancPluginErrorCode_Success; 1057 return OrthancPluginErrorCode_Success;
1137 } 1058 }
1138 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1059 ORTHANC_PLUGINS_DATABASE_CATCH
1139 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1140 } 1060 }
1141 1061
1142 1062
1143 static OrthancPluginErrorCode LookupIdentifier3(OrthancPluginDatabaseContext* context, 1063 static OrthancPluginErrorCode LookupIdentifier3(OrthancPluginDatabaseContext* context,
1144 void* payload, 1064 void* payload,
1161 backend->GetOutput().database_, *it); 1081 backend->GetOutput().database_, *it);
1162 } 1082 }
1163 1083
1164 return OrthancPluginErrorCode_Success; 1084 return OrthancPluginErrorCode_Success;
1165 } 1085 }
1166 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1086 ORTHANC_PLUGINS_DATABASE_CATCH
1167 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1168 } 1087 }
1169 1088
1170 1089
1171 static OrthancPluginErrorCode LookupIdentifierRange(OrthancPluginDatabaseContext* context, 1090 static OrthancPluginErrorCode LookupIdentifierRange(OrthancPluginDatabaseContext* context,
1172 void* payload, 1091 void* payload,
1191 backend->GetOutput().database_, *it); 1110 backend->GetOutput().database_, *it);
1192 } 1111 }
1193 1112
1194 return OrthancPluginErrorCode_Success; 1113 return OrthancPluginErrorCode_Success;
1195 } 1114 }
1196 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1115 ORTHANC_PLUGINS_DATABASE_CATCH
1197 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1198 } 1116 }
1199 1117
1200 1118
1201 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context, 1119 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseContext* context,
1202 void* payload, 1120 void* payload,
1215 backend->GetOutput().database_, s.c_str()); 1133 backend->GetOutput().database_, s.c_str());
1216 } 1134 }
1217 1135
1218 return OrthancPluginErrorCode_Success; 1136 return OrthancPluginErrorCode_Success;
1219 } 1137 }
1220 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1138 ORTHANC_PLUGINS_DATABASE_CATCH
1221 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1222 } 1139 }
1223 1140
1224 1141
1225 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context, 1142 static OrthancPluginErrorCode LookupParent(OrthancPluginDatabaseContext* context,
1226 void* payload, 1143 void* payload,
1238 backend->GetOutput().database_, parent); 1155 backend->GetOutput().database_, parent);
1239 } 1156 }
1240 1157
1241 return OrthancPluginErrorCode_Success; 1158 return OrthancPluginErrorCode_Success;
1242 } 1159 }
1243 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1160 ORTHANC_PLUGINS_DATABASE_CATCH
1244 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1245 } 1161 }
1246 1162
1247 1163
1248 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context, 1164 static OrthancPluginErrorCode LookupResource(OrthancPluginDatabaseContext* context,
1249 void* payload, 1165 void* payload,
1263 id, type); 1179 id, type);
1264 } 1180 }
1265 1181
1266 return OrthancPluginErrorCode_Success; 1182 return OrthancPluginErrorCode_Success;
1267 } 1183 }
1268 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1184 ORTHANC_PLUGINS_DATABASE_CATCH
1269 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1270 } 1185 }
1271 1186
1272 1187
1273 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context, 1188 static OrthancPluginErrorCode SelectPatientToRecycle(OrthancPluginDatabaseContext* context,
1274 void* payload) 1189 void* payload)
1285 backend->GetOutput().database_, id); 1200 backend->GetOutput().database_, id);
1286 } 1201 }
1287 1202
1288 return OrthancPluginErrorCode_Success; 1203 return OrthancPluginErrorCode_Success;
1289 } 1204 }
1290 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1205 ORTHANC_PLUGINS_DATABASE_CATCH
1291 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1292 } 1206 }
1293 1207
1294 1208
1295 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context, 1209 static OrthancPluginErrorCode SelectPatientToRecycle2(OrthancPluginDatabaseContext* context,
1296 void* payload, 1210 void* payload,
1308 backend->GetOutput().database_, id); 1222 backend->GetOutput().database_, id);
1309 } 1223 }
1310 1224
1311 return OrthancPluginErrorCode_Success; 1225 return OrthancPluginErrorCode_Success;
1312 } 1226 }
1313 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1227 ORTHANC_PLUGINS_DATABASE_CATCH
1314 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1315 } 1228 }
1316 1229
1317 1230
1318 static OrthancPluginErrorCode SetGlobalProperty(void* payload, 1231 static OrthancPluginErrorCode SetGlobalProperty(void* payload,
1319 int32_t property, 1232 int32_t property,
1325 try 1238 try
1326 { 1239 {
1327 backend->SetGlobalProperty(property, value); 1240 backend->SetGlobalProperty(property, value);
1328 return OrthancPluginErrorCode_Success; 1241 return OrthancPluginErrorCode_Success;
1329 } 1242 }
1330 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1243 ORTHANC_PLUGINS_DATABASE_CATCH
1331 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1332 } 1244 }
1333 1245
1334 1246
1335 static OrthancPluginErrorCode SetMainDicomTag(void* payload, 1247 static OrthancPluginErrorCode SetMainDicomTag(void* payload,
1336 int64_t id, 1248 int64_t id,
1342 try 1254 try
1343 { 1255 {
1344 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value); 1256 backend->SetMainDicomTag(id, tag->group, tag->element, tag->value);
1345 return OrthancPluginErrorCode_Success; 1257 return OrthancPluginErrorCode_Success;
1346 } 1258 }
1347 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1259 ORTHANC_PLUGINS_DATABASE_CATCH
1348 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1349 } 1260 }
1350 1261
1351 1262
1352 static OrthancPluginErrorCode SetIdentifierTag(void* payload, 1263 static OrthancPluginErrorCode SetIdentifierTag(void* payload,
1353 int64_t id, 1264 int64_t id,
1359 try 1270 try
1360 { 1271 {
1361 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value); 1272 backend->SetIdentifierTag(id, tag->group, tag->element, tag->value);
1362 return OrthancPluginErrorCode_Success; 1273 return OrthancPluginErrorCode_Success;
1363 } 1274 }
1364 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1275 ORTHANC_PLUGINS_DATABASE_CATCH
1365 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1366 } 1276 }
1367 1277
1368 1278
1369 static OrthancPluginErrorCode SetMetadata(void* payload, 1279 static OrthancPluginErrorCode SetMetadata(void* payload,
1370 int64_t id, 1280 int64_t id,
1377 try 1287 try
1378 { 1288 {
1379 backend->SetMetadata(id, metadata, value); 1289 backend->SetMetadata(id, metadata, value);
1380 return OrthancPluginErrorCode_Success; 1290 return OrthancPluginErrorCode_Success;
1381 } 1291 }
1382 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1292 ORTHANC_PLUGINS_DATABASE_CATCH
1383 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1384 } 1293 }
1385 1294
1386 1295
1387 static OrthancPluginErrorCode SetProtectedPatient(void* payload, 1296 static OrthancPluginErrorCode SetProtectedPatient(void* payload,
1388 int64_t id, 1297 int64_t id,
1394 try 1303 try
1395 { 1304 {
1396 backend->SetProtectedPatient(id, (isProtected != 0)); 1305 backend->SetProtectedPatient(id, (isProtected != 0));
1397 return OrthancPluginErrorCode_Success; 1306 return OrthancPluginErrorCode_Success;
1398 } 1307 }
1399 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1308 ORTHANC_PLUGINS_DATABASE_CATCH
1400 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1401 } 1309 }
1402 1310
1403 1311
1404 static OrthancPluginErrorCode StartTransaction(void* payload) 1312 static OrthancPluginErrorCode StartTransaction(void* payload)
1405 { 1313 {
1409 try 1317 try
1410 { 1318 {
1411 backend->StartTransaction(); 1319 backend->StartTransaction();
1412 return OrthancPluginErrorCode_Success; 1320 return OrthancPluginErrorCode_Success;
1413 } 1321 }
1414 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1322 ORTHANC_PLUGINS_DATABASE_CATCH
1415 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1416 } 1323 }
1417 1324
1418 1325
1419 static OrthancPluginErrorCode RollbackTransaction(void* payload) 1326 static OrthancPluginErrorCode RollbackTransaction(void* payload)
1420 { 1327 {
1424 try 1331 try
1425 { 1332 {
1426 backend->RollbackTransaction(); 1333 backend->RollbackTransaction();
1427 return OrthancPluginErrorCode_Success; 1334 return OrthancPluginErrorCode_Success;
1428 } 1335 }
1429 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1336 ORTHANC_PLUGINS_DATABASE_CATCH
1430 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1431 } 1337 }
1432 1338
1433 1339
1434 static OrthancPluginErrorCode CommitTransaction(void* payload) 1340 static OrthancPluginErrorCode CommitTransaction(void* payload)
1435 { 1341 {
1439 try 1345 try
1440 { 1346 {
1441 backend->CommitTransaction(); 1347 backend->CommitTransaction();
1442 return OrthancPluginErrorCode_Success; 1348 return OrthancPluginErrorCode_Success;
1443 } 1349 }
1444 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1350 ORTHANC_PLUGINS_DATABASE_CATCH
1445 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1446 } 1351 }
1447 1352
1448 1353
1449 static OrthancPluginErrorCode Open(void* payload) 1354 static OrthancPluginErrorCode Open(void* payload)
1450 { 1355 {
1454 try 1359 try
1455 { 1360 {
1456 backend->Open(); 1361 backend->Open();
1457 return OrthancPluginErrorCode_Success; 1362 return OrthancPluginErrorCode_Success;
1458 } 1363 }
1459 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1364 ORTHANC_PLUGINS_DATABASE_CATCH
1460 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1461 } 1365 }
1462 1366
1463 1367
1464 static OrthancPluginErrorCode Close(void* payload) 1368 static OrthancPluginErrorCode Close(void* payload)
1465 { 1369 {
1469 try 1373 try
1470 { 1374 {
1471 backend->Close(); 1375 backend->Close();
1472 return OrthancPluginErrorCode_Success; 1376 return OrthancPluginErrorCode_Success;
1473 } 1377 }
1474 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1378 ORTHANC_PLUGINS_DATABASE_CATCH
1475 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1476 } 1379 }
1477 1380
1478 1381
1479 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version, 1382 static OrthancPluginErrorCode GetDatabaseVersion(uint32_t* version,
1480 void* payload) 1383 void* payload)
1484 try 1387 try
1485 { 1388 {
1486 *version = backend->GetDatabaseVersion(); 1389 *version = backend->GetDatabaseVersion();
1487 return OrthancPluginErrorCode_Success; 1390 return OrthancPluginErrorCode_Success;
1488 } 1391 }
1489 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1392 ORTHANC_PLUGINS_DATABASE_CATCH
1490 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1491 } 1393 }
1492 1394
1493 1395
1494 static OrthancPluginErrorCode UpgradeDatabase(void* payload, 1396 static OrthancPluginErrorCode UpgradeDatabase(void* payload,
1495 uint32_t targetVersion, 1397 uint32_t targetVersion,
1500 try 1402 try
1501 { 1403 {
1502 backend->UpgradeDatabase(targetVersion, storageArea); 1404 backend->UpgradeDatabase(targetVersion, storageArea);
1503 return OrthancPluginErrorCode_Success; 1405 return OrthancPluginErrorCode_Success;
1504 } 1406 }
1505 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1407 ORTHANC_PLUGINS_DATABASE_CATCH
1506 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1507 } 1408 }
1508 1409
1509 1410
1510 static OrthancPluginErrorCode ClearMainDicomTags(void* payload, 1411 static OrthancPluginErrorCode ClearMainDicomTags(void* payload,
1511 int64_t internalId) 1412 int64_t internalId)
1515 try 1416 try
1516 { 1417 {
1517 backend->ClearMainDicomTags(internalId); 1418 backend->ClearMainDicomTags(internalId);
1518 return OrthancPluginErrorCode_Success; 1419 return OrthancPluginErrorCode_Success;
1519 } 1420 }
1520 ORTHANC_PLUGINS_DATABASE_CATCH_ORTHANC 1421 ORTHANC_PLUGINS_DATABASE_CATCH
1521 ORTHANC_PLUGINS_DATABASE_CATCH_COMMON
1522 } 1422 }
1523 1423
1524 1424
1525 public: 1425 public:
1526 /** 1426 /**
1606 { 1506 {
1607 OrthancPluginLogWarning(context, "Performance warning: The database plugin was compiled " 1507 OrthancPluginLogWarning(context, "Performance warning: The database plugin was compiled "
1608 "against an old version of the Orthanc SDK, consider upgrading"); 1508 "against an old version of the Orthanc SDK, consider upgrading");
1609 } 1509 }
1610 1510
1611 OrthancPluginDatabaseContext* database = OrthancPluginRegisterDatabaseBackendV2(context, &params, &extensions, &backend); 1511 OrthancPluginDatabaseContext* database =
1512 OrthancPluginRegisterDatabaseBackendV2(context, &params, &extensions, &backend);
1612 if (!context) 1513 if (!context)
1613 { 1514 {
1614 throw std::runtime_error("Unable to register the database backend"); 1515 throw std::runtime_error("Unable to register the database backend");
1615 } 1516 }
1616 1517