Mercurial > hg > orthanc
comparison Plugins/Samples/Common/OrthancPluginCppWrapper.cpp @ 2176:fead5549aaa7
introduction of HAS_ORTHANC_EXCEPTION to avoid PluginException if not necessary
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Fri, 25 Nov 2016 12:07:36 +0100 |
parents | aa2915963531 |
children | 11420238f337 |
comparison
equal
deleted
inserted
replaced
2175:bed8e7ad8bab | 2176:fead5549aaa7 |
---|---|
34 | 34 |
35 #include <json/reader.h> | 35 #include <json/reader.h> |
36 #include <json/writer.h> | 36 #include <json/writer.h> |
37 | 37 |
38 | 38 |
39 #if HAS_ORTHANC_EXCEPTION == 1 | |
40 # define THROW_EXCEPTION(code) throw Orthanc::OrthancException(static_cast<Orthanc::ErrorCode>(code)) | |
41 #else | |
42 # define THROW_EXCEPTION(code) throw PluginException(code) | |
43 #endif | |
44 | |
45 | |
46 | |
39 namespace OrthancPlugins | 47 namespace OrthancPlugins |
40 { | 48 { |
41 const char* PluginException::GetErrorDescription(OrthancPluginContext* context) const | 49 void ThrowException(OrthancPluginErrorCode code) |
42 { | 50 { |
43 const char* description = OrthancPluginGetErrorDescription(context, code_); | 51 THROW_EXCEPTION(code); |
52 } | |
53 | |
54 | |
55 const char* GetErrorDescription(OrthancPluginContext* context, | |
56 OrthancPluginErrorCode code) | |
57 { | |
58 const char* description = OrthancPluginGetErrorDescription(context, code); | |
44 if (description) | 59 if (description) |
45 { | 60 { |
46 return description; | 61 return description; |
47 } | 62 } |
48 else | 63 else |
50 return "No description available"; | 65 return "No description available"; |
51 } | 66 } |
52 } | 67 } |
53 | 68 |
54 | 69 |
70 #if HAS_ORTHANC_EXCEPTION == 0 | |
55 void PluginException::Check(OrthancPluginErrorCode code) | 71 void PluginException::Check(OrthancPluginErrorCode code) |
56 { | 72 { |
57 if (code != OrthancPluginErrorCode_Success) | 73 if (code != OrthancPluginErrorCode_Success) |
58 { | 74 { |
59 throw PluginException(code); | 75 THROW_EXCEPTION(code); |
60 } | 76 } |
61 } | 77 } |
78 #endif | |
62 | 79 |
63 | 80 |
64 void MemoryBuffer::Check(OrthancPluginErrorCode code) | 81 void MemoryBuffer::Check(OrthancPluginErrorCode code) |
65 { | 82 { |
66 if (code != OrthancPluginErrorCode_Success) | 83 if (code != OrthancPluginErrorCode_Success) |
67 { | 84 { |
68 // Prevent using garbage information | 85 // Prevent using garbage information |
69 buffer_.data = NULL; | 86 buffer_.data = NULL; |
70 buffer_.size = 0; | 87 buffer_.size = 0; |
71 throw PluginException(code); | 88 THROW_EXCEPTION(code); |
72 } | 89 } |
73 } | 90 } |
74 | 91 |
75 | 92 |
76 MemoryBuffer::MemoryBuffer(OrthancPluginContext* context) : | 93 MemoryBuffer::MemoryBuffer(OrthancPluginContext* context) : |
120 void MemoryBuffer::ToJson(Json::Value& target) const | 137 void MemoryBuffer::ToJson(Json::Value& target) const |
121 { | 138 { |
122 if (buffer_.data == NULL || | 139 if (buffer_.data == NULL || |
123 buffer_.size == 0) | 140 buffer_.size == 0) |
124 { | 141 { |
125 throw PluginException(OrthancPluginErrorCode_InternalError); | 142 THROW_EXCEPTION(OrthancPluginErrorCode_InternalError); |
126 } | 143 } |
127 | 144 |
128 const char* tmp = reinterpret_cast<const char*>(buffer_.data); | 145 const char* tmp = reinterpret_cast<const char*>(buffer_.data); |
129 | 146 |
130 Json::Reader reader; | 147 Json::Reader reader; |
131 if (!reader.parse(tmp, tmp + buffer_.size, target)) | 148 if (!reader.parse(tmp, tmp + buffer_.size, target)) |
132 { | 149 { |
133 OrthancPluginLogError(context_, "Cannot convert some memory buffer to JSON"); | 150 OrthancPluginLogError(context_, "Cannot convert some memory buffer to JSON"); |
134 throw PluginException(OrthancPluginErrorCode_BadFileFormat); | 151 THROW_EXCEPTION(OrthancPluginErrorCode_BadFileFormat); |
135 } | 152 } |
136 } | 153 } |
137 | 154 |
138 | 155 |
139 bool MemoryBuffer::RestApiGet(const std::string& uri, | 156 bool MemoryBuffer::RestApiGet(const std::string& uri, |
161 { | 178 { |
162 return false; | 179 return false; |
163 } | 180 } |
164 else | 181 else |
165 { | 182 { |
166 throw PluginException(error); | 183 THROW_EXCEPTION(error); |
167 } | 184 } |
168 } | 185 } |
169 | 186 |
170 | 187 |
171 bool MemoryBuffer::RestApiPost(const std::string& uri, | 188 bool MemoryBuffer::RestApiPost(const std::string& uri, |
195 { | 212 { |
196 return false; | 213 return false; |
197 } | 214 } |
198 else | 215 else |
199 { | 216 { |
200 throw PluginException(error); | 217 THROW_EXCEPTION(error); |
201 } | 218 } |
202 } | 219 } |
203 | 220 |
204 | 221 |
205 bool MemoryBuffer::RestApiPut(const std::string& uri, | 222 bool MemoryBuffer::RestApiPut(const std::string& uri, |
229 { | 246 { |
230 return false; | 247 return false; |
231 } | 248 } |
232 else | 249 else |
233 { | 250 { |
234 throw PluginException(error); | 251 THROW_EXCEPTION(error); |
235 } | 252 } |
236 } | 253 } |
237 | 254 |
238 | 255 |
239 bool MemoryBuffer::RestApiPost(const std::string& uri, | 256 bool MemoryBuffer::RestApiPost(const std::string& uri, |
307 void OrthancString::ToJson(Json::Value& target) const | 324 void OrthancString::ToJson(Json::Value& target) const |
308 { | 325 { |
309 if (str_ == NULL) | 326 if (str_ == NULL) |
310 { | 327 { |
311 OrthancPluginLogError(context_, "Cannot convert an empty memory buffer to JSON"); | 328 OrthancPluginLogError(context_, "Cannot convert an empty memory buffer to JSON"); |
312 throw PluginException(OrthancPluginErrorCode_InternalError); | 329 THROW_EXCEPTION(OrthancPluginErrorCode_InternalError); |
313 } | 330 } |
314 | 331 |
315 Json::Reader reader; | 332 Json::Reader reader; |
316 if (!reader.parse(str_, target)) | 333 if (!reader.parse(str_, target)) |
317 { | 334 { |
318 OrthancPluginLogError(context_, "Cannot convert some memory buffer to JSON"); | 335 OrthancPluginLogError(context_, "Cannot convert some memory buffer to JSON"); |
319 throw PluginException(OrthancPluginErrorCode_BadFileFormat); | 336 THROW_EXCEPTION(OrthancPluginErrorCode_BadFileFormat); |
320 } | 337 } |
321 } | 338 } |
322 | 339 |
323 | 340 |
324 OrthancConfiguration::OrthancConfiguration(OrthancPluginContext* context) : | 341 OrthancConfiguration::OrthancConfiguration(OrthancPluginContext* context) : |
327 OrthancString str(context, OrthancPluginGetConfiguration(context)); | 344 OrthancString str(context, OrthancPluginGetConfiguration(context)); |
328 | 345 |
329 if (str.GetContent() == NULL) | 346 if (str.GetContent() == NULL) |
330 { | 347 { |
331 OrthancPluginLogError(context, "Cannot access the Orthanc configuration"); | 348 OrthancPluginLogError(context, "Cannot access the Orthanc configuration"); |
332 throw PluginException(OrthancPluginErrorCode_InternalError); | 349 THROW_EXCEPTION(OrthancPluginErrorCode_InternalError); |
333 } | 350 } |
334 | 351 |
335 str.ToJson(configuration_); | 352 str.ToJson(configuration_); |
336 | 353 |
337 if (configuration_.type() != Json::objectValue) | 354 if (configuration_.type() != Json::objectValue) |
338 { | 355 { |
339 OrthancPluginLogError(context, "Unable to read the Orthanc configuration"); | 356 OrthancPluginLogError(context, "Unable to read the Orthanc configuration"); |
340 throw PluginException(OrthancPluginErrorCode_InternalError); | 357 THROW_EXCEPTION(OrthancPluginErrorCode_InternalError); |
341 } | 358 } |
342 } | 359 } |
343 | 360 |
344 | 361 |
345 OrthancPluginContext* OrthancConfiguration::GetContext() const | 362 OrthancPluginContext* OrthancConfiguration::GetContext() const |
346 { | 363 { |
347 if (context_ == NULL) | 364 if (context_ == NULL) |
348 { | 365 { |
349 throw PluginException(OrthancPluginErrorCode_Plugin); | 366 THROW_EXCEPTION(OrthancPluginErrorCode_Plugin); |
350 } | 367 } |
351 else | 368 else |
352 { | 369 { |
353 return context_; | 370 return context_; |
354 } | 371 } |
397 { | 414 { |
398 std::string s = "The configuration section \"" + target.path_ + "\" is not an associative array as expected"; | 415 std::string s = "The configuration section \"" + target.path_ + "\" is not an associative array as expected"; |
399 OrthancPluginLogError(context_, s.c_str()); | 416 OrthancPluginLogError(context_, s.c_str()); |
400 } | 417 } |
401 | 418 |
402 throw PluginException(OrthancPluginErrorCode_BadFileFormat); | 419 THROW_EXCEPTION(OrthancPluginErrorCode_BadFileFormat); |
403 } | 420 } |
404 | 421 |
405 target.configuration_ = configuration_[key]; | 422 target.configuration_ = configuration_[key]; |
406 } | 423 } |
407 } | 424 } |
423 { | 440 { |
424 std::string s = "The configuration option \"" + GetPath(key) + "\" is not a string as expected"; | 441 std::string s = "The configuration option \"" + GetPath(key) + "\" is not a string as expected"; |
425 OrthancPluginLogError(context_, s.c_str()); | 442 OrthancPluginLogError(context_, s.c_str()); |
426 } | 443 } |
427 | 444 |
428 throw PluginException(OrthancPluginErrorCode_BadFileFormat); | 445 THROW_EXCEPTION(OrthancPluginErrorCode_BadFileFormat); |
429 } | 446 } |
430 | 447 |
431 target = configuration_[key].asString(); | 448 target = configuration_[key].asString(); |
432 return true; | 449 return true; |
433 } | 450 } |
458 { | 475 { |
459 std::string s = "The configuration option \"" + GetPath(key) + "\" is not an integer as expected"; | 476 std::string s = "The configuration option \"" + GetPath(key) + "\" is not an integer as expected"; |
460 OrthancPluginLogError(context_, s.c_str()); | 477 OrthancPluginLogError(context_, s.c_str()); |
461 } | 478 } |
462 | 479 |
463 throw PluginException(OrthancPluginErrorCode_BadFileFormat); | 480 THROW_EXCEPTION(OrthancPluginErrorCode_BadFileFormat); |
464 } | 481 } |
465 } | 482 } |
466 | 483 |
467 | 484 |
468 bool OrthancConfiguration::LookupUnsignedIntegerValue(unsigned int& target, | 485 bool OrthancConfiguration::LookupUnsignedIntegerValue(unsigned int& target, |
480 { | 497 { |
481 std::string s = "The configuration option \"" + GetPath(key) + "\" is not a positive integer as expected"; | 498 std::string s = "The configuration option \"" + GetPath(key) + "\" is not a positive integer as expected"; |
482 OrthancPluginLogError(context_, s.c_str()); | 499 OrthancPluginLogError(context_, s.c_str()); |
483 } | 500 } |
484 | 501 |
485 throw PluginException(OrthancPluginErrorCode_BadFileFormat); | 502 THROW_EXCEPTION(OrthancPluginErrorCode_BadFileFormat); |
486 } | 503 } |
487 else | 504 else |
488 { | 505 { |
489 target = static_cast<unsigned int>(tmp); | 506 target = static_cast<unsigned int>(tmp); |
490 return true; | 507 return true; |
508 { | 525 { |
509 std::string s = "The configuration option \"" + GetPath(key) + "\" is not a Boolean as expected"; | 526 std::string s = "The configuration option \"" + GetPath(key) + "\" is not a Boolean as expected"; |
510 OrthancPluginLogError(context_, s.c_str()); | 527 OrthancPluginLogError(context_, s.c_str()); |
511 } | 528 } |
512 | 529 |
513 throw PluginException(OrthancPluginErrorCode_BadFileFormat); | 530 THROW_EXCEPTION(OrthancPluginErrorCode_BadFileFormat); |
514 } | 531 } |
515 | 532 |
516 target = configuration_[key].asBool(); | 533 target = configuration_[key].asBool(); |
517 return true; | 534 return true; |
518 } | 535 } |
547 { | 564 { |
548 std::string s = "The configuration option \"" + GetPath(key) + "\" is not an integer as expected"; | 565 std::string s = "The configuration option \"" + GetPath(key) + "\" is not an integer as expected"; |
549 OrthancPluginLogError(context_, s.c_str()); | 566 OrthancPluginLogError(context_, s.c_str()); |
550 } | 567 } |
551 | 568 |
552 throw PluginException(OrthancPluginErrorCode_BadFileFormat); | 569 THROW_EXCEPTION(OrthancPluginErrorCode_BadFileFormat); |
553 } | 570 } |
554 } | 571 } |
555 | 572 |
556 | 573 |
557 std::string OrthancConfiguration::GetStringValue(const std::string& key, | 574 std::string OrthancConfiguration::GetStringValue(const std::string& key, |
642 void OrthancImage::CheckImageAvailable() | 659 void OrthancImage::CheckImageAvailable() |
643 { | 660 { |
644 if (image_ == NULL) | 661 if (image_ == NULL) |
645 { | 662 { |
646 OrthancPluginLogError(context_, "Trying to access a NULL image"); | 663 OrthancPluginLogError(context_, "Trying to access a NULL image"); |
647 throw PluginException(OrthancPluginErrorCode_ParameterOutOfRange); | 664 THROW_EXCEPTION(OrthancPluginErrorCode_ParameterOutOfRange); |
648 } | 665 } |
649 } | 666 } |
650 | 667 |
651 | 668 |
652 OrthancImage::OrthancImage(OrthancPluginContext* context) : | 669 OrthancImage::OrthancImage(OrthancPluginContext* context) : |
653 context_(context), | 670 context_(context), |
654 image_(NULL) | 671 image_(NULL) |
655 { | 672 { |
656 if (context == NULL) | 673 if (context == NULL) |
657 { | 674 { |
658 throw PluginException(OrthancPluginErrorCode_ParameterOutOfRange); | 675 THROW_EXCEPTION(OrthancPluginErrorCode_ParameterOutOfRange); |
659 } | 676 } |
660 } | 677 } |
661 | 678 |
662 | 679 |
663 OrthancImage::OrthancImage(OrthancPluginContext* context, | 680 OrthancImage::OrthancImage(OrthancPluginContext* context, |
665 context_(context), | 682 context_(context), |
666 image_(image) | 683 image_(image) |
667 { | 684 { |
668 if (context == NULL) | 685 if (context == NULL) |
669 { | 686 { |
670 throw PluginException(OrthancPluginErrorCode_ParameterOutOfRange); | 687 THROW_EXCEPTION(OrthancPluginErrorCode_ParameterOutOfRange); |
671 } | 688 } |
672 } | 689 } |
673 | 690 |
674 | 691 |
675 OrthancImage::OrthancImage(OrthancPluginContext* context, | 692 OrthancImage::OrthancImage(OrthancPluginContext* context, |
678 uint32_t height) : | 695 uint32_t height) : |
679 context_(context) | 696 context_(context) |
680 { | 697 { |
681 if (context == NULL) | 698 if (context == NULL) |
682 { | 699 { |
683 throw PluginException(OrthancPluginErrorCode_ParameterOutOfRange); | 700 THROW_EXCEPTION(OrthancPluginErrorCode_ParameterOutOfRange); |
684 } | 701 } |
685 else | 702 else |
686 { | 703 { |
687 image_ = OrthancPluginCreateImage(context, format, width, height); | 704 image_ = OrthancPluginCreateImage(context, format, width, height); |
688 } | 705 } |
695 Clear(); | 712 Clear(); |
696 image_ = OrthancPluginUncompressImage(context_, data, size, OrthancPluginImageFormat_Png); | 713 image_ = OrthancPluginUncompressImage(context_, data, size, OrthancPluginImageFormat_Png); |
697 if (image_ == NULL) | 714 if (image_ == NULL) |
698 { | 715 { |
699 OrthancPluginLogError(context_, "Cannot uncompress a PNG image"); | 716 OrthancPluginLogError(context_, "Cannot uncompress a PNG image"); |
700 throw PluginException(OrthancPluginErrorCode_ParameterOutOfRange); | 717 THROW_EXCEPTION(OrthancPluginErrorCode_ParameterOutOfRange); |
701 } | 718 } |
702 } | 719 } |
703 | 720 |
704 | 721 |
705 void OrthancImage::UncompressJpegImage(const void* data, | 722 void OrthancImage::UncompressJpegImage(const void* data, |
708 Clear(); | 725 Clear(); |
709 image_ = OrthancPluginUncompressImage(context_, data, size, OrthancPluginImageFormat_Jpeg); | 726 image_ = OrthancPluginUncompressImage(context_, data, size, OrthancPluginImageFormat_Jpeg); |
710 if (image_ == NULL) | 727 if (image_ == NULL) |
711 { | 728 { |
712 OrthancPluginLogError(context_, "Cannot uncompress a JPEG image"); | 729 OrthancPluginLogError(context_, "Cannot uncompress a JPEG image"); |
713 throw PluginException(OrthancPluginErrorCode_ParameterOutOfRange); | 730 THROW_EXCEPTION(OrthancPluginErrorCode_ParameterOutOfRange); |
714 } | 731 } |
715 } | 732 } |
716 | 733 |
717 | 734 |
718 void OrthancImage::DecodeDicomImage(const void* data, | 735 void OrthancImage::DecodeDicomImage(const void* data, |
722 Clear(); | 739 Clear(); |
723 image_ = OrthancPluginDecodeDicomImage(context_, data, size, frame); | 740 image_ = OrthancPluginDecodeDicomImage(context_, data, size, frame); |
724 if (image_ == NULL) | 741 if (image_ == NULL) |
725 { | 742 { |
726 OrthancPluginLogError(context_, "Cannot uncompress a DICOM image"); | 743 OrthancPluginLogError(context_, "Cannot uncompress a DICOM image"); |
727 throw PluginException(OrthancPluginErrorCode_ParameterOutOfRange); | 744 THROW_EXCEPTION(OrthancPluginErrorCode_ParameterOutOfRange); |
728 } | 745 } |
729 } | 746 } |
730 | 747 |
731 | 748 |
732 OrthancPluginPixelFormat OrthancImage::GetPixelFormat() | 749 OrthancPluginPixelFormat OrthancImage::GetPixelFormat() |
910 { | 927 { |
911 return false; | 928 return false; |
912 } | 929 } |
913 else | 930 else |
914 { | 931 { |
915 throw PluginException(error); | 932 THROW_EXCEPTION(error); |
916 } | 933 } |
917 } | 934 } |
918 | 935 |
919 | 936 |
920 static void ReportIncompatibleVersion(OrthancPluginContext* context, | 937 static void ReportIncompatibleVersion(OrthancPluginContext* context, |