Orthanc Plugin SDK
Documentation of the plugin interface of Orthanc
OrthancCppDatabasePlugin.h
1 
34 #pragma once
35 
36 #include "OrthancCDatabasePlugin.h"
37 
38 #include <stdexcept>
39 #include <list>
40 #include <string>
41 
42 namespace OrthancPlugins
43 {
45  // This class mimics "boost::noncopyable"
46  class NonCopyable
47  {
48  private:
49  NonCopyable(const NonCopyable&);
50 
51  NonCopyable& operator= (const NonCopyable&);
52 
53  protected:
54  NonCopyable()
55  {
56  }
57 
58  ~NonCopyable()
59  {
60  }
61  };
63 
64 
65 
69  class DatabaseBackendOutput : public NonCopyable
70  {
71  friend class DatabaseBackendAdapter;
72 
73  private:
74  enum AllowedAnswers
75  {
76  AllowedAnswers_All,
77  AllowedAnswers_None,
78  AllowedAnswers_Attachment,
79  AllowedAnswers_Change,
80  AllowedAnswers_DicomTag,
81  AllowedAnswers_ExportedResource
82  };
83 
84  OrthancPluginContext* context_;
86  AllowedAnswers allowedAnswers_;
87 
88  void SetAllowedAnswers(AllowedAnswers allowed)
89  {
90  allowedAnswers_ = allowed;
91  }
92 
93  public:
95  OrthancPluginDatabaseContext* database) :
96  context_(context),
97  database_(database),
98  allowedAnswers_(AllowedAnswers_All /* for unit tests */)
99  {
100  }
101 
102  void LogError(const std::string& message)
103  {
104  OrthancPluginLogError(context_, message.c_str());
105  }
106 
107  void LogWarning(const std::string& message)
108  {
109  OrthancPluginLogWarning(context_, message.c_str());
110  }
111 
112  void LogInfo(const std::string& message)
113  {
114  OrthancPluginLogInfo(context_, message.c_str());
115  }
116 
117  void SignalDeletedAttachment(const std::string& uuid,
118  int32_t contentType,
119  uint64_t uncompressedSize,
120  const std::string& uncompressedHash,
121  int32_t compressionType,
122  uint64_t compressedSize,
123  const std::string& compressedHash)
124  {
125  OrthancPluginAttachment attachment;
126  attachment.uuid = uuid.c_str();
127  attachment.contentType = contentType;
128  attachment.uncompressedSize = uncompressedSize;
129  attachment.uncompressedHash = uncompressedHash.c_str();
130  attachment.compressionType = compressionType;
131  attachment.compressedSize = compressedSize;
132  attachment.compressedHash = compressedHash.c_str();
133 
134  OrthancPluginDatabaseSignalDeletedAttachment(context_, database_, &attachment);
135  }
136 
137  void SignalDeletedResource(const std::string& publicId,
138  OrthancPluginResourceType resourceType)
139  {
140  OrthancPluginDatabaseSignalDeletedResource(context_, database_, publicId.c_str(), resourceType);
141  }
142 
143  void SignalRemainingAncestor(const std::string& ancestorId,
144  OrthancPluginResourceType ancestorType)
145  {
146  OrthancPluginDatabaseSignalRemainingAncestor(context_, database_, ancestorId.c_str(), ancestorType);
147  }
148 
149  void AnswerAttachment(const std::string& uuid,
150  int32_t contentType,
151  uint64_t uncompressedSize,
152  const std::string& uncompressedHash,
153  int32_t compressionType,
154  uint64_t compressedSize,
155  const std::string& compressedHash)
156  {
157  if (allowedAnswers_ != AllowedAnswers_All &&
158  allowedAnswers_ != AllowedAnswers_Attachment)
159  {
160  throw std::runtime_error("Cannot answer with an attachment in the current state");
161  }
162 
163  OrthancPluginAttachment attachment;
164  attachment.uuid = uuid.c_str();
165  attachment.contentType = contentType;
166  attachment.uncompressedSize = uncompressedSize;
167  attachment.uncompressedHash = uncompressedHash.c_str();
168  attachment.compressionType = compressionType;
169  attachment.compressedSize = compressedSize;
170  attachment.compressedHash = compressedHash.c_str();
171 
172  OrthancPluginDatabaseAnswerAttachment(context_, database_, &attachment);
173  }
174 
175  void AnswerChange(int64_t seq,
176  int32_t changeType,
177  OrthancPluginResourceType resourceType,
178  const std::string& publicId,
179  const std::string& date)
180  {
181  if (allowedAnswers_ != AllowedAnswers_All &&
182  allowedAnswers_ != AllowedAnswers_Change)
183  {
184  throw std::runtime_error("Cannot answer with a change in the current state");
185  }
186 
187  OrthancPluginChange change;
188  change.seq = seq;
189  change.changeType = changeType;
190  change.resourceType = resourceType;
191  change.publicId = publicId.c_str();
192  change.date = date.c_str();
193 
194  OrthancPluginDatabaseAnswerChange(context_, database_, &change);
195  }
196 
197  void AnswerDicomTag(uint16_t group,
198  uint16_t element,
199  const std::string& value)
200  {
201  if (allowedAnswers_ != AllowedAnswers_All &&
202  allowedAnswers_ != AllowedAnswers_DicomTag)
203  {
204  throw std::runtime_error("Cannot answer with a DICOM tag in the current state");
205  }
206 
207  OrthancPluginDicomTag tag;
208  tag.group = group;
209  tag.element = element;
210  tag.value = value.c_str();
211 
212  OrthancPluginDatabaseAnswerDicomTag(context_, database_, &tag);
213  }
214 
215  void AnswerExportedResource(int64_t seq,
216  OrthancPluginResourceType resourceType,
217  const std::string& publicId,
218  const std::string& modality,
219  const std::string& date,
220  const std::string& patientId,
221  const std::string& studyInstanceUid,
222  const std::string& seriesInstanceUid,
223  const std::string& sopInstanceUid)
224  {
225  if (allowedAnswers_ != AllowedAnswers_All &&
226  allowedAnswers_ != AllowedAnswers_ExportedResource)
227  {
228  throw std::runtime_error("Cannot answer with an exported resource in the current state");
229  }
230 
231  OrthancPluginExportedResource exported;
232  exported.seq = seq;
233  exported.resourceType = resourceType;
234  exported.publicId = publicId.c_str();
235  exported.modality = modality.c_str();
236  exported.date = date.c_str();
237  exported.patientId = patientId.c_str();
238  exported.studyInstanceUid = studyInstanceUid.c_str();
239  exported.seriesInstanceUid = seriesInstanceUid.c_str();
240  exported.sopInstanceUid = sopInstanceUid.c_str();
241 
242  OrthancPluginDatabaseAnswerExportedResource(context_, database_, &exported);
243  }
244  };
245 
246 
250  class IDatabaseBackend : public NonCopyable
251  {
252  friend class DatabaseBackendAdapter;
253 
254  private:
255  DatabaseBackendOutput* output_;
256 
257  void Finalize()
258  {
259  if (output_ != NULL)
260  {
261  delete output_;
262  output_ = NULL;
263  }
264  }
265 
266  protected:
267  DatabaseBackendOutput& GetOutput()
268  {
269  return *output_;
270  }
271 
272  public:
273  IDatabaseBackend() : output_(NULL)
274  {
275  }
276 
277  virtual ~IDatabaseBackend()
278  {
279  Finalize();
280  }
281 
282  // This takes the ownership
283  void RegisterOutput(DatabaseBackendOutput* output)
284  {
285  Finalize();
286  output_ = output;
287  }
288 
289  virtual void Open() = 0;
290 
291  virtual void Close() = 0;
292 
293  virtual void AddAttachment(int64_t id,
294  const OrthancPluginAttachment& attachment) = 0;
295 
296  virtual void AttachChild(int64_t parent,
297  int64_t child) = 0;
298 
299  virtual void ClearChanges() = 0;
300 
301  virtual void ClearExportedResources() = 0;
302 
303  virtual int64_t CreateResource(const char* publicId,
304  OrthancPluginResourceType type) = 0;
305 
306  virtual void DeleteAttachment(int64_t id,
307  int32_t attachment) = 0;
308 
309  virtual void DeleteMetadata(int64_t id,
310  int32_t metadataType) = 0;
311 
312  virtual void DeleteResource(int64_t id) = 0;
313 
314  virtual void GetAllPublicIds(std::list<std::string>& target,
315  OrthancPluginResourceType resourceType) = 0;
316 
317  virtual void GetAllPublicIds(std::list<std::string>& target,
318  OrthancPluginResourceType resourceType,
319  uint64_t since,
320  uint64_t limit) = 0;
321 
322  /* Use GetOutput().AnswerChange() */
323  virtual void GetChanges(bool& done /*out*/,
324  int64_t since,
325  uint32_t maxResults) = 0;
326 
327  virtual void GetChildrenInternalId(std::list<int64_t>& target /*out*/,
328  int64_t id) = 0;
329 
330  virtual void GetChildrenPublicId(std::list<std::string>& target /*out*/,
331  int64_t id) = 0;
332 
333  /* Use GetOutput().AnswerExportedResource() */
334  virtual void GetExportedResources(bool& done /*out*/,
335  int64_t since,
336  uint32_t maxResults) = 0;
337 
338  /* Use GetOutput().AnswerChange() */
339  virtual void GetLastChange() = 0;
340 
341  /* Use GetOutput().AnswerExportedResource() */
342  virtual void GetLastExportedResource() = 0;
343 
344  /* Use GetOutput().AnswerDicomTag() */
345  virtual void GetMainDicomTags(int64_t id) = 0;
346 
347  virtual std::string GetPublicId(int64_t resourceId) = 0;
348 
349  virtual uint64_t GetResourceCount(OrthancPluginResourceType resourceType) = 0;
350 
351  virtual OrthancPluginResourceType GetResourceType(int64_t resourceId) = 0;
352 
353  virtual uint64_t GetTotalCompressedSize() = 0;
354 
355  virtual uint64_t GetTotalUncompressedSize() = 0;
356 
357  virtual bool IsExistingResource(int64_t internalId) = 0;
358 
359  virtual bool IsProtectedPatient(int64_t internalId) = 0;
360 
361  virtual void ListAvailableMetadata(std::list<int32_t>& target /*out*/,
362  int64_t id) = 0;
363 
364  virtual void ListAvailableAttachments(std::list<int32_t>& target /*out*/,
365  int64_t id) = 0;
366 
367  virtual void LogChange(const OrthancPluginChange& change) = 0;
368 
369  virtual void LogExportedResource(const OrthancPluginExportedResource& resource) = 0;
370 
371  /* Use GetOutput().AnswerAttachment() */
372  virtual bool LookupAttachment(int64_t id,
373  int32_t contentType) = 0;
374 
375  virtual bool LookupGlobalProperty(std::string& target /*out*/,
376  int32_t property) = 0;
377 
384  virtual void LookupIdentifier(std::list<int64_t>& target /*out*/,
385  uint16_t group,
386  uint16_t element,
387  const char* value) = 0;
388 
389  virtual void LookupIdentifier(std::list<int64_t>& target /*out*/,
390  const char* value) = 0;
391 
392  virtual bool LookupMetadata(std::string& target /*out*/,
393  int64_t id,
394  int32_t metadataType) = 0;
395 
396  virtual bool LookupParent(int64_t& parentId /*out*/,
397  int64_t resourceId) = 0;
398 
399  virtual bool LookupResource(int64_t& id /*out*/,
400  OrthancPluginResourceType& type /*out*/,
401  const char* publicId) = 0;
402 
403  virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/) = 0;
404 
405  virtual bool SelectPatientToRecycle(int64_t& internalId /*out*/,
406  int64_t patientIdToAvoid) = 0;
407 
408  virtual void SetGlobalProperty(int32_t property,
409  const char* value) = 0;
410 
411  virtual void SetMainDicomTag(int64_t id,
412  uint16_t group,
413  uint16_t element,
414  const char* value) = 0;
415 
416  virtual void SetIdentifierTag(int64_t id,
417  uint16_t group,
418  uint16_t element,
419  const char* value) = 0;
420 
421  virtual void SetMetadata(int64_t id,
422  int32_t metadataType,
423  const char* value) = 0;
424 
425  virtual void SetProtectedPatient(int64_t internalId,
426  bool isProtected) = 0;
427 
428  virtual void StartTransaction() = 0;
429 
430  virtual void RollbackTransaction() = 0;
431 
432  virtual void CommitTransaction() = 0;
433 
434  virtual uint32_t GetDatabaseVersion() = 0;
435 
436  virtual void UpgradeDatabase(uint32_t targetVersion,
437  OrthancPluginStorageArea* storageArea) = 0;
438  };
439 
440 
441 
452  {
453  private:
454  // This class cannot be instantiated
456  {
457  }
458 
459  static void LogError(IDatabaseBackend* backend,
460  const std::runtime_error& e)
461  {
462  backend->GetOutput().LogError("Exception in database back-end: " + std::string(e.what()));
463  }
464 
465 
466  static int32_t AddAttachment(void* payload,
467  int64_t id,
468  const OrthancPluginAttachment* attachment)
469  {
470  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
471  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
472 
473  try
474  {
475  backend->AddAttachment(id, *attachment);
476  return 0;
477  }
478  catch (std::runtime_error& e)
479  {
480  LogError(backend, e);
481  return -1;
482  }
483  }
484 
485 
486  static int32_t AttachChild(void* payload,
487  int64_t parent,
488  int64_t child)
489  {
490  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
491  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
492 
493  try
494  {
495  backend->AttachChild(parent, child);
496  return 0;
497  }
498  catch (std::runtime_error& e)
499  {
500  LogError(backend, e);
501  return -1;
502  }
503  }
504 
505 
506  static int32_t ClearChanges(void* payload)
507  {
508  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
509  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
510 
511  try
512  {
513  backend->ClearChanges();
514  return 0;
515  }
516  catch (std::runtime_error& e)
517  {
518  LogError(backend, e);
519  return -1;
520  }
521  }
522 
523 
524  static int32_t ClearExportedResources(void* payload)
525  {
526  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
527  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
528 
529  try
530  {
531  backend->ClearExportedResources();
532  return 0;
533  }
534  catch (std::runtime_error& e)
535  {
536  LogError(backend, e);
537  return -1;
538  }
539  }
540 
541 
542  static int32_t CreateResource(int64_t* id,
543  void* payload,
544  const char* publicId,
545  OrthancPluginResourceType resourceType)
546  {
547  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
548  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
549 
550  try
551  {
552  *id = backend->CreateResource(publicId, resourceType);
553  return 0;
554  }
555  catch (std::runtime_error& e)
556  {
557  LogError(backend, e);
558  return -1;
559  }
560  }
561 
562 
563  static int32_t DeleteAttachment(void* payload,
564  int64_t id,
565  int32_t contentType)
566  {
567  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
568  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
569 
570  try
571  {
572  backend->DeleteAttachment(id, contentType);
573  return 0;
574  }
575  catch (std::runtime_error& e)
576  {
577  LogError(backend, e);
578  return -1;
579  }
580  }
581 
582 
583  static int32_t DeleteMetadata(void* payload,
584  int64_t id,
585  int32_t metadataType)
586  {
587  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
588  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
589 
590  try
591  {
592  backend->DeleteMetadata(id, metadataType);
593  return 0;
594  }
595  catch (std::runtime_error& e)
596  {
597  LogError(backend, e);
598  return -1;
599  }
600  }
601 
602 
603  static int32_t DeleteResource(void* payload,
604  int64_t id)
605  {
606  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
607  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
608 
609  try
610  {
611  backend->DeleteResource(id);
612  return 0;
613  }
614  catch (std::runtime_error& e)
615  {
616  LogError(backend, e);
617  return -1;
618  }
619  }
620 
621 
622  static int32_t GetAllPublicIds(OrthancPluginDatabaseContext* context,
623  void* payload,
624  OrthancPluginResourceType resourceType)
625  {
626  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
627  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
628 
629  try
630  {
631  std::list<std::string> ids;
632  backend->GetAllPublicIds(ids, resourceType);
633 
634  for (std::list<std::string>::const_iterator
635  it = ids.begin(); it != ids.end(); ++it)
636  {
637  OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
638  backend->GetOutput().database_,
639  it->c_str());
640  }
641 
642  return 0;
643  }
644  catch (std::runtime_error& e)
645  {
646  LogError(backend, e);
647  return -1;
648  }
649  }
650 
651 
652  static int32_t GetAllPublicIdsWithLimit(OrthancPluginDatabaseContext* context,
653  void* payload,
654  OrthancPluginResourceType resourceType,
655  uint64_t since,
656  uint64_t limit)
657  {
658  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
659  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
660 
661  try
662  {
663  std::list<std::string> ids;
664  backend->GetAllPublicIds(ids, resourceType, since, limit);
665 
666  for (std::list<std::string>::const_iterator
667  it = ids.begin(); it != ids.end(); ++it)
668  {
669  OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
670  backend->GetOutput().database_,
671  it->c_str());
672  }
673 
674  return 0;
675  }
676  catch (std::runtime_error& e)
677  {
678  LogError(backend, e);
679  return -1;
680  }
681  }
682 
683 
684  static int32_t GetChanges(OrthancPluginDatabaseContext* context,
685  void* payload,
686  int64_t since,
687  uint32_t maxResult)
688  {
689  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
690  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change);
691 
692  try
693  {
694  bool done;
695  backend->GetChanges(done, since, maxResult);
696 
697  if (done)
698  {
699  OrthancPluginDatabaseAnswerChangesDone(backend->GetOutput().context_,
700  backend->GetOutput().database_);
701  }
702 
703  return 0;
704  }
705  catch (std::runtime_error& e)
706  {
707  LogError(backend, e);
708  return -1;
709  }
710  }
711 
712 
713  static int32_t GetChildrenInternalId(OrthancPluginDatabaseContext* context,
714  void* payload,
715  int64_t id)
716  {
717  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
718  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
719 
720  try
721  {
722  std::list<int64_t> target;
723  backend->GetChildrenInternalId(target, id);
724 
725  for (std::list<int64_t>::const_iterator
726  it = target.begin(); it != target.end(); ++it)
727  {
728  OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
729  backend->GetOutput().database_, *it);
730  }
731 
732  return 0;
733  }
734  catch (std::runtime_error& e)
735  {
736  LogError(backend, e);
737  return -1;
738  }
739  }
740 
741 
742  static int32_t GetChildrenPublicId(OrthancPluginDatabaseContext* context,
743  void* payload,
744  int64_t id)
745  {
746  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
747  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
748 
749  try
750  {
751  std::list<std::string> ids;
752  backend->GetChildrenPublicId(ids, id);
753 
754  for (std::list<std::string>::const_iterator
755  it = ids.begin(); it != ids.end(); ++it)
756  {
757  OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
758  backend->GetOutput().database_,
759  it->c_str());
760  }
761 
762  return 0;
763  }
764  catch (std::runtime_error& e)
765  {
766  LogError(backend, e);
767  return -1;
768  }
769  }
770 
771 
772  static int32_t GetExportedResources(OrthancPluginDatabaseContext* context,
773  void* payload,
774  int64_t since,
775  uint32_t maxResult)
776  {
777  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
778  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource);
779 
780  try
781  {
782  bool done;
783  backend->GetExportedResources(done, since, maxResult);
784 
785  if (done)
786  {
787  OrthancPluginDatabaseAnswerExportedResourcesDone(backend->GetOutput().context_,
788  backend->GetOutput().database_);
789  }
790  return 0;
791  }
792  catch (std::runtime_error& e)
793  {
794  LogError(backend, e);
795  return -1;
796  }
797  }
798 
799 
800  static int32_t GetLastChange(OrthancPluginDatabaseContext* context,
801  void* payload)
802  {
803  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
804  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Change);
805 
806  try
807  {
808  backend->GetLastChange();
809  return 0;
810  }
811  catch (std::runtime_error& e)
812  {
813  LogError(backend, e);
814  return -1;
815  }
816  }
817 
818 
819  static int32_t GetLastExportedResource(OrthancPluginDatabaseContext* context,
820  void* payload)
821  {
822  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
823  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_ExportedResource);
824 
825  try
826  {
827  backend->GetLastExportedResource();
828  return 0;
829  }
830  catch (std::runtime_error& e)
831  {
832  LogError(backend, e);
833  return -1;
834  }
835  }
836 
837 
838  static int32_t GetMainDicomTags(OrthancPluginDatabaseContext* context,
839  void* payload,
840  int64_t id)
841  {
842  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
843  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_DicomTag);
844 
845  try
846  {
847  backend->GetMainDicomTags(id);
848  return 0;
849  }
850  catch (std::runtime_error& e)
851  {
852  LogError(backend, e);
853  return -1;
854  }
855  }
856 
857 
858  static int32_t GetPublicId(OrthancPluginDatabaseContext* context,
859  void* payload,
860  int64_t id)
861  {
862  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
863  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
864 
865  try
866  {
867  std::string s = backend->GetPublicId(id);
868  OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
869  backend->GetOutput().database_,
870  s.c_str());
871 
872  return 0;
873  }
874  catch (std::runtime_error& e)
875  {
876  LogError(backend, e);
877  return -1;
878  }
879  }
880 
881 
882  static int32_t GetResourceCount(uint64_t* target,
883  void* payload,
884  OrthancPluginResourceType resourceType)
885  {
886  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
887  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
888 
889  try
890  {
891  *target = backend->GetResourceCount(resourceType);
892  return 0;
893  }
894  catch (std::runtime_error& e)
895  {
896  LogError(backend, e);
897  return -1;
898  }
899  }
900 
901 
902  static int32_t GetResourceType(OrthancPluginResourceType* resourceType,
903  void* payload,
904  int64_t id)
905  {
906  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
907  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
908 
909  try
910  {
911  *resourceType = backend->GetResourceType(id);
912  return 0;
913  }
914  catch (std::runtime_error& e)
915  {
916  LogError(backend, e);
917  return -1;
918  }
919  }
920 
921 
922  static int32_t GetTotalCompressedSize(uint64_t* target,
923  void* payload)
924  {
925  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
926  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
927 
928  try
929  {
930  *target = backend->GetTotalCompressedSize();
931  return 0;
932  }
933  catch (std::runtime_error& e)
934  {
935  LogError(backend, e);
936  return -1;
937  }
938  }
939 
940 
941  static int32_t GetTotalUncompressedSize(uint64_t* target,
942  void* payload)
943  {
944  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
945  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
946 
947  try
948  {
949  *target = backend->GetTotalUncompressedSize();
950  return 0;
951  }
952  catch (std::runtime_error& e)
953  {
954  LogError(backend, e);
955  return -1;
956  }
957  }
958 
959 
960  static int32_t IsExistingResource(int32_t* existing,
961  void* payload,
962  int64_t id)
963  {
964  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
965  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
966 
967  try
968  {
969  *existing = backend->IsExistingResource(id);
970  return 0;
971  }
972  catch (std::runtime_error& e)
973  {
974  LogError(backend, e);
975  return -1;
976  }
977  }
978 
979 
980  static int32_t IsProtectedPatient(int32_t* isProtected,
981  void* payload,
982  int64_t id)
983  {
984  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
985  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
986 
987  try
988  {
989  *isProtected = backend->IsProtectedPatient(id);
990  return 0;
991  }
992  catch (std::runtime_error& e)
993  {
994  LogError(backend, e);
995  return -1;
996  }
997  }
998 
999 
1000  static int32_t ListAvailableMetadata(OrthancPluginDatabaseContext* context,
1001  void* payload,
1002  int64_t id)
1003  {
1004  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1005  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1006 
1007  try
1008  {
1009  std::list<int32_t> target;
1010  backend->ListAvailableMetadata(target, id);
1011 
1012  for (std::list<int32_t>::const_iterator
1013  it = target.begin(); it != target.end(); ++it)
1014  {
1015  OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_,
1016  backend->GetOutput().database_,
1017  *it);
1018  }
1019 
1020  return 0;
1021  }
1022  catch (std::runtime_error& e)
1023  {
1024  LogError(backend, e);
1025  return -1;
1026  }
1027  }
1028 
1029 
1030  static int32_t ListAvailableAttachments(OrthancPluginDatabaseContext* context,
1031  void* payload,
1032  int64_t id)
1033  {
1034  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1035  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1036 
1037  try
1038  {
1039  std::list<int32_t> target;
1040  backend->ListAvailableAttachments(target, id);
1041 
1042  for (std::list<int32_t>::const_iterator
1043  it = target.begin(); it != target.end(); ++it)
1044  {
1045  OrthancPluginDatabaseAnswerInt32(backend->GetOutput().context_,
1046  backend->GetOutput().database_,
1047  *it);
1048  }
1049 
1050  return 0;
1051  }
1052  catch (std::runtime_error& e)
1053  {
1054  LogError(backend, e);
1055  return -1;
1056  }
1057  }
1058 
1059 
1060  static int32_t LogChange(void* payload,
1061  const OrthancPluginChange* change)
1062  {
1063  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1064  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1065 
1066  try
1067  {
1068  backend->LogChange(*change);
1069  return 0;
1070  }
1071  catch (std::runtime_error& e)
1072  {
1073  LogError(backend, e);
1074  return -1;
1075  }
1076  }
1077 
1078 
1079  static int32_t LogExportedResource(void* payload,
1080  const OrthancPluginExportedResource* exported)
1081  {
1082  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1083  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1084 
1085  try
1086  {
1087  backend->LogExportedResource(*exported);
1088  return 0;
1089  }
1090  catch (std::runtime_error& e)
1091  {
1092  LogError(backend, e);
1093  return -1;
1094  }
1095  }
1096 
1097 
1098  static int32_t LookupAttachment(OrthancPluginDatabaseContext* context,
1099  void* payload,
1100  int64_t id,
1101  int32_t contentType)
1102  {
1103  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1104  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_Attachment);
1105 
1106  try
1107  {
1108  backend->LookupAttachment(id, contentType);
1109  return 0;
1110  }
1111  catch (std::runtime_error& e)
1112  {
1113  LogError(backend, e);
1114  return -1;
1115  }
1116  }
1117 
1118 
1119  static int32_t LookupGlobalProperty(OrthancPluginDatabaseContext* context,
1120  void* payload,
1121  int32_t property)
1122  {
1123  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1124  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1125 
1126  try
1127  {
1128  std::string s;
1129  if (backend->LookupGlobalProperty(s, property))
1130  {
1131  OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
1132  backend->GetOutput().database_,
1133  s.c_str());
1134  }
1135 
1136  return 0;
1137  }
1138  catch (std::runtime_error& e)
1139  {
1140  LogError(backend, e);
1141  return -1;
1142  }
1143  }
1144 
1145 
1146  static int32_t LookupIdentifier(OrthancPluginDatabaseContext* context,
1147  void* payload,
1148  const OrthancPluginDicomTag* tag)
1149  {
1150  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1151  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1152 
1153  try
1154  {
1155  std::list<int64_t> target;
1156  backend->LookupIdentifier(target, tag->group, tag->element, tag->value);
1157 
1158  for (std::list<int64_t>::const_iterator
1159  it = target.begin(); it != target.end(); ++it)
1160  {
1161  OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1162  backend->GetOutput().database_, *it);
1163  }
1164 
1165  return 0;
1166  }
1167  catch (std::runtime_error& e)
1168  {
1169  LogError(backend, e);
1170  return -1;
1171  }
1172  }
1173 
1174 
1175  static int32_t LookupIdentifier2(OrthancPluginDatabaseContext* context,
1176  void* payload,
1177  const char* value)
1178  {
1179  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1180  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1181 
1182  try
1183  {
1184  std::list<int64_t> target;
1185  backend->LookupIdentifier(target, value);
1186 
1187  for (std::list<int64_t>::const_iterator
1188  it = target.begin(); it != target.end(); ++it)
1189  {
1190  OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1191  backend->GetOutput().database_, *it);
1192  }
1193 
1194  return 0;
1195  }
1196  catch (std::runtime_error& e)
1197  {
1198  LogError(backend, e);
1199  return -1;
1200  }
1201  }
1202 
1203 
1204  static int32_t LookupMetadata(OrthancPluginDatabaseContext* context,
1205  void* payload,
1206  int64_t id,
1207  int32_t metadata)
1208  {
1209  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1210  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1211 
1212  try
1213  {
1214  std::string s;
1215  if (backend->LookupMetadata(s, id, metadata))
1216  {
1217  OrthancPluginDatabaseAnswerString(backend->GetOutput().context_,
1218  backend->GetOutput().database_, s.c_str());
1219  }
1220 
1221  return 0;
1222  }
1223  catch (std::runtime_error& e)
1224  {
1225  LogError(backend, e);
1226  return -1;
1227  }
1228  }
1229 
1230 
1231  static int32_t LookupParent(OrthancPluginDatabaseContext* context,
1232  void* payload,
1233  int64_t id)
1234  {
1235  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1236  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1237 
1238  try
1239  {
1240  int64_t parent;
1241  if (backend->LookupParent(parent, id))
1242  {
1243  OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1244  backend->GetOutput().database_, parent);
1245  }
1246 
1247  return 0;
1248  }
1249  catch (std::runtime_error& e)
1250  {
1251  LogError(backend, e);
1252  return -1;
1253  }
1254  }
1255 
1256 
1257  static int32_t LookupResource(OrthancPluginDatabaseContext* context,
1258  void* payload,
1259  const char* publicId)
1260  {
1261  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1262  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1263 
1264  try
1265  {
1266  int64_t id;
1268  if (backend->LookupResource(id, type, publicId))
1269  {
1270  OrthancPluginDatabaseAnswerResource(backend->GetOutput().context_,
1271  backend->GetOutput().database_,
1272  id, type);
1273  }
1274 
1275  return 0;
1276  }
1277  catch (std::runtime_error& e)
1278  {
1279  LogError(backend, e);
1280  return -1;
1281  }
1282  }
1283 
1284 
1285  static int32_t SelectPatientToRecycle(OrthancPluginDatabaseContext* context,
1286  void* payload)
1287  {
1288  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1289  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1290 
1291  try
1292  {
1293  int64_t id;
1294  if (backend->SelectPatientToRecycle(id))
1295  {
1296  OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1297  backend->GetOutput().database_, id);
1298  }
1299 
1300  return 0;
1301  }
1302  catch (std::runtime_error& e)
1303  {
1304  LogError(backend, e);
1305  return -1;
1306  }
1307  }
1308 
1309 
1310  static int32_t SelectPatientToRecycle2(OrthancPluginDatabaseContext* context,
1311  void* payload,
1312  int64_t patientIdToAvoid)
1313  {
1314  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1315  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1316 
1317  try
1318  {
1319  int64_t id;
1320  if (backend->SelectPatientToRecycle(id, patientIdToAvoid))
1321  {
1322  OrthancPluginDatabaseAnswerInt64(backend->GetOutput().context_,
1323  backend->GetOutput().database_, id);
1324  }
1325 
1326  return 0;
1327  }
1328  catch (std::runtime_error& e)
1329  {
1330  LogError(backend, e);
1331  return -1;
1332  }
1333  }
1334 
1335 
1336  static int32_t SetGlobalProperty(void* payload,
1337  int32_t property,
1338  const char* value)
1339  {
1340  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1341  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1342 
1343  try
1344  {
1345  backend->SetGlobalProperty(property, value);
1346  return 0;
1347  }
1348  catch (std::runtime_error& e)
1349  {
1350  LogError(backend, e);
1351  return -1;
1352  }
1353  }
1354 
1355 
1356  static int32_t SetMainDicomTag(void* payload,
1357  int64_t id,
1358  const OrthancPluginDicomTag* tag)
1359  {
1360  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1361  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1362 
1363  try
1364  {
1365  backend->SetMainDicomTag(id, tag->group, tag->element, tag->value);
1366  return 0;
1367  }
1368  catch (std::runtime_error& e)
1369  {
1370  LogError(backend, e);
1371  return -1;
1372  }
1373  }
1374 
1375 
1376  static int32_t SetIdentifierTag(void* payload,
1377  int64_t id,
1378  const OrthancPluginDicomTag* tag)
1379  {
1380  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1381  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1382 
1383  try
1384  {
1385  backend->SetIdentifierTag(id, tag->group, tag->element, tag->value);
1386  return 0;
1387  }
1388  catch (std::runtime_error& e)
1389  {
1390  LogError(backend, e);
1391  return -1;
1392  }
1393  }
1394 
1395 
1396  static int32_t SetMetadata(void* payload,
1397  int64_t id,
1398  int32_t metadata,
1399  const char* value)
1400  {
1401  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1402  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1403 
1404  try
1405  {
1406  backend->SetMetadata(id, metadata, value);
1407  return 0;
1408  }
1409  catch (std::runtime_error& e)
1410  {
1411  LogError(backend, e);
1412  return -1;
1413  }
1414  }
1415 
1416 
1417  static int32_t SetProtectedPatient(void* payload,
1418  int64_t id,
1419  int32_t isProtected)
1420  {
1421  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1422  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1423 
1424  try
1425  {
1426  backend->SetProtectedPatient(id, (isProtected != 0));
1427  return 0;
1428  }
1429  catch (std::runtime_error& e)
1430  {
1431  LogError(backend, e);
1432  return -1;
1433  }
1434  }
1435 
1436 
1437  static int32_t StartTransaction(void* payload)
1438  {
1439  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1440  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1441 
1442  try
1443  {
1444  backend->StartTransaction();
1445  return 0;
1446  }
1447  catch (std::runtime_error& e)
1448  {
1449  LogError(backend, e);
1450  return -1;
1451  }
1452  }
1453 
1454 
1455  static int32_t RollbackTransaction(void* payload)
1456  {
1457  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1458  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1459 
1460  try
1461  {
1462  backend->RollbackTransaction();
1463  return 0;
1464  }
1465  catch (std::runtime_error& e)
1466  {
1467  LogError(backend, e);
1468  return -1;
1469  }
1470  }
1471 
1472 
1473  static int32_t CommitTransaction(void* payload)
1474  {
1475  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1476  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1477 
1478  try
1479  {
1480  backend->CommitTransaction();
1481  return 0;
1482  }
1483  catch (std::runtime_error& e)
1484  {
1485  LogError(backend, e);
1486  return -1;
1487  }
1488  }
1489 
1490 
1491  static int32_t Open(void* payload)
1492  {
1493  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1494  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1495 
1496  try
1497  {
1498  backend->Open();
1499  return 0;
1500  }
1501  catch (std::runtime_error& e)
1502  {
1503  LogError(backend, e);
1504  return -1;
1505  }
1506  }
1507 
1508 
1509  static int32_t Close(void* payload)
1510  {
1511  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1512  backend->GetOutput().SetAllowedAnswers(DatabaseBackendOutput::AllowedAnswers_None);
1513 
1514  try
1515  {
1516  backend->Close();
1517  return 0;
1518  }
1519  catch (std::runtime_error& e)
1520  {
1521  LogError(backend, e);
1522  return -1;
1523  }
1524  }
1525 
1526 
1527  static int32_t GetDatabaseVersion(uint32_t* version,
1528  void* payload)
1529  {
1530  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1531 
1532  try
1533  {
1534  *version = backend->GetDatabaseVersion();
1535  return 0;
1536  }
1537  catch (std::runtime_error& e)
1538  {
1539  LogError(backend, e);
1540  return -1;
1541  }
1542  }
1543 
1544 
1545  static int32_t UpgradeDatabase(void* payload,
1546  uint32_t targetVersion,
1547  OrthancPluginStorageArea* storageArea)
1548  {
1549  IDatabaseBackend* backend = reinterpret_cast<IDatabaseBackend*>(payload);
1550 
1551  try
1552  {
1553  backend->UpgradeDatabase(targetVersion, storageArea);
1554  return 0;
1555  }
1556  catch (std::runtime_error& e)
1557  {
1558  LogError(backend, e);
1559  return -1;
1560  }
1561  }
1562 
1563 
1564  public:
1572  static void Register(OrthancPluginContext* context,
1573  IDatabaseBackend& backend)
1574  {
1575  OrthancPluginDatabaseBackend params;
1576  memset(&params, 0, sizeof(params));
1577 
1578  OrthancPluginDatabaseExtensions extensions;
1579  memset(&extensions, 0, sizeof(extensions));
1580 
1581  params.addAttachment = AddAttachment;
1582  params.attachChild = AttachChild;
1583  params.clearChanges = ClearChanges;
1584  params.clearExportedResources = ClearExportedResources;
1585  params.createResource = CreateResource;
1586  params.deleteAttachment = DeleteAttachment;
1587  params.deleteMetadata = DeleteMetadata;
1588  params.deleteResource = DeleteResource;
1589  params.getAllPublicIds = GetAllPublicIds;
1590  params.getChanges = GetChanges;
1591  params.getChildrenInternalId = GetChildrenInternalId;
1592  params.getChildrenPublicId = GetChildrenPublicId;
1593  params.getExportedResources = GetExportedResources;
1594  params.getLastChange = GetLastChange;
1595  params.getLastExportedResource = GetLastExportedResource;
1596  params.getMainDicomTags = GetMainDicomTags;
1597  params.getPublicId = GetPublicId;
1598  params.getResourceCount = GetResourceCount;
1599  params.getResourceType = GetResourceType;
1600  params.getTotalCompressedSize = GetTotalCompressedSize;
1601  params.getTotalUncompressedSize = GetTotalUncompressedSize;
1602  params.isExistingResource = IsExistingResource;
1603  params.isProtectedPatient = IsProtectedPatient;
1604  params.listAvailableMetadata = ListAvailableMetadata;
1605  params.listAvailableAttachments = ListAvailableAttachments;
1606  params.logChange = LogChange;
1607  params.logExportedResource = LogExportedResource;
1608  params.lookupAttachment = LookupAttachment;
1609  params.lookupGlobalProperty = LookupGlobalProperty;
1610  params.lookupIdentifier = LookupIdentifier;
1611  params.lookupIdentifier2 = LookupIdentifier2;
1612  params.lookupMetadata = LookupMetadata;
1613  params.lookupParent = LookupParent;
1614  params.lookupResource = LookupResource;
1615  params.selectPatientToRecycle = SelectPatientToRecycle;
1616  params.selectPatientToRecycle2 = SelectPatientToRecycle2;
1617  params.setGlobalProperty = SetGlobalProperty;
1618  params.setMainDicomTag = SetMainDicomTag;
1619  params.setIdentifierTag = SetIdentifierTag;
1620  params.setMetadata = SetMetadata;
1621  params.setProtectedPatient = SetProtectedPatient;
1622  params.startTransaction = StartTransaction;
1623  params.rollbackTransaction = RollbackTransaction;
1624  params.commitTransaction = CommitTransaction;
1625  params.open = Open;
1626  params.close = Close;
1627 
1628  extensions.getAllPublicIdsWithLimit = GetAllPublicIdsWithLimit;
1629  extensions.getDatabaseVersion = GetDatabaseVersion;
1630  extensions.upgradeDatabase = UpgradeDatabase;
1631 
1632  OrthancPluginDatabaseContext* database = OrthancPluginRegisterDatabaseBackendV2(context, &params, &extensions, &backend);
1633  if (!context)
1634  {
1635  throw std::runtime_error("Unable to register the database backend");
1636  }
1637 
1638  backend.RegisterOutput(new DatabaseBackendOutput(context, database));
1639  }
1640  };
1641 }
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:924
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:647
OrthancPluginResourceType
Definition: OrthancCPlugin.h:535
static void Register(OrthancPluginContext *context, IDatabaseBackend &backend)
Definition: OrthancCppDatabasePlugin.h:1572
virtual void LookupIdentifier(std::list< int64_t > &target, uint16_t group, uint16_t element, const char *value)=0
Definition: OrthancCppDatabasePlugin.h:42
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:892
Bridge between C and C++ database engines.
Definition: OrthancCppDatabasePlugin.h:451
Definition: OrthancCppDatabasePlugin.h:69
struct _OrthancPluginDatabaseContext_t OrthancPluginDatabaseContext
Definition: OrthancCDatabasePlugin.h:55
OrthancPluginDatabaseContext * OrthancPluginRegisterDatabaseBackendV2(OrthancPluginContext *context, const OrthancPluginDatabaseBackend *backend, const OrthancPluginDatabaseExtensions *extensions, void *payload)
Definition: OrthancCDatabasePlugin.h:742
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:908
Definition: OrthancCppDatabasePlugin.h:250