orthanc: Plugins/Samples/Common/OrthancPluginCppWrapper.cpp comparison

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

OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 04 Dec 2018 16:31:29 +0100
parents	859e880ac9a8
children	e361df74639f

comparison

equal deleted inserted replaced

-:ccf61f6e22ef
+:bb7a66efbeb1
 #include <json/writer.h>
 namespace OrthancPlugins
 {
+static OrthancPluginContext* globalContext_ = NULL;
+void SetGlobalContext(OrthancPluginContext* context)
+{
+if (context == NULL)
+{
+ORTHANC_PLUGINS_THROW_EXCEPTION(NullPointer);
+}
+else if (globalContext_ == NULL)
+{
+globalContext_ = context;
+}
+else
+{
+ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls);
+}
+}
+bool HasGlobalContext()
+{
+return globalContext_ != NULL;
+}
+OrthancPluginContext* GetGlobalContext()
+{
+if (globalContext_ == NULL)
+{
+ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls);
+}
+else
+{
+return globalContext_;
+}
+}
 void MemoryBuffer::Check(OrthancPluginErrorCode code)
 {
 if (code != OrthancPluginErrorCode_Success)
 {
 // Prevent using garbage information
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code);
 }
 }
-MemoryBuffer::MemoryBuffer(OrthancPluginContext* context) :
+MemoryBuffer::MemoryBuffer()
-context_(context)
 {
 buffer_.data = NULL;
 buffer_.size = 0;
 }
 void MemoryBuffer::Clear()
 {
 if (buffer_.data != NULL)
 {
-OrthancPluginFreeMemoryBuffer(context_, &buffer_);
+OrthancPluginFreeMemoryBuffer(GetGlobalContext(), &buffer_);
 buffer_.data = NULL;
 buffer_.size = 0;
 }
 }
 const char* tmp = reinterpret_cast<const char*>(buffer_.data);
 Json::Reader reader;
 if (!reader.parse(tmp, tmp + buffer_.size, target))
 {
-OrthancPluginLogError(context_, "Cannot convert some memory buffer to JSON");
+LogError("Cannot convert some memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 {
 Clear();
 if (applyPlugins)
 {
-return CheckHttp(OrthancPluginRestApiGetAfterPlugins(context_, &buffer_, uri.c_str()));
+return CheckHttp(OrthancPluginRestApiGetAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str()));
 }
 else
 {
-return CheckHttp(OrthancPluginRestApiGet(context_, &buffer_, uri.c_str()));
+return CheckHttp(OrthancPluginRestApiGet(GetGlobalContext(), &buffer_, uri.c_str()));
 }
 }
 bool MemoryBuffer::RestApiPost(const std::string& uri,
 {
 Clear();
 if (applyPlugins)
 {
-return CheckHttp(OrthancPluginRestApiPostAfterPlugins(context_, &buffer_, uri.c_str(), body, bodySize));
+return CheckHttp(OrthancPluginRestApiPostAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str(), body, bodySize));
 }
 else
 {
-return CheckHttp(OrthancPluginRestApiPost(context_, &buffer_, uri.c_str(), body, bodySize));
+return CheckHttp(OrthancPluginRestApiPost(GetGlobalContext(), &buffer_, uri.c_str(), body, bodySize));
 }
 }
 bool MemoryBuffer::RestApiPut(const std::string& uri,
 {
 Clear();
 if (applyPlugins)
 {
-return CheckHttp(OrthancPluginRestApiPutAfterPlugins(context_, &buffer_, uri.c_str(), body, bodySize));
+return CheckHttp(OrthancPluginRestApiPutAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str(), body, bodySize));
 }
 else
 {
-return CheckHttp(OrthancPluginRestApiPut(context_, &buffer_, uri.c_str(), body, bodySize));
+return CheckHttp(OrthancPluginRestApiPut(GetGlobalContext(), &buffer_, uri.c_str(), body, bodySize));
 }
 }
 bool MemoryBuffer::RestApiPost(const std::string& uri,
 Clear();
 Json::FastWriter writer;
 std::string s = writer.write(tags);
-Check(OrthancPluginCreateDicom(context_, &buffer_, s.c_str(), NULL, flags));
+Check(OrthancPluginCreateDicom(GetGlobalContext(), &buffer_, s.c_str(), NULL, flags));
 }
 void MemoryBuffer::CreateDicom(const Json::Value& tags,
 const OrthancImage& pixelData,
 OrthancPluginCreateDicomFlags flags)
 Clear();
 Json::FastWriter writer;
 std::string s = writer.write(tags);
