orthanc-stone: RenderingPlugin/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp comparison

comparison RenderingPlugin/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp @ 2077:07964689cb0b

upgrade to year 2023

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 12 Jul 2023 21:20:22 +0200
parents	c0aa4b03f219
children	3ef91da06636

comparison

equal deleted inserted replaced

-:990f396484b1
+:07964689cb0b
 /**
 * Orthanc - A Lightweight, RESTful DICOM Store
 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
 * Department, University Hospital of Liege, Belgium
-* Copyright (C) 2017-2022 Osimis S.A., Belgium
+* Copyright (C) 2017-2023 Osimis S.A., Belgium
-* Copyright (C) 2021-2022 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
+* Copyright (C) 2021-2023 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
 * License, or (at your option) any later version.
 }
 // helper class to convert std::map of headers to the plugin SDK C structure
 class PluginHttpHeaders
 {
+private:
 std::vector<const char*> headersKeys_;
 std::vector<const char*> headersValues_;
 public:
+explicit PluginHttpHeaders(const std::map<std::string, std::string>& httpHeaders)
-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++)
+it = httpHeaders.begin(); it != httpHeaders.end(); ++it)
 {
 headersKeys_.push_back(it->first.c_str());
 headersValues_.push_back(it->second.c_str());
 }
 }
 {
 configuration_ = Json::objectValue;
 }
 }
+OrthancConfiguration::OrthancConfiguration(const Json::Value& configuration, const std::string& path) :
+configuration_(configuration),
+path_(path)
+{
+}
 std::string OrthancConfiguration::GetPath(const std::string& key) const
 {
 if (path_.empty())
 {
 }
 if (configuration_[key].type() != Json::objectValue)
 {
 LogError("The configuration option \"" + GetPath(key) +
-"\" is not a string as expected");
+"\" is not an object as expected");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 Json::Value::Members members = configuration_[key].getMemberNames();
 answer.ToString(result);
 return true;
 }
 }
+bool RestApiGet(Json::Value& result,
+const std::string& uri,
+const std::map<std::string, std::string>& httpHeaders,
+bool applyPlugins)
+{
+MemoryBuffer answer;
+if (!answer.RestApiGet(uri, httpHeaders, applyPlugins))
+{
+return false;
+}
+else
+{
+if (!answer.IsEmpty())
+{
+answer.ToJson(result);
+}
+return true;
+}
+}
 bool RestApiGet(Json::Value& result,
 const std::string& uri,
 bool applyPlugins)
 return 0;
 }
 }
+#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3)
+static OrthancPluginErrorCode CopyStringToMemoryBuffer(OrthancPluginMemoryBuffer* target,
+const std::string& source)
+{
+if (OrthancPluginCreateMemoryBuffer(globalContext_, target, source.size()) != OrthancPluginErrorCode_Success)
+{
+return OrthancPluginErrorCode_NotEnoughMemory;
+}
+else
+{
+if (!source.empty())
+{
+memcpy(target->data, source.c_str(), source.size());
+}
+return OrthancPluginErrorCode_Success;
+}
+}
+#endif
+#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3)
+OrthancPluginErrorCode OrthancJob::CallbackGetContent(OrthancPluginMemoryBuffer* target,
+void* job)
+{
+assert(job != NULL);
+OrthancJob& that = *reinterpret_cast<OrthancJob*>(job);
+return CopyStringToMemoryBuffer(target, that.content_);
+}
+#else
 const char* OrthancJob::CallbackGetContent(void* job)
 {
 assert(job != NULL);
 try
 catch (...)
 {
 return 0;
 }
 }
+#endif
+#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3)
+int32_t OrthancJob::CallbackGetSerialized(OrthancPluginMemoryBuffer* target,
+void* job)
+{
+assert(job != NULL);
+OrthancJob& that = *reinterpret_cast<OrthancJob*>(job);
+if (that.hasSerialized_)
+{
+if (CopyStringToMemoryBuffer(target, that.serialized_) == OrthancPluginErrorCode_Success)
+{
+return 1;
+}
+else
+{
+return -1;
+}
+}
+else
+{
+return 0;
+}
+}
+#else
 const char* OrthancJob::CallbackGetSerialized(void* job)
 {
 assert(job != NULL);
 try
 catch (...)
 {
 return 0;
 }
 }
+#endif
 OrthancPluginJobStepStatus OrthancJob::CallbackStep(void* job)
 {
 assert(job != NULL);
 if (job == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer);
 }
-OrthancPluginJob* orthanc = OrthancPluginCreateJob(
+OrthancPluginJob* orthanc =
-GetGlobalContext(), job, CallbackFinalize, job->jobType_.c_str(),
+#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3)
-CallbackGetProgress, CallbackGetContent, CallbackGetSerialized,
+OrthancPluginCreateJob2
-CallbackStep, CallbackStop, CallbackReset);
+#else
+OrthancPluginCreateJob
+#endif
+(GetGlobalContext(), job, CallbackFinalize, job->jobType_.c_str(),
+CallbackGetProgress, CallbackGetContent, CallbackGetSerialized,
+CallbackStep, CallbackStop, CallbackReset);
 if (orthanc == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }
 size_t size,
 const std::string& transferSyntax)
 {
 OrthancPluginDicomInstance* instance = OrthancPluginTranscodeDicomInstance(
 GetGlobalContext(), buffer, size, transferSyntax.c_str());
+if (instance == NULL)
+{
+ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin);
+}
+else
+{
+boost::movelib::unique_ptr<DicomInstance> result(new DicomInstance(instance));
+result->toFree_ = true;
+return result.release();
+}
+}
+#endif
+#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 1)
+DicomInstance* DicomInstance::Load(const std::string& instanceId,
+OrthancPluginLoadDicomInstanceMode mode)
+{
+OrthancPluginDicomInstance* instance = OrthancPluginLoadDicomInstance(
+GetGlobalContext(), instanceId.c_str(), mode);
 if (instance == NULL)
 {
 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin);
 }

Mercurial > hg > orthanc-stone

comparison RenderingPlugin/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp @ 2077:07964689cb0b