orthanc-object-storage: Common/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp comparison

comparison Common/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp @ 145:3c7e0374f28e

updated copyright, as Orthanc Team now replaces Osimis

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 30 May 2024 22:35:35 +0200
parents	82ab647f7e73
children

comparison

equal deleted inserted replaced

-:dc54e850f586
+:3c7e0374f28e
 /**
 * Orthanc - A Lightweight, RESTful DICOM Store
 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
 * Department, University Hospital of Liege, Belgium
-* Copyright (C) 2017-2024 Osimis S.A., Belgium
+* Copyright (C) 2017-2023 Osimis S.A., Belgium
+* Copyright (C) 2024-2024 Orthanc Team SRL, Belgium
 * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 namespace OrthancPlugins
 {
 static OrthancPluginContext* globalContext_ = NULL;
+static std::string pluginName_;
 void SetGlobalContext(OrthancPluginContext* context)
 {
 if (context == NULL)
 {
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls);
 }
 }
+void SetGlobalContext(OrthancPluginContext* context,
+const char* pluginName)
+{
+SetGlobalContext(context);
+pluginName_ = pluginName;
+}
 void ResetGlobalContext()
 {
 globalContext_ = NULL;
+pluginName_.clear();
 }
 bool HasGlobalContext()
 {
 return globalContext_ != NULL;
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls);
 }
 else
 {
 return globalContext_;
+}
+}
+#if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1
+void LogMessage(OrthancPluginLogLevel level,
+const char* file,
+uint32_t line,
+const std::string& message)
+{
+if (HasGlobalContext())
+{
+#if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1
+const char* pluginName = (pluginName_.empty() ? NULL : pluginName_.c_str());
+OrthancPluginLogMessage(GetGlobalContext(), message.c_str(), pluginName, file, line, OrthancPluginLogCategory_Generic, level);
+#else
+switch (level)
+{
+case OrthancPluginLogLevel_Error:
+OrthancPluginLogError(GetGlobalContext(), message.c_str());
+break;
+case OrthancPluginLogLevel_Warning:
+OrthancPluginLogWarning(GetGlobalContext(), message.c_str());
+break;
+case OrthancPluginLogLevel_Info:
+OrthancPluginLogInfo(GetGlobalContext(), message.c_str());
+break;
+default:
+ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
+}
+#endif
+}
+}
+#endif
+void LogError(const std::string& message)
+{
+if (HasGlobalContext())
+{
+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());
 }
 }
 void MemoryBuffer::Check(OrthancPluginErrorCode code)
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 if (!ReadJson(target, buffer_.data, buffer_.size))
 {
-LogError("Cannot convert some memory buffer to JSON");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot convert some memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 public:
 explicit PluginHttpHeaders(const std::map<std::string, std::string>& httpHeaders)
 {
 for (std::map<std::string, std::string>::const_iterator
 it = httpHeaders.begin(); it != httpHeaders.end(); ++it)
 {
 headersKeys_.push_back(it->first.c_str());
 headersValues_.push_back(it->second.c_str());
 }
 }
 {
 return true;
 }
 else
 {
-LogError("Cannot parse JSON: " + std::string(err));
+ORTHANC_PLUGINS_LOG_ERROR("Cannot parse JSON: " + std::string(err));
 return false;
 }
 #endif
 }
 void OrthancString::ToJson(Json::Value& target) const
 {
 if (str_ == NULL)
 {
-LogError("Cannot convert an empty memory buffer to JSON");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot convert an empty memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 if (!ReadJson(target, str_))
 {
-LogError("Cannot convert some memory buffer to JSON");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot convert some memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 void OrthancString::ToJsonWithoutComments(Json::Value& target) const
 {
 if (str_ == NULL)
 {
-LogError("Cannot convert an empty memory buffer to JSON");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot convert an empty memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 if (!ReadJsonWithoutComments(target, str_))
 {
-LogError("Cannot convert some memory buffer to JSON");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot convert some memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 {
 Clear();
 if (body.size() > 0xffffffffu)
 {
-LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 return CheckHttp(OrthancPluginHttpPost(GetGlobalContext(), &buffer_, url.c_str(),
 body.c_str(), body.size(),
 {
 Clear();
 if (body.size() > 0xffffffffu)
 {
-LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 return CheckHttp(OrthancPluginHttpPut(GetGlobalContext(), &buffer_, url.c_str(),
 body.empty() ? NULL : body.c_str(),
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error);
 }
 }
-void LogError(const std::string& message)
-{
-if (HasGlobalContext())
-{
-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());
-}
-}
 void OrthancConfiguration::LoadConfiguration()
 {
 OrthancString str;
 str.Assign(OrthancPluginGetConfiguration(GetGlobalContext()));
 if (str.GetContent() == NULL)
 {
-LogError("Cannot access the Orthanc configuration");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot access the Orthanc configuration");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 str.ToJsonWithoutComments(configuration_);
 if (configuration_.type() != Json::objectValue)
 {
-LogError("Unable to read the Orthanc configuration");
+ORTHANC_PLUGINS_LOG_ERROR("Unable to read the Orthanc configuration");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 }
 }
 else
 {
 if (configuration_[key].type() != Json::objectValue)
 {
-LogError("The configuration section \"" + target.path_ +
+ORTHANC_PLUGINS_LOG_ERROR("The configuration section \"" + target.path_ +
 "\" is not an associative array as expected");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 target.configuration_ = configuration_[key];
 return false;
 }
 if (configuration_[key].type() != Json::stringValue)
 {
-LogError("The configuration option \"" + GetPath(key) +
+ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) +
 "\" is not a string as expected");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 target = configuration_[key].asString();
 case Json::uintValue:
 target = configuration_[key].asUInt();
 return true;
 default:
-LogError("The configuration option \"" + GetPath(key) +
+ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) +
 "\" is not an integer as expected");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 return false;
 }
 if (tmp < 0)
 {
-LogError("The configuration option \"" + GetPath(key) +
+ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) +
 "\" is not a positive integer as expected");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 else
 {
 return false;
 }
 if (configuration_[key].type() != Json::booleanValue)
 {
-LogError("The configuration option \"" + GetPath(key) +
+ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) +
 "\" is not a Boolean as expected");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 target = configuration_[key].asBool();
 case Json::uintValue:
 target = static_cast<float>(configuration_[key].asUInt());
 return true;
 default:
-LogError("The configuration option \"" + GetPath(key) +
+ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) +
 "\" is not an integer as expected");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 default:
 break;
 }
-LogError("The configuration option \"" + GetPath(key) +
+ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) +
 "\" is not a list of strings as expected");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 return;
 }
 if (configuration_[key].type() != Json::objectValue)
 {
-LogError("The configuration option \"" + GetPath(key) +
+ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) +
 "\" is not an object as expected");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 Json::Value::Members members = configuration_[key].getMemberNames();
 {
 target[members[i]] = value.asString();
 }
 else
 {
-LogError("The configuration option \"" + GetPath(key) +
+ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) +
 "\" is not a dictionary mapping strings to strings");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 }
 void OrthancImage::CheckImageAvailable() const
 {
 if (image_ == NULL)
 {
-LogError("Trying to access a NULL image");
+ORTHANC_PLUGINS_LOG_ERROR("Trying to access a NULL image");
 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
 }
 }
 {
 image_ = OrthancPluginCreateImage(GetGlobalContext(), format, width, height);
 if (image_ == NULL)
 {
-LogError("Cannot create an image");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot create an image");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 }
 image_ = OrthancPluginCreateImageAccessor
 (GetGlobalContext(), format, width, height, pitch, buffer);
 if (image_ == NULL)
 {
-LogError("Cannot create an image accessor");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot create an image accessor");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 }
 void OrthancImage::UncompressPngImage(const void* data,
 image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Png);
 if (image_ == NULL)
 {
-LogError("Cannot uncompress a PNG image");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot uncompress a PNG image");
 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
 }
 }
 {
 Clear();
 image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Jpeg);
 if (image_ == NULL)
 {
-LogError("Cannot uncompress a JPEG image");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot uncompress a JPEG image");
 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
 }
 }
 {
 Clear();
 image_ = OrthancPluginDecodeDicomImage(GetGlobalContext(), data, size, frame);
 if (image_ == NULL)
 {
-LogError("Cannot uncompress a DICOM image");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot uncompress a DICOM image");
 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange);
 }
 }
 void ReportMinimalOrthancVersion(unsigned int major,
 unsigned int minor,
 unsigned int revision)
 {
-LogError("Your version of the Orthanc core (" +
+ORTHANC_PLUGINS_LOG_ERROR("Your version of the Orthanc core (" +
 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)");
 }
 bool CheckMinimalVersion(const char* version,
 unsigned int major,
 unsigned int minor,
 // Parse the version
 int aa, bb, cc = 0;
 if ((ORTHANC_SCANF(version, "%4d.%4d.%4d", &aa, &bb, &cc) != 3 &&
 ORTHANC_SCANF(version, "%4d.%4d", &aa, &bb) != 2) ||
 aa < 0 ||
 bb < 0 ||
 cc < 0)
 {
 return false;
 }
 unsigned int a = static_cast<unsigned int>(aa);
 unsigned int minor,
 unsigned int revision)
 {
 if (!HasGlobalContext())
 {
-LogError("Bad Orthanc context in the plugin");
+ORTHANC_PLUGINS_LOG_ERROR("Bad Orthanc context in the plugin");
 return false;
 }
 return CheckMinimalVersion(GetGlobalContext()->orthancVersion,
 major, minor, revision);
 {
 return index;
 }
 else
 {
-LogError("Inexistent peer: " + name);
+ORTHANC_PLUGINS_LOG_ERROR("Inexistent peer: " + name);
 ORTHANC_PLUGINS_THROW_EXCEPTION(UnknownResource);
 }
 }
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
 }
 if (body.size() > 0xffffffffu)
 {
-LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 OrthancPlugins::MemoryBuffer answer;
 uint16_t status;
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
 }
 if (body.size() > 0xffffffffu)
 {
-LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 OrthancPlugins::MemoryBuffer answer;
 uint16_t status;
 char* id = OrthancPluginSubmitJob(GetGlobalContext(), orthanc, priority);
 if (id == NULL)
 {
-LogError("Plugin cannot submit job");
+ORTHANC_PLUGINS_LOG_ERROR("Plugin cannot submit job");
 OrthancPluginFreeJob(GetGlobalContext(), orthanc);
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }
 else
 {
 {
 #if HAS_ORTHANC_EXCEPTION == 1
 throw Orthanc::OrthancException(static_cast<Orthanc::ErrorCode>(status["ErrorCode"].asInt()),
 status["ErrorDescription"].asString());
 #else
-LogError("Exception while executing the job: " + status["ErrorDescription"].asString());
+ORTHANC_PLUGINS_LOG_ERROR("Exception while executing the job: " + status["ErrorDescription"].asString());
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(status["ErrorCode"].asInt());
 #endif
 }
 }
 }
 {
 #if HAS_ORTHANC_EXCEPTION == 1
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat,
 "Expected a JSON object in the body");
 #else
-LogError("Expected a JSON object in the body");
+ORTHANC_PLUGINS_LOG_ERROR("Expected a JSON object in the body");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 #endif
 }
 bool synchronous = true;
 #if HAS_ORTHANC_EXCEPTION == 1
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat,
 "Option \"" + std::string(KEY_SYNCHRONOUS) +
 "\" must be Boolean");
 #else
-LogError("Option \"" + std::string(KEY_SYNCHRONOUS) + "\" must be Boolean");
+ORTHANC_PLUGINS_LOG_ERROR("Option \"" + std::string(KEY_SYNCHRONOUS) + "\" must be Boolean");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 #endif
 }
 else
 {
 #if HAS_ORTHANC_EXCEPTION == 1
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat,
 "Option \"" + std::string(KEY_ASYNCHRONOUS) +
 "\" must be Boolean");
 #else
-LogError("Option \"" + std::string(KEY_ASYNCHRONOUS) + "\" must be Boolean");
+ORTHANC_PLUGINS_LOG_ERROR("Option \"" + std::string(KEY_ASYNCHRONOUS) + "\" must be Boolean");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 #endif
 }
 else
 {
 #if HAS_ORTHANC_EXCEPTION == 1
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat,
 "Option \"" + std::string(KEY_PRIORITY) +
 "\" must be an integer");
 #else
-LogError("Option \"" + std::string(KEY_PRIORITY) + "\" must be an integer");
+ORTHANC_PLUGINS_LOG_ERROR("Option \"" + std::string(KEY_PRIORITY) + "\" must be an integer");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 #endif
 }
 else
 {
 MemoryBuffer answerBodyBuffer, answerHeadersBuffer;
 if (body.size() > 0xffffffffu)
 {
-LogError("Cannot handle body size > 4GB");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
 OrthancPluginErrorCode error = OrthancPluginHttpClient(
 GetGlobalContext(),
 std::string body;
 Execute(answerHeaders, body);
 if (!ReadJson(answerBody, body))
 {
-LogError("Cannot convert HTTP answer body to JSON");
+ORTHANC_PLUGINS_LOG_ERROR("Cannot convert HTTP answer body to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }

Mercurial > hg > orthanc-object-storage

comparison Common/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp @ 145:3c7e0374f28e