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

comparison Plugins/Samples/Common/OrthancPluginCppWrapper.cpp @ 2850:9f949922d603

fix

author	am@osimis.io
date	Mon, 01 Oct 2018 14:19:10 +0200
parents	dd3914a44b87
children	859e880ac9a8

comparison

equal deleted inserted replaced

-:dd3914a44b87
+:9f949922d603
 * modify file(s) with this exception, you may extend this exception to
 * your version of the file(s), but you are not obligated to do so. If
 * you do not wish to do so, delete this exception statement from your
 * version. If you delete this exception statement from all source files
 * in the program, then also delete it here.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code);
 }
 }
 MemoryBuffer::MemoryBuffer(OrthancPluginContext* context) :
 context_(context)
 {
 buffer_.data = NULL;
 buffer_.size = 0;
 }
 std::string s = writer.write(tags);
 Check(OrthancPluginCreateDicom(context_, &buffer_, s.c_str(), NULL, flags));
 }
-void MemoreyBuffer::CreateDicom(const Json::Value& tags,
+void MemoryBuffer::CreateDicom(const Json::Value& tags,
-const OrthancPluginImage& pixelData,
+const OrthancImage& pixelData,
 OrthancPluginCreateDicomFlags flags)
 {
 Clear();
 Json::FastWriter writer;
 std::string s = writer.write(tags);
 body.c_str(), body.size(),
 username.empty() ? NULL : username.c_str(),
 password.empty() ? NULL : password.c_str()));
 }
 bool MemoryBuffer::HttpPut(const std::string& url,
 const std::string& body,
 const std::string& username,
 const std::string& password)
 {
 const std::string& url,
 const std::string& username,
 const std::string& password)
 {
 OrthancPluginErrorCode error = OrthancPluginHttpDelete
 (context_, url.c_str(),
 username.empty() ? NULL : username.c_str(),
 password.empty() ? NULL : password.c_str());
 if (error == OrthancPluginErrorCode_Success)
 {
 return true;
 }
 else if (error == OrthancPluginErrorCode_UnknownResource ||
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error);
 }
 }
 OrthancConfiguration::OrthancConfiguration(OrthancPluginContext* context) :
 context_(context)
 {
 OrthancString str(context);
 str.Assign(OrthancPluginGetConfiguration(context));
 return false;
 }
 switch (configuration_[key].type())
 {
 case Json::intValue:
 target = configuration_[key].asInt();
 return true;
 case Json::uintValue:
 target = configuration_[key].asUInt();
 return true;
 default:
 if (context_ != NULL)
 {
 std::string s = "The configuration option \"" + GetPath(key) + "\" is not an integer as expected";
 OrthancPluginLogError(context_, s.c_str());
 }
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 bool OrthancConfiguration::LookupUnsignedIntegerValue(unsigned int& target,
 return false;
 }
 switch (configuration_[key].type())
 {
 case Json::realValue:
 target = configuration_[key].asFloat();
 return true;
 case Json::intValue:
 target = static_cast<float>(configuration_[key].asInt());
 return true;
 case Json::uintValue:
 target = static_cast<float>(configuration_[key].asUInt());
 return true;
 default:
 if (context_ != NULL)
 {
 std::string s = "The configuration option \"" + GetPath(key) + "\" is not an integer as expected";
 OrthancPluginLogError(context_, s.c_str());
 }
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 bool OrthancConfiguration::LookupListOfStrings(std::list<std::string>& target,
 return false;
 }
 switch (configuration_[key].type())
 {
 case Json::arrayValue:
 {
 bool ok = true;
 for (Json::Value::ArrayIndex i = 0; ok && i < configuration_[key].size(); i++)
+{
+if (configuration_[key][i].type() == Json::stringValue)
 {
-if (configuration_[key][i].type() == Json::stringValue)
+target.push_back(configuration_[key][i].asString());
-{
-target.push_back(configuration_[key][i].asString());
-}
-else
-{
-ok = false;
-}
 }
+else
-if (ok)
 {
-return true;
+ok = false;
 }
+}
-break;
-}
+if (ok)
+{
-case Json::stringValue:
+return true;
-if (allowSingleString)
+}
-{
-target.push_back(configuration_[key].asString());
+break;
-return true;
+}
-}
+case Json::stringValue:
-break;
+if (allowSingleString)
+{
-default:
+target.push_back(configuration_[key].asString());
-break;
+return true;
+}
+break;
+default:
+break;
 }
 if (context_ != NULL)
 {
 std::string s = ("The configuration option \"" + GetPath(key) +
 if (LookupListOfStrings(lst, key, allowSingleString))
 {
 target.clear();
 for (std::list<std::string>::const_iterator
 it = lst.begin(); it != lst.end(); ++it)
 {
 target.insert(*it);
 }
 return true;
 {
 CheckImageAvailable();
 return OrthancPluginGetImagePitch(context_, image_);
 }
 const void* OrthancImage::GetBuffer()
 {
 CheckImageAvailable();
 return OrthancPluginGetImageBuffer(context_, image_);
 }
 void OrthancImage::CompressPngImage(MemoryBuffer& target)
 {
 CheckImageAvailable();
 OrthancPluginMemoryBuffer tmp;
 OrthancPluginCompressPngImage(context_, &tmp, GetPixelFormat(),
 GetWidth(), GetHeight(), GetPitch(), GetBuffer());
 target.Assign(tmp);
 }
 uint8_t quality)
 {
 CheckImageAvailable();
 OrthancPluginMemoryBuffer tmp;
 OrthancPluginCompressJpegImage(context_, &tmp, GetPixelFormat(),
 GetWidth(), GetHeight(), GetPitch(), GetBuffer(), quality);
 target.Assign(tmp);
 }
 }
 FindMatcher::~FindMatcher()
 {
 // The "worklist_" field
 if (matcher_ != NULL)
 {
 OrthancPluginFreeFindMatcher(context_, matcher_);
 }
 std::string s = ("Your version of the Orthanc core (" +
 std::string(context->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());
 }
 unsigned int minor,
 unsigned int revision)
 {
 if (context == NULL)
 {
 OrthancPluginLogError(context, "Bad Orthanc context in the plugin");
 return false;
 }
 if (!strcmp(context->orthancVersion, "mainline"))
 {
 return true;
 }
 // Parse the version of the Orthanc core
 int aa, bb, cc;
 if (
 #ifdef _MSC_VER
 sscanf_s
 #else
 sscanf
 #endif
 (context->orthancVersion, "%4d.%4d.%4d", &aa, &bb, &cc) != 3 ||
 aa < 0 ||
 bb < 0 ||
 cc < 0)
 {
 return false;
 }
 unsigned int a = static_cast<unsigned int>(aa);
 peers_(NULL),
 timeout_(0)
 {
 if (context_ == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer);
 }
 peers_ = OrthancPluginGetPeers(context_);
 if (peers_ == NULL)
 }
 OrthancPluginMemoryBuffer answer;
 uint16_t status;
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
 (context_, &answer, NULL, &status, peers_,
 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Get, uri.c_str(),
 0, NULL, NULL, NULL, 0, timeout_);
 if (code == OrthancPluginErrorCode_Success)
 {
 target.Assign(answer);
 return (status == 200);
 bool OrthancPeers::DoGet(Json::Value& target,
 size_t index,
 const std::string& uri) const
 {
 MemoryBuffer buffer(context_);
 if (DoGet(buffer, index, uri))
 {
 buffer.ToJson(target);
 return true;
 }
 {
 return false;
 }
 }
 bool OrthancPeers::DoGet(Json::Value& target,
 const std::string& name,
 const std::string& uri) const
 {
 MemoryBuffer buffer(context_);
 if (DoGet(buffer, name, uri))
 {
 buffer.ToJson(target);
 return true;
 }
 size_t index,
 const std::string& uri,
 const std::string& body) const
 {
 MemoryBuffer buffer(context_);
 if (DoPost(buffer, index, uri, body))
 {
 buffer.ToJson(target);
 return true;
 }
 {
 return false;
 }
 }
 bool OrthancPeers::DoPost(Json::Value& target,
 const std::string& name,
 const std::string& uri,
 const std::string& body) const
 {
 MemoryBuffer buffer(context_);
 if (DoPost(buffer, name, uri, body))
 {
 buffer.ToJson(target);
 return true;
 }
 }
 OrthancPluginMemoryBuffer answer;
 uint16_t status;
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
 (context_, &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)
 {
 target.Assign(answer);
 return (status == 200);
 }
 OrthancPluginMemoryBuffer answer;
 uint16_t status;
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
 (context_, &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);
 return (status == 200);
 }
 OrthancPluginMemoryBuffer answer;
 uint16_t status;
 OrthancPluginErrorCode code = OrthancPluginCallPeerApi
 (context_, &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);
 return (status == 200);
 if (progress < 0 ||
 progress > 1)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange);
 }
 progress_ = progress;
 }
 OrthancJob::OrthancJob(const std::string& jobType) :
 jobType_(jobType),
 progress_(0)
 {
 ClearContent();
 ClearSerialized();
 }
 OrthancPluginJob* OrthancJob::Create(OrthancPluginContext* context,
 OrthancJob* job)
 {
 if (job == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer);
 }
 OrthancPluginJob* orthanc = OrthancPluginCreateJob(
 context, job, CallbackFinalize, job->jobType_.c_str(),
 CallbackGetProgress, CallbackGetContent, CallbackGetSerialized,
 CallbackStep, CallbackStop, CallbackReset);
 if (orthanc == NULL)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin);
 }

Mercurial > hg > orthanc

comparison Plugins/Samples/Common/OrthancPluginCppWrapper.cpp @ 2850:9f949922d603