Mercurial > hg > orthanc

comparison Plugins/Samples/Common/OrthancPluginCppWrapper.h @ 2958:bb7a66efbeb1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
author Sebastien Jodogne <s.jodogne@gmail.com>
date Tue, 04 Dec 2018 16:31:29 +0100
parents 859e880ac9a8
children 7364415851ac
comparison
equal deleted inserted replaced
2957:ccf61f6e22ef 2958:bb7a66efbeb1
77 { 77 {
78 typedef void (*RestCallback) (OrthancPluginRestOutput* output, 78 typedef void (*RestCallback) (OrthancPluginRestOutput* output,
79 const char* url, 79 const char* url,
80 const OrthancPluginHttpRequest* request); 80 const OrthancPluginHttpRequest* request);
81 81
82
83 void SetGlobalContext(OrthancPluginContext* context);
84
85 bool HasGlobalContext();
86
87 OrthancPluginContext* GetGlobalContext();
88
89
82 class OrthancImage; 90 class OrthancImage;
83 91
84 92
85 class MemoryBuffer : public boost::noncopyable 93 class MemoryBuffer : public boost::noncopyable
86 { 94 {
87 private: 95 private:
88 OrthancPluginContext* context_;
89 OrthancPluginMemoryBuffer buffer_; 96 OrthancPluginMemoryBuffer buffer_;
90 97
91 void Check(OrthancPluginErrorCode code); 98 void Check(OrthancPluginErrorCode code);
92 99
93 bool CheckHttp(OrthancPluginErrorCode code); 100 bool CheckHttp(OrthancPluginErrorCode code);
94 101
95 public: 102 public:
96 MemoryBuffer(OrthancPluginContext* context); 103 MemoryBuffer();
97 104
98 ~MemoryBuffer() 105 ~MemoryBuffer()
99 { 106 {
100 Clear(); 107 Clear();
101 } 108 }
203 210
204 211
205 class OrthancString : public boost::noncopyable 212 class OrthancString : public boost::noncopyable
206 { 213 {
207 private: 214 private:
208 OrthancPluginContext* context_; 215 char* str_;
209 char* str_;
210 216
211 void Clear(); 217 void Clear();
212 218
213 public: 219 public:
214 OrthancString(OrthancPluginContext* context) : 220 OrthancString() :
215 context_(context),
216 str_(NULL) 221 str_(NULL)
217 { 222 {
218 } 223 }
219 224
220 ~OrthancString() 225 ~OrthancString()
238 243
239 244
240 class OrthancConfiguration : public boost::noncopyable 245 class OrthancConfiguration : public boost::noncopyable
241 { 246 {
242 private: 247 private:
243 OrthancPluginContext* context_; 248 Json::Value configuration_; // Necessarily a Json::objectValue
244 Json::Value configuration_; // Necessarily a Json::objectValue 249 std::string path_;
245 std::string path_;
246 250
247 std::string GetPath(const std::string& key) const; 251 std::string GetPath(const std::string& key) const;
248 252
249 public: 253 public:
250 OrthancConfiguration() : context_(NULL) 254 OrthancConfiguration();
251 {
252 }
253
254 OrthancConfiguration(OrthancPluginContext* context);
255
256 OrthancPluginContext* GetContext() const;
257 255
258 const Json::Value& GetJson() const 256 const Json::Value& GetJson() const
259 { 257 {
260 return configuration_; 258 return configuration_;
261 } 259 }
308 }; 306 };
309 307
310 class OrthancImage : public boost::noncopyable 308 class OrthancImage : public boost::noncopyable
311 { 309 {
312 private: 310 private:
313 OrthancPluginContext* context_;
314 OrthancPluginImage* image_; 311 OrthancPluginImage* image_;
315 312
316 void Clear(); 313 void Clear();
317 314
318 void CheckImageAvailable(); 315 void CheckImageAvailable();
319 316
320 public: 317 public:
321 OrthancImage(OrthancPluginContext* context); 318 OrthancImage();
322 319
323 OrthancImage(OrthancPluginContext* context, 320 OrthancImage(OrthancPluginImage* image);
324 OrthancPluginImage* image); 321
325 322 OrthancImage(OrthancPluginPixelFormat format,
326 OrthancImage(OrthancPluginContext* context,
327 OrthancPluginPixelFormat format,
328 uint32_t width, 323 uint32_t width,
329 uint32_t height); 324 uint32_t height);
330 325
331 OrthancImage(OrthancPluginContext* context, 326 OrthancImage(OrthancPluginPixelFormat format,
332 OrthancPluginPixelFormat format,
333 uint32_t width, 327 uint32_t width,
334 uint32_t height, 328 uint32_t height,
335 uint32_t pitch, 329 uint32_t pitch,
336 void* buffer 330 void* buffer
337 ); 331 );
380 374
381 #if HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 375 #if HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1
382 class FindMatcher : public boost::noncopyable 376 class FindMatcher : public boost::noncopyable
383 { 377 {
384 private: 378 private:
385 OrthancPluginContext* context_;
386 OrthancPluginFindMatcher* matcher_; 379 OrthancPluginFindMatcher* matcher_;
387 const OrthancPluginWorklistQuery* worklist_; 380 const OrthancPluginWorklistQuery* worklist_;
388 381
389 void SetupDicom(OrthancPluginContext* context, 382 void SetupDicom(const void* query,
390 const void* query,
391 uint32_t size); 383 uint32_t size);
392 384
393 public: 385 public:
394 FindMatcher(OrthancPluginContext* context, 386 FindMatcher(const OrthancPluginWorklistQuery* worklist);
395 const OrthancPluginWorklistQuery* worklist); 387
396 388 FindMatcher(const void* query,
397 FindMatcher(OrthancPluginContext* context,
398 const void* query,
399 uint32_t size) 389 uint32_t size)
400 { 390 {
401 SetupDicom(context, query, size); 391 SetupDicom(query, size);
402 } 392 }
403 393
404 FindMatcher(OrthancPluginContext* context, 394 FindMatcher(const MemoryBuffer& dicom)
405 const MemoryBuffer& dicom) 395 {
406 { 396 SetupDicom(dicom.GetData(), dicom.GetSize());
407 SetupDicom(context, dicom.GetData(), dicom.GetSize());
408 } 397 }
409 398
410 ~FindMatcher(); 399 ~FindMatcher();
411 400
412 bool IsMatch(const void* dicom, 401 bool IsMatch(const void* dicom,
419 }; 408 };
420 #endif 409 #endif
421 410
422 411
423 bool RestApiGet(Json::Value& result, 412 bool RestApiGet(Json::Value& result,
424 OrthancPluginContext* context,
425 const std::string& uri, 413 const std::string& uri,
426 bool applyPlugins); 414 bool applyPlugins);
427 415
428 bool RestApiPost(Json::Value& result, 416 bool RestApiPost(Json::Value& result,
429 OrthancPluginContext* context,
430 const std::string& uri, 417 const std::string& uri,
431 const char* body, 418 const char* body,
432 size_t bodySize, 419 size_t bodySize,
433 bool applyPlugins); 420 bool applyPlugins);
434 421
435 bool RestApiPost(Json::Value& result, 422 bool RestApiPost(Json::Value& result,
436 OrthancPluginContext* context,
437 const std::string& uri, 423 const std::string& uri,
438 const Json::Value& body, 424 const Json::Value& body,
439 bool applyPlugins); 425 bool applyPlugins);
440 426
441 inline bool RestApiPost(Json::Value& result, 427 inline bool RestApiPost(Json::Value& result,
442 OrthancPluginContext* context,
443 const std::string& uri, 428 const std::string& uri,
444 const std::string& body, 429 const std::string& body,
445 bool applyPlugins) 430 bool applyPlugins)
446 { 431 {
447 return RestApiPost(result, context, uri, body.empty() ? NULL : body.c_str(), 432 return RestApiPost(result, uri, body.empty() ? NULL : body.c_str(),
448 body.size(), applyPlugins); 433 body.size(), applyPlugins);
449 } 434 }
450 435
451 bool RestApiPut(Json::Value& result, 436 bool RestApiPut(Json::Value& result,
452 OrthancPluginContext* context,
453 const std::string& uri, 437 const std::string& uri,
454 const char* body, 438 const char* body,
455 size_t bodySize, 439 size_t bodySize,
456 bool applyPlugins); 440 bool applyPlugins);
457 441
458 bool RestApiPut(Json::Value& result, 442 bool RestApiPut(Json::Value& result,
459 OrthancPluginContext* context,
460 const std::string& uri, 443 const std::string& uri,
461 const Json::Value& body, 444 const Json::Value& body,
462 bool applyPlugins); 445 bool applyPlugins);
463 446
464 inline bool RestApiPut(Json::Value& result, 447 inline bool RestApiPut(Json::Value& result,
465 OrthancPluginContext* context,
466 const std::string& uri, 448 const std::string& uri,
467 const std::string& body, 449 const std::string& body,
468 bool applyPlugins) 450 bool applyPlugins)
469 { 451 {
470 return RestApiPut(result, context, uri, body.empty() ? NULL : body.c_str(), 452 return RestApiPut(result, uri, body.empty() ? NULL : body.c_str(),
471 body.size(), applyPlugins); 453 body.size(), applyPlugins);
472 } 454 }
473 455
474 bool RestApiDelete(OrthancPluginContext* context, 456 bool RestApiDelete(const std::string& uri,
475 const std::string& uri,
476 bool applyPlugins); 457 bool applyPlugins);
477 458
478 bool HttpDelete(OrthancPluginContext* context, 459 bool HttpDelete(const std::string& url,
479 const std::string& url,
480 const std::string& username, 460 const std::string& username,
481 const std::string& password); 461 const std::string& password);
482 462
483 inline void LogError(OrthancPluginContext* context, 463 void LogError(const std::string& message);
484 const std::string& message) 464
485 { 465 void LogWarning(const std::string& message);
486 if (context != NULL) 466
487 { 467 void LogInfo(const std::string& message);
488 OrthancPluginLogError(context, message.c_str()); 468
489 } 469 void ReportMinimalOrthancVersion(unsigned int major,
490 }
491
492 inline void LogWarning(OrthancPluginContext* context,
493 const std::string& message)
494 {
495 if (context != NULL)
496 {
497 OrthancPluginLogWarning(context, message.c_str());
498 }
499 }
500
501 inline void LogInfo(OrthancPluginContext* context,
502 const std::string& message)
503 {
504 if (context != NULL)
505 {
506 OrthancPluginLogInfo(context, message.c_str());
507 }
508 }
509
510 void ReportMinimalOrthancVersion(OrthancPluginContext* context,
511 unsigned int major,
512 unsigned int minor, 470 unsigned int minor,
513 unsigned int revision); 471 unsigned int revision);
514 472
515 bool CheckMinimalOrthancVersion(OrthancPluginContext* context, 473 bool CheckMinimalOrthancVersion(unsigned int major,
516 unsigned int major,
517 unsigned int minor, 474 unsigned int minor,
518 unsigned int revision); 475 unsigned int revision);
519 476
520 477
521 namespace Internals 478 namespace Internals
530 Callback(output, url, request); 487 Callback(output, url, request);
531 return OrthancPluginErrorCode_Success; 488 return OrthancPluginErrorCode_Success;
532 } 489 }
533 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) 490 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e)
534 { 491 {
492 #if HAS_ORTHANC_EXCEPTION == 1
493 if (HasGlobalContext() &&
494 e.HasDetails())
495 {
496 OrthancPluginSetHttpErrorDetails(GetGlobalContext(), output, e.GetDetails());
497 }
498 #endif
499
535 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); 500 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode());
536 } 501 }
537 catch (boost::bad_lexical_cast&) 502 catch (boost::bad_lexical_cast&)
538 { 503 {
539 return OrthancPluginErrorCode_BadFileFormat; 504 return OrthancPluginErrorCode_BadFileFormat;
545 } 510 }
546 } 511 }
547 512
548 513
549 template <RestCallback Callback> 514 template <RestCallback Callback>
550 void RegisterRestCallback(OrthancPluginContext* context, 515 void RegisterRestCallback(const std::string& uri,
551 const std::string& uri,
552 bool isThreadSafe) 516 bool isThreadSafe)
553 { 517 {
554 if (isThreadSafe) 518 if (isThreadSafe)
555 { 519 {
556 OrthancPluginRegisterRestCallbackNoLock(context, uri.c_str(), Internals::Protect<Callback>); 520 OrthancPluginRegisterRestCallbackNoLock
521 (GetGlobalContext(), uri.c_str(), Internals::Protect<Callback>);
557 } 522 }
558 else 523 else
559 { 524 {
560 OrthancPluginRegisterRestCallback(context, uri.c_str(), Internals::Protect<Callback>); 525 OrthancPluginRegisterRestCallback
526 (GetGlobalContext(), uri.c_str(), Internals::Protect<Callback>);
561 } 527 }
562 } 528 }
563 529
564 530
565 #if HAS_ORTHANC_PLUGIN_PEERS == 1 531 #if HAS_ORTHANC_PLUGIN_PEERS == 1
566 class OrthancPeers : public boost::noncopyable 532 class OrthancPeers : public boost::noncopyable
567 { 533 {
568 private: 534 private:
569 typedef std::map<std::string, uint32_t> Index; 535 typedef std::map<std::string, uint32_t> Index;
570 536
571 OrthancPluginContext *context_;
572 OrthancPluginPeers *peers_; 537 OrthancPluginPeers *peers_;
573 Index index_; 538 Index index_;
574 uint32_t timeout_; 539 uint32_t timeout_;
575 540
576 size_t GetPeerIndex(const std::string& name) const; 541 size_t GetPeerIndex(const std::string& name) const;
577 542
578 public: 543 public:
579 OrthancPeers(OrthancPluginContext* context); 544 OrthancPeers();
580 545
581 ~OrthancPeers(); 546 ~OrthancPeers();
582 547
583 uint32_t GetTimeout() const 548 uint32_t GetTimeout() const
584 { 549 {
713 678
714 virtual void Stop(OrthancPluginJobStopReason reason) = 0; 679 virtual void Stop(OrthancPluginJobStopReason reason) = 0;
715 680
716 virtual void Reset() = 0; 681 virtual void Reset() = 0;
717 682
718 static OrthancPluginJob* Create(OrthancPluginContext* context, 683 static OrthancPluginJob* Create(OrthancJob* job /* takes ownership */);
719 OrthancJob* job /* takes ownership */); 684
720 685 static std::string Submit(OrthancJob* job /* takes ownership */,
721 static std::string Submit(OrthancPluginContext* context,
722 OrthancJob* job /* takes ownership */,
723 int priority); 686 int priority);
724 }; 687 };
725 #endif 688 #endif
726 } 689 }