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

comparison OrthancServer/Plugins/Samples/Common/OrthancPluginCppWrapper.cpp @ 4394:f7104e9d044c

functions to read/write JSON in OrthancPluginCppWrapper.h

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 22 Dec 2020 08:11:37 +0100
parents	4bb7522a63e0
children	d07a65100a95

comparison

equal deleted inserted replaced

-:e8e95b80194f
+:f7104e9d044c
 #include "OrthancPluginCppWrapper.h"
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/move/unique_ptr.hpp>
 #include <boost/thread.hpp>
 #include <json/reader.h>
+#include <json/version.h>
 #include <json/writer.h>
+#if !defined(JSONCPP_VERSION_MAJOR) || !defined(JSONCPP_VERSION_MINOR)
+#  error Cannot access the version of JsonCpp
+#endif
+/**
+* We use deprecated "Json::Reader", "Json::StyledWriter" and
+* "Json::StyledReader" if JsonCpp < 1.7.0. This choice is rather
+* arbitrary, but if Json >= 1.9.0, gcc generates explicit deprecation
+* warnings (clang was warning in earlier versions). For reference,
+* these classes seem to have been deprecated since JsonCpp 1.4.0 (on
+* February 2015) by the following changeset:
+* https://github.com/open-source-parsers/jsoncpp/commit/8df98f6112890d6272734975dd6d70cf8999bb22
+**/
+#if (JSONCPP_VERSION_MAJOR >= 2 ||                                      \
+(JSONCPP_VERSION_MAJOR == 1 && JSONCPP_VERSION_MINOR >= 8))
+#  define JSONCPP_USE_DEPRECATED 0
+#else
+#  define JSONCPP_USE_DEPRECATED 1
+#endif
 #if !ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 2, 0)
 static const OrthancPluginErrorCode OrthancPluginErrorCode_NullPointer = OrthancPluginErrorCode_Plugin;
 #endif
 buffer_.size == 0)
 {
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
-const char* tmp = reinterpret_cast<const char*>(buffer_.data);
+if (!ReadJson(target, buffer_.data, buffer_.size))
-Json::Reader reader;
-if (!reader.parse(tmp, tmp + buffer_.size, target))
 {
 LogError("Cannot convert some memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 return CheckHttp(OrthancPluginRestApiPut(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize));
 }
 }
+bool ReadJson(Json::Value& target,
+const std::string& source)
+{
+#if JSONCPP_USE_DEPRECATED == 1
+Json::Reader reader;
+return reader.parse(source, target);
+#else
+return ReadJson(target, source.c_str(), source.size());
+#endif
+}
+bool ReadJson(Json::Value& target,
+const void* buffer,
+size_t size)
+{
+#if JSONCPP_USE_DEPRECATED == 1
+Json::Reader reader;
+return reader.parse(reinterpret_cast<const char*>(buffer),
+reinterpret_cast<const char*>(buffer) + size, target);
+#else
+Json::CharReaderBuilder builder;
+const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+assert(reader.get() != NULL);
+JSONCPP_STRING err;
+if (reader->parse(reinterpret_cast<const char*>(buffer),
+reinterpret_cast<const char*>(buffer) + size, &target, &err))
+{
+return true;
+}
+else
+{
+LogError("Cannot parse JSON: " + err);
+return false;
+}
+#endif
+}
+void WriteFastJson(std::string& target,
+const Json::Value& source)
+{
+#if JSONCPP_USE_DEPRECATED == 1
+Json::FastWriter writer;
+target = writer.write(source);
+#else
+Json::StreamWriterBuilder builder;
+builder.settings_["indentation"] = "";
+target = Json::writeString(builder, source);
+#endif
+}
+void WriteStyledJson(std::string& target,
+const Json::Value& source)
+{
+#if JSONCPP_USE_DEPRECATED == 1
+Json::StyledWriter writer;
+target = writer.write(source);
+#else
+Json::StreamWriterBuilder builder;
+builder.settings_["indentation"] = "   ";
+target = Json::writeString(builder, source);
+#endif
+}
 bool MemoryBuffer::RestApiPost(const std::string& uri,
 const Json::Value& body,
 bool applyPlugins)
 {
-Json::FastWriter writer;
+std::string s;
-return RestApiPost(uri, writer.write(body), applyPlugins);
+WriteFastJson(s, body);
+return RestApiPost(uri, s, applyPlugins);
 }
 bool MemoryBuffer::RestApiPut(const std::string& uri,
 const Json::Value& body,
 bool applyPlugins)
 {
-Json::FastWriter writer;
+std::string s;
-return RestApiPut(uri, writer.write(body), applyPlugins);
+WriteFastJson(s, body);
+return RestApiPut(uri, s, applyPlugins);
 }
 void MemoryBuffer::CreateDicom(const Json::Value& tags,
 OrthancPluginCreateDicomFlags flags)
 {
 Clear();
-Json::FastWriter writer;
+std::string s;
-std::string s = writer.write(tags);
+WriteFastJson(s, tags);
 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;
-std::string s = writer.write(tags);
+WriteFastJson(s, tags);
 Check(OrthancPluginCreateDicom(GetGlobalContext(), &buffer_, s.c_str(), pixelData.GetObject(), flags));
 }
 {
 LogError("Cannot convert an empty memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError);
 }
-Json::Reader reader;
+if (!ReadJson(target, str_))
-if (!reader.parse(str_, target))
 {
 LogError("Cannot convert some memory buffer to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }
 }
 #endif /* HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 */
 void AnswerJson(const Json::Value& value,
-OrthancPluginRestOutput* output
+OrthancPluginRestOutput* output)
-)
+{
-{
+std::string bodyString;
-Json::StyledWriter writer;
+WriteStyledJson(bodyString, value);
-std::string bodyString = writer.write(value);
 OrthancPluginAnswerBuffer(GetGlobalContext(), output, bodyString.c_str(), bodyString.size(), "application/json");
 }
 void AnswerString(const std::string& answer,
 const char* mimeType,
-OrthancPluginRestOutput* output
+OrthancPluginRestOutput* output)
-)
 {
 OrthancPluginAnswerBuffer(GetGlobalContext(), output, answer.c_str(), answer.size(), mimeType);
 }
 void AnswerHttpError(uint16_t httpError, OrthancPluginRestOutput *output)
 bool RestApiPost(Json::Value& result,
 const std::string& uri,
 const Json::Value& body,
 bool applyPlugins)
 {
-Json::FastWriter writer;
+std::string s;
-return RestApiPost(result, uri, writer.write(body), applyPlugins);
+WriteFastJson(s, body);
+return RestApiPost(result, uri, s, applyPlugins);
 }
 bool RestApiPut(Json::Value& result,
 const std::string& uri,
 bool RestApiPut(Json::Value& result,
 const std::string& uri,
 const Json::Value& body,
 bool applyPlugins)
 {
-Json::FastWriter writer;
+std::string s;
-return RestApiPut(result, uri, writer.write(body), applyPlugins);
+WriteFastJson(s, body);
+return RestApiPut(result, uri, s, applyPlugins);
 }
 bool RestApiDelete(const std::string& uri,
 bool applyPlugins)
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_BadFileFormat);
 }
 else
 {
-Json::FastWriter writer;
+WriteFastJson(content_, content);
-content_ = writer.write(content);
 }
 }
 void OrthancJob::ClearSerialized()
 {
 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_BadFileFormat);
 }
 else
 {
-Json::FastWriter writer;
+WriteFastJson(serialized_, serialized);
-serialized_ = writer.write(serialized);
 hasSerialized_ = true;
 }
 }
 Json::Value& answerBody /* out */)
 {
 std::string body;
 Execute(answerHeaders, body);
-Json::Reader reader;
+if (!ReadJson(answerBody, body))
-if (!reader.parse(body, answerBody))
 {
 LogError("Cannot convert HTTP answer body to JSON");
 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat);
 }
 }

Mercurial > hg > orthanc

comparison OrthancServer/Plugins/Samples/Common/OrthancPluginCppWrapper.cpp @ 4394:f7104e9d044c