-Check(OrthancPluginCreateDicom(context_, &buffer_, s.c_str(), pixelData.GetObject(), flags));
+Check(OrthancPluginCreateDicom(GetGlobalContext(), &buffer_, s.c_str(), pixelData.GetObject(), flags));
 }
 void MemoryBuffer::ReadFile(const std::string& path)
 {
 Clear();
-Check(OrthancPluginReadFile(context_, &buffer_, path.c_str()));
+Check(OrthancPluginReadFile(GetGlobalContext(), &buffer_, path.c_str()));
 }
 void MemoryBuffer::GetDicomQuery(const OrthancPluginWorklistQuery* query)
 {
 Clear();
-Check(OrthancPluginWorklistGetDicomQuery(context_, &buffer_, query));
+Check(OrthancPluginWorklistGetDicomQuery(GetGlobalContext(), &buffer_, query));
 }
 void OrthancString::Assign(char* str)
 {
 void OrthancString::Clear()
 {
 if (str_ != NULL)
 {
-OrthancPluginFreeString(context_, str_);
+OrthancPluginFreeString(GetGlobalContext(), str_);
 str_ = NULL;
 }
 }
 void OrthancString::ToJson(Json::Value& target) const
 {
 if (str_ == NULL)
 {
-OrthancPluginLogError(context_, "Cannot convert an empty memory buffer to JSON");
+LogError("Cannot convert an empty memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 Json::Reader reader;
 if (!reader.parse(str_, target))
 {
-OrthancPluginLogError(context_, "Cannot convert some memory buffer to JSON");
+LogError("Cannot convert some memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 void MemoryBuffer::DicomToJson(Json::Value& target,
 OrthancPluginDicomToJsonFormat format,
 OrthancPluginDicomToJsonFlags flags,
 uint32_t maxStringLength)
 {
-OrthancString str(context_);
+OrthancString str;
-str.Assign(OrthancPluginDicomBufferToJson(context_, GetData(), GetSize(), format, flags, maxStringLength));
+str.Assign(OrthancPluginDicomBufferToJson
+(GetGlobalContext(), GetData(), GetSize(), format, flags, maxStringLength));
 str.ToJson(target);
 }
 bool MemoryBuffer::HttpGet(const std::string& url,
 const std::string& username,
 const std::string& password)
 {
 Clear();
-return CheckHttp(OrthancPluginHttpGet(context_, &buffer_, url.c_str(),
+return CheckHttp(OrthancPluginHttpGet(GetGlobalContext(), &buffer_, url.c_str(),
 username.empty() ? NULL : username.c_str(),
 password.empty() ? NULL : password.c_str()));
 }
 const std::string& body,
 const std::string& username,
 const std::string& password)
 {
 Clear();
-return CheckHttp(OrthancPluginHttpPost(context_, &buffer_, url.c_str(),
+return CheckHttp(OrthancPluginHttpPost(GetGlobalContext(), &buffer_, url.c_str(),
 body.c_str(), body.size(),
 username.empty() ? NULL : username.c_str(),
 password.empty() ? NULL : password.c_str()));
 }
 const std::string& body,
 const std::string& username,
 const std::string& password)
 {
 Clear();
-return CheckHttp(OrthancPluginHttpPut(context_, &buffer_, url.c_str(),
+return CheckHttp(OrthancPluginHttpPut(GetGlobalContext(), &buffer_, url.c_str(),
 body.empty() ? NULL : body.c_str(),
 body.size(),
 username.empty() ? NULL : username.c_str(),
 password.empty() ? NULL : password.c_str()));
 }
 void MemoryBuffer::GetDicomInstance(const std::string& instanceId)
 {
 Clear();
-Check(OrthancPluginGetDicomForInstance(context_, &buffer_, instanceId.c_str()));
+Check(OrthancPluginGetDicomForInstance(GetGlobalContext(), &buffer_, instanceId.c_str()));
 }
-bool HttpDelete(OrthancPluginContext* context_,
+bool HttpDelete(const std::string& url,
-const std::string& url,
 const std::string& username,
 const std::string& password)
 {
 OrthancPluginErrorCode error = OrthancPluginHttpDelete
-(context_, url.c_str(),
+(GetGlobalContext(), url.c_str(),
 username.empty() ? NULL : username.c_str(),
 password.empty() ? NULL : password.c_str());
 if (error == OrthancPluginErrorCode_Success)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error);
 }
 }
-OrthancConfiguration::OrthancConfiguration(OrthancPluginContext* context) :
+void LogError(const std::string& message)
-context_(context)
+{
-{
+if (HasGlobalContext())
-OrthancString str(context);
+{
-str.Assign(OrthancPluginGetConfiguration(context));
+OrthancPluginLogError(GetGlobalContext(), message.c_str());
+}
+}
+void LogWarning(const std::string& message)
+{
+if (HasGlobalContext())
+{
+OrthancPluginLogWarning(GetGlobalContext(), message.c_str());
+}
+}
+void LogInfo(const std::string& message)
+{
+if (HasGlobalContext())
+{
+OrthancPluginLogInfo(GetGlobalContext(), message.c_str());
+}
+}
+OrthancConfiguration::OrthancConfiguration()
+{
+OrthancString str;
+str.Assign(OrthancPluginGetConfiguration(GetGlobalContext()));
 if (str.GetContent() == NULL)
 {
-OrthancPluginLogError(context, "Cannot access the Orthanc configuration");
+LogError("Cannot access the Orthanc configuration");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 str.ToJson(configuration_);
 if (configuration_.type() != Json::objectValue)
 {
-OrthancPluginLogError(context, "Unable to read the Orthanc configuration");
+LogError("Unable to read the Orthanc configuration");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
-}
-}
-OrthancPluginContext* OrthancConfiguration::GetContext() const
-{
-if (context_ == NULL)
-{
-ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin);
-}
-else
-{
-return context_;
 }
 }
 std::string OrthancConfiguration::GetPath(const std::string& key) const
 void OrthancConfiguration::GetSection(OrthancConfiguration& target,
 const std::string& key) const
 {
 assert(configuration_.type() == Json::objectValue);
-target.context_ = context_;
 target.path_ = GetPath(key);
 if (!configuration_.isMember(key))
 {
 target.configuration_ = Json::objectValue;
 }
 else
 {
 if (configuration_[key].type() != Json::objectValue)
 {
-if (context_ != NULL)
+LogError("The configuration section \"" + target.path_ +
-{
+"\" is not an associative array as expected");
-std::string s = "The configuration section \"" + target.path_ + "\" is not an associative array as expected";
-OrthancPluginLogError(context_, s.c_str());
-}
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 target.configuration_ = configuration_[key];
 return false;
 }
 if (configuration_[key].type() != Json::stringValue)
 {
-if (context_ != NULL)
+LogError("The configuration option \"" + GetPath(key) +
-{
+"\" is not a string as expected");
-std::string s = "The configuration option \"" + GetPath(key) + "\" is not a string as expected";
-OrthancPluginLogError(context_, s.c_str());
-}
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 target = configuration_[key].asString();
 case Json::uintValue:
 target = configuration_[key].asUInt();
 return true;
 default:
-if (context_ != NULL)
+LogError("The configuration option \"" + GetPath(key) +
-{
+"\" is not an integer as expected");
-std::string s = "The configuration option \"" + GetPath(key) + "\" is not an integer as expected";
-OrthancPluginLogError(context_, s.c_str());
-}
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 return false;
 }
 if (tmp < 0)
 {
-if (context_ != NULL)
+LogError("The configuration option \"" + GetPath(key) +
-{
+"\" is not a positive integer as expected");
-std::string s = "The configuration option \"" + GetPath(key) + "\" is not a positive integer as expected";
-OrthancPluginLogError(context_, s.c_str());
-}
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 else
 {
 return false;
 }
 if (configuration_[key].type() != Json::booleanValue)
 {
-if (context_ != NULL)
+LogError("The configuration option \"" + GetPath(key) +
-{
+"\" is not a Boolean as expected");
-std::string s = "The configuration option \"" + GetPath(key) + "\" is not a Boolean as expected";
-OrthancPluginLogError(context_, s.c_str());
-}
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 target = configuration_[key].asBool();
 case Json::uintValue:
 target = static_cast<float>(configuration_[key].asUInt());
 return true;
 default:
-if (context_ != NULL)
+LogError("The configuration option \"" + GetPath(key) +
-{
+"\" is not an integer as expected");
-std::string s = "The configuration option \"" + GetPath(key) + "\" is not an integer as expected";
-OrthancPluginLogError(context_, s.c_str());
-}
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 default:
 break;
 }
-if (context_ != NULL)
+LogError("The configuration option \"" + GetPath(key) +
-{
+"\" is not a list of strings as expected");
-std::string s = ("The configuration option \"" + GetPath(key) +
-"\" is not a list of strings as expected");
-OrthancPluginLogError(context_, s.c_str());
-}
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 return;
 }
 if (configuration_[key].type() != Json::objectValue)
 {
-if (context_ != NULL)
+LogError("The configuration option \"" + GetPath(key) +
-{
+"\" is not a string as expected");
-std::string s = "The configuration option \"" + GetPath(key) + "\" is not a string as expected";
-OrthancPluginLogError(context_, s.c_str());
-}
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 Json::Value::Members members = configuration_[key].getMemberNames();
 {
 target[members[i]] = value.asString();
 }
 else
 {
-if (context_ != NULL)
+LogError("The configuration option \"" + GetPath(key) +
-{
+"\" is not a dictionary mapping strings to strings");
-std::string s = "The configuration option \"" + GetPath(key) + "\" is not a dictionary mapping strings to strings";
-OrthancPluginLogError(context_, s.c_str());
-}
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 }
 void OrthancImage::Clear()
 {
 if (image_ != NULL)
 {
-OrthancPluginFreeImage(context_, image_);
+OrthancPluginFreeImage(GetGlobalContext(), image_);
 image_ = NULL;
 }
 }
 void OrthancImage::CheckImageAvailable()
 {
 if (image_ == NULL)
 {
-OrthancPluginLogError(context_, "Trying to access a NULL image");
+LogError("Trying to access a NULL image");
 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
 }
 }
-OrthancImage::OrthancImage(OrthancPluginContext*  context) :
+OrthancImage::OrthancImage() :
-context_(context),
 image_(NULL)
 {
-if (context == NULL)
+}
-{
-ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
-}
+OrthancImage::OrthancImage(OrthancPluginImage*  image) :
-}
-OrthancImage::OrthancImage(OrthancPluginContext*  context,
-OrthancPluginImage*    image) :
-context_(context),
 image_(image)
 {
-if (context == NULL)
+}
-{
-ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
-}
+OrthancImage::OrthancImage(OrthancPluginPixelFormat  format,
-}
-OrthancImage::OrthancImage(OrthancPluginContext*     context,
-OrthancPluginPixelFormat  format,
 uint32_t                  width,
-uint32_t                  height) :
+uint32_t                  height)
-context_(context)
+{
-{
+image_ = OrthancPluginCreateImage(GetGlobalContext(), format, width, height);
-if (context == NULL)
-{
+if (image_ == NULL)
-ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
+{
-}
+LogError("Cannot create an image");
-else
+ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
-{
+}
-image_ = OrthancPluginCreateImage(context, format, width, height);
+}
-}
-}
+OrthancImage::OrthancImage(OrthancPluginPixelFormat  format,
-OrthancImage::OrthancImage(OrthancPluginContext*     context,
-OrthancPluginPixelFormat  format,
 uint32_t                  width,
 uint32_t                  height,
 uint32_t                  pitch,
-void*                     buffer) :
+void*                     buffer)
-context_(context)
+{
-{
+image_ = OrthancPluginCreateImageAccessor
-if (context == NULL)
+(GetGlobalContext(), format, width, height, pitch, buffer);
-{
-ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
+if (image_ == NULL)
-}
+{
-else
+LogError("Cannot create an image accessor");
-{
+ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
-image_ = OrthancPluginCreateImageAccessor(context, format, width, height, pitch, buffer);
 }
 }
 void OrthancImage::UncompressPngImage(const void* data,
 size_t size)
 {
 Clear();
-image_ = OrthancPluginUncompressImage(context_, data, size, OrthancPluginImageFormat_Png);
+image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Png);
 if (image_ == NULL)
 {
-OrthancPluginLogError(context_, "Cannot uncompress a PNG image");
+LogError("Cannot uncompress a PNG image");
 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
 }
 }
 void OrthancImage::UncompressJpegImage(const void* data,
 size_t size)
 {
 Clear();
-image_ = OrthancPluginUncompressImage(context_, data, size, OrthancPluginImageFormat_Jpeg);
+image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Jpeg);
 if (image_ == NULL)
 {
-OrthancPluginLogError(context_, "Cannot uncompress a JPEG image");
+LogError("Cannot uncompress a JPEG image");
 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
 }
 }
 void OrthancImage::DecodeDicomImage(const void* data,
 size_t size,
 unsigned int frame)
 {
 Clear();
-image_ = OrthancPluginDecodeDicomImage(context_, data, size, frame);
+image_ = OrthancPluginDecodeDicomImage(GetGlobalContext(), data, size, frame);
 if (image_ == NULL)
 {
-OrthancPluginLogError(context_, "Cannot uncompress a DICOM image");
+LogError("Cannot uncompress a DICOM image");
 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
 }
 }
 OrthancPluginPixelFormat OrthancImage::GetPixelFormat()
 {
 CheckImageAvailable();
-return OrthancPluginGetImagePixelFormat(context_, image_);
+return OrthancPluginGetImagePixelFormat(GetGlobalContext(), image_);
 }
 unsigned int OrthancImage::GetWidth()
 {
 CheckImageAvailable();
-return OrthancPluginGetImageWidth(context_, image_);
+return OrthancPluginGetImageWidth(GetGlobalContext(), image_);
 }
 unsigned int OrthancImage::GetHeight()
 {
 CheckImageAvailable();
-return OrthancPluginGetImageHeight(context_, image_);
+return OrthancPluginGetImageHeight(GetGlobalContext(), image_);
 }
 unsigned int OrthancImage::GetPitch()
 {
 CheckImageAvailable();
-return OrthancPluginGetImagePitch(context_, image_);
+return OrthancPluginGetImagePitch(GetGlobalContext(), image_);
 }
 const void* OrthancImage::GetBuffer()
 {
 CheckImageAvailable();
-return OrthancPluginGetImageBuffer(context_, image_);
+return OrthancPluginGetImageBuffer(GetGlobalContext(), image_);
 }
 void OrthancImage::CompressPngImage(MemoryBuffer& target)
 {
 CheckImageAvailable();
 OrthancPluginMemoryBuffer tmp;
-OrthancPluginCompressPngImage(context_, &tmp, GetPixelFormat(),
+OrthancPluginCompressPngImage(GetGlobalContext(), &tmp, GetPixelFormat(),
 GetWidth(), GetHeight(), GetPitch(), GetBuffer());
 target.Assign(tmp);
 }
 uint8_t quality)
 {
 CheckImageAvailable();
 OrthancPluginMemoryBuffer tmp;
-OrthancPluginCompressJpegImage(context_, &tmp, GetPixelFormat(),
+OrthancPluginCompressJpegImage(GetGlobalContext(), &tmp, GetPixelFormat(),
 GetWidth(), GetHeight(), GetPitch(), GetBuffer(), quality);
 target.Assign(tmp);
 }
 void OrthancImage::AnswerPngImage(OrthancPluginRestOutput* output)
 {
 CheckImageAvailable();
-OrthancPluginCompressAndAnswerPngImage(context_, output, GetPixelFormat(),
+OrthancPluginCompressAndAnswerPngImage(GetGlobalContext(), output, GetPixelFormat(),
 GetWidth(), GetHeight(), GetPitch(), GetBuffer());
 }
 void OrthancImage::AnswerJpegImage(OrthancPluginRestOutput* output,
 uint8_t quality)
 {
 CheckImageAvailable();
-OrthancPluginCompressAndAnswerJpegImage(context_, output, GetPixelFormat(),
+OrthancPluginCompressAndAnswerJpegImage(GetGlobalContext(), output, GetPixelFormat(),
 GetWidth(), GetHeight(), GetPitch(), GetBuffer(), quality);
 }
 #if HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1
-FindMatcher::FindMatcher(OrthancPluginContext*              context,
+FindMatcher::FindMatcher(const OrthancPluginWorklistQuery* worklist) :
-const OrthancPluginWorklistQuery*  worklist) :
-context_(context),
 matcher_(NULL),
 worklist_(worklist)
 {
 if (worklist_ == NULL)
 {
 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
 }
 }
-void FindMatcher::SetupDicom(OrthancPluginContext*  context,
+void FindMatcher::SetupDicom(const void*  query,
-const void*            query,
+uint32_t     size)
-uint32_t               size)
+{
-{
-context_ = context;
 worklist_ = NULL;
-matcher_ = OrthancPluginCreateFindMatcher(context_, query, size);
+matcher_ = OrthancPluginCreateFindMatcher(GetGlobalContext(), query, size);
 if (matcher_ == NULL)
 {
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 }
 {
 // The "worklist_" field
 if (matcher_ != NULL)
 {
-OrthancPluginFreeFindMatcher(context_, matcher_);
+OrthancPluginFreeFindMatcher(GetGlobalContext(), matcher_);
 }
 }
 {
 int32_t result;
 if (matcher_ != NULL)
 {
-result = OrthancPluginFindMatcherIsMatch(context_, matcher_, dicom, size);
+result = OrthancPluginFindMatcherIsMatch(GetGlobalContext(), matcher_, dicom, size);
 }
 else if (worklist_ != NULL)
 {
-result = OrthancPluginWorklistIsMatch(context_, worklist_, dicom, size);
+result = OrthancPluginWorklistIsMatch(GetGlobalContext(), worklist_, dicom, size);
 }
 else
 {
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 #endif /* HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 */
 bool RestApiGet(Json::Value& result,
-OrthancPluginContext* context,
 const std::string& uri,
 bool applyPlugins)
 {
-MemoryBuffer answer(context);
+MemoryBuffer answer;
 if (!answer.RestApiGet(uri, applyPlugins))
 {
 return false;
 }
 else
 }
 }
 bool RestApiPost(Json::Value& result,
-OrthancPluginContext* context,
 const std::string& uri,
 const char* body,
 size_t bodySize,
 bool applyPlugins)
 {
-MemoryBuffer answer(context);
+MemoryBuffer answer;
 if (!answer.RestApiPost(uri, body, bodySize, applyPlugins))
 {
 return false;
 }
 else
 }
 }
 bool RestApiPost(Json::Value& result,
-OrthancPluginContext* context,
 const std::string& uri,
 const Json::Value& body,
 bool applyPlugins)
 {
 Json::FastWriter writer;
-return RestApiPost(result, context, uri, writer.write(body), applyPlugins);
+return RestApiPost(result, uri, writer.write(body), applyPlugins);
 }
 bool RestApiPut(Json::Value& result,
-OrthancPluginContext* context,
 const std::string& uri,
 const char* body,
 size_t bodySize,
 bool applyPlugins)
 {
-MemoryBuffer answer(context);
+MemoryBuffer answer;
 if (!answer.RestApiPut(uri, body, bodySize, applyPlugins))
 {
 return false;
 }
 else
 }
 }
 bool RestApiPut(Json::Value& result,
-OrthancPluginContext* context,
 const std::string& uri,
 const Json::Value& body,
 bool applyPlugins)
 {
 Json::FastWriter writer;
-return RestApiPut(result, context, uri, writer.write(body), applyPlugins);
+return RestApiPut(result, uri, writer.write(body), applyPlugins);
 }
-bool RestApiDelete(OrthancPluginContext* context,
+bool RestApiDelete(const std::string& uri,
-const std::string& uri,
 bool applyPlugins)
 {
 OrthancPluginErrorCode error;
 if (applyPlugins)
 {
-error = OrthancPluginRestApiDeleteAfterPlugins(context, uri.c_str());
+error = OrthancPluginRestApiDeleteAfterPlugins(GetGlobalContext(), uri.c_str());
 }
 else
 {
-error = OrthancPluginRestApiDelete(context, uri.c_str());
+error = OrthancPluginRestApiDelete(GetGlobalContext(), uri.c_str());
 }
 if (error == OrthancPluginErrorCode_Success)
 {
 return true;
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error);
 }
 }
-void ReportMinimalOrthancVersion(OrthancPluginContext* context,
+void ReportMinimalOrthancVersion(unsigned int major,
-unsigned int major,
 unsigned int minor,
 unsigned int revision)
 {
-std::string s = ("Your version of the Orthanc core (" +
+LogError("Your version of the Orthanc core (" +
-std::string(context->orthancVersion) +
+std::string(GetGlobalContext()->orthancVersion) +
 ") is too old to run this plugin (version " +
 boost::lexical_cast<std::string>(major) + "." +
 boost::lexical_cast<std::string>(minor) + "." +
 boost::lexical_cast<std::string>(revision) +
 " is required)");
+}
-OrthancPluginLogError(context, s.c_str());
-}
+bool CheckMinimalOrthancVersion(unsigned int major,
-bool CheckMinimalOrthancVersion(OrthancPluginContext* context,
-unsigned int major,
 unsigned int minor,
 unsigned int revision)
 {
-if (context == NULL)
+if (!HasGlobalContext())
 {
-OrthancPluginLogError(context, "Bad Orthanc context in the plugin");
+LogError("Bad Orthanc context in the plugin");
 return false;
 }
-if (!strcmp(context->orthancVersion, "mainline"))
+if (!strcmp(GetGlobalContext()->orthancVersion, "mainline"))
 {
 // Assume compatibility with the mainline
 return true;
 }
 #ifdef _MSC_VER
 sscanf_s
 #else
 sscanf
 #endif
-(context->orthancVersion, "%4d.%4d.%4d", &aa, &bb, &cc) != 3 ||
+(GetGlobalContext()->orthancVersion, "%4d.%4d.%4d", &aa, &bb, &cc) != 3 ||
 aa < 0 ||
 bb < 0 ||
 cc < 0)
 {
 return false;
 {
 return index;
 }
 else
 {
-std::string s = "Inexistent peer: " + name;
+LogError("Inexistent peer: " + name);
-OrthancPluginLogError(context_, s.c_str());
 ORTHANC_PLUGINS_THROW_EXCEPTION(UnknownResource);
 }
 }
-OrthancPeers::OrthancPeers(OrthancPluginContext* context) :
+OrthancPeers::OrthancPeers() :
-context_(context),
 peers_(NULL),
 timeout_(0)
 {
-if (context_ == NULL)
+peers_ = OrthancPluginGetPeers(GetGlobalContext());
-{
-ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer);
-}
-peers_ = OrthancPluginGetPeers(context_);
 if (peers_ == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }
-uint32_t count = OrthancPluginGetPeersCount(context_, peers_);
+uint32_t count = OrthancPluginGetPeersCount(GetGlobalContext(), peers_);
 for (uint32_t i = 0; i < count; i++)
 {
-const char* name = OrthancPluginGetPeerName(context_, peers_, i);
+const char* name = OrthancPluginGetPeerName(GetGlobalContext(), peers_, i);
 if (name == NULL)
 {
-OrthancPluginFreePeers(context_, peers_);
+OrthancPluginFreePeers(GetGlobalContext(), peers_);
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }
 index_[name] = i;
 }
 OrthancPeers::~OrthancPeers()
 {
 if (peers_ != NULL)
 {
-OrthancPluginFreePeers(context_, peers_);
+OrthancPluginFreePeers(GetGlobalContext(), peers_);
 }
 }
 bool OrthancPeers::LookupName(size_t& target,
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
 }
 else
 {
-const char* s = OrthancPluginGetPeerName(context_, peers_, static_cast<uint32_t>(index));
+const char* s = OrthancPluginGetPeerName(GetGlobalContext(), peers_, static_cast<uint32_t>(index));
 if (s == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }
 else
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
 }
 else
 {
-const char* s = OrthancPluginGetPeerUrl(context_, peers_, static_cast<uint32_t>(index));
+const char* s = OrthancPluginGetPeerUrl(GetGlobalContext(), peers_, static_cast<uint32_t>(index));
 if (s == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }
 else
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
 }
 else
 {
-const char* s = OrthancPluginGetPeerUserProperty(context_, peers_, static_cast<uint32_t>(index), key.c_str());
+const char* s = OrthancPluginGetPeerUserProperty(GetGlobalContext(), peers_, static_cast<uint32_t>(index), key.c_str());
 if (s == NULL)
 {
 return false;
 }
 else
 }
 OrthancPluginMemoryBuffer answer;
 uint16_t status;
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
-(context_, &answer, NULL, &status, peers_,
+(GetGlobalContext(), &answer, NULL, &status, peers_,
 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Get, uri.c_str(),
 0, NULL, NULL, NULL, 0, timeout_);
 if (code == OrthancPluginErrorCode_Success)
 {
 bool OrthancPeers::DoGet(Json::Value& target,
 size_t index,
 const std::string& uri) const
 {
-MemoryBuffer buffer(context_);
+MemoryBuffer buffer;
 if (DoGet(buffer, index, uri))
 {
 buffer.ToJson(target);
 return true;
 bool OrthancPeers::DoGet(Json::Value& target,
 const std::string& name,
 const std::string& uri) const
 {
-MemoryBuffer buffer(context_);
+MemoryBuffer buffer;
 if (DoGet(buffer, name, uri))
 {
 buffer.ToJson(target);
 return true;
 bool OrthancPeers::DoPost(Json::Value& target,
 size_t index,
 const std::string& uri,
 const std::string& body) const
 {
-MemoryBuffer buffer(context_);
+MemoryBuffer buffer;
 if (DoPost(buffer, index, uri, body))
 {
 buffer.ToJson(target);
 return true;
 bool OrthancPeers::DoPost(Json::Value& target,
 const std::string& name,
 const std::string& uri,
 const std::string& body) const
 {
-MemoryBuffer buffer(context_);
+MemoryBuffer buffer;
 if (DoPost(buffer, name, uri, body))
 {
 buffer.ToJson(target);
 return true;
 }
 OrthancPluginMemoryBuffer answer;
 uint16_t status;
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
-(context_, &answer, NULL, &status, peers_,
+(GetGlobalContext(), &answer, NULL, &status, peers_,
 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Post, uri.c_str(),
 0, NULL, NULL, body.empty() ? NULL : body.c_str(), body.size(), timeout_);
 if (code == OrthancPluginErrorCode_Success)
 {
 }
 OrthancPluginMemoryBuffer answer;
 uint16_t status;
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
-(context_, &answer, NULL, &status, peers_,
+(GetGlobalContext(), &answer, NULL, &status, peers_,
 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Put, uri.c_str(),
 0, NULL, NULL, body.empty() ? NULL : body.c_str(), body.size(), timeout_);
 if (code == OrthancPluginErrorCode_Success)
 {
-OrthancPluginFreeMemoryBuffer(context_, &answer);
+OrthancPluginFreeMemoryBuffer(GetGlobalContext(), &answer);
 return (status == 200);
 }
 else
 {
 return false;
 }
 OrthancPluginMemoryBuffer answer;
 uint16_t status;
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
-(context_, &answer, NULL, &status, peers_,
+(GetGlobalContext(), &answer, NULL, &status, peers_,
 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Put, uri.c_str(),
 0, NULL, NULL, NULL, 0, timeout_);
 if (code == OrthancPluginErrorCode_Success)
 {
-OrthancPluginFreeMemoryBuffer(context_, &answer);
+OrthancPluginFreeMemoryBuffer(GetGlobalContext(), &answer);
 return (status == 200);
 }
 else
 {
 return false;
 ClearContent();
 ClearSerialized();
 }
-OrthancPluginJob* OrthancJob::Create(OrthancPluginContext* context,
+OrthancPluginJob* OrthancJob::Create(OrthancJob* job)
-OrthancJob* job)
 {
 if (job == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer);
 }
 OrthancPluginJob* orthanc = OrthancPluginCreateJob(
-context, job, CallbackFinalize, job->jobType_.c_str(),
+GetGlobalContext(), job, CallbackFinalize, job->jobType_.c_str(),
 CallbackGetProgress, CallbackGetContent, CallbackGetSerialized,
 CallbackStep, CallbackStop, CallbackReset);
 if (orthanc == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }
 return orthanc;
 }
 }
-std::string OrthancJob::Submit(OrthancPluginContext* context,
+std::string OrthancJob::Submit(OrthancJob* job,
-OrthancJob* job,
 int priority)
 {
-OrthancPluginJob* orthanc = Create(context, job);
+OrthancPluginJob* orthanc = Create(job);
-char* id = OrthancPluginSubmitJob(context, orthanc, priority);
+char* id = OrthancPluginSubmitJob(GetGlobalContext(), orthanc, priority);
 if (id == NULL)
 {
-OrthancPluginLogError(context, "Plugin cannot submit job");
+LogError("Plugin cannot submit job");
-OrthancPluginFreeJob(context, orthanc);
+OrthancPluginFreeJob(GetGlobalContext(), orthanc);
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }
 else
 {
 std::string tmp(id);
 tmp.assign(id);
-OrthancPluginFreeString(context, id);
+OrthancPluginFreeString(GetGlobalContext(), id);
 return tmp;
 }
 }
 #endif

Mercurial > hg > orthanc

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