Mercurial > hg > orthanc
annotate OrthancServer/Plugins/Samples/Common/OrthancPluginCppWrapper.cpp @ 5575:d7eaa568da15
Orthanc::Logging automatically detects whether the Orthanc core supports OrthancPluginLogMessage()
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Fri, 26 Apr 2024 17:17:34 +0200 |
parents | f0dc99bc811c |
children | f7adfb22e20e |
rev | line source |
---|---|
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1 /** |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2 * Orthanc - A Lightweight, RESTful DICOM Store |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
4 * Department, University Hospital of Liege, Belgium |
5485
48b8dae6dc77
upgrade to year 2024
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5441
diff
changeset
|
5 * Copyright (C) 2017-2024 Osimis S.A., Belgium |
48b8dae6dc77
upgrade to year 2024
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5441
diff
changeset
|
6 * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
7 * |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
8 * This program is free software: you can redistribute it and/or |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
9 * modify it under the terms of the GNU General Public License as |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
10 * published by the Free Software Foundation, either version 3 of the |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
11 * License, or (at your option) any later version. |
4122
4bb7522a63e0
do not enforce openssl exception in plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
12 * |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
13 * This program is distributed in the hope that it will be useful, but |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
14 * WITHOUT ANY WARRANTY; without even the implied warranty of |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
16 * General Public License for more details. |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
17 * |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
18 * You should have received a copy of the GNU General Public License |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
20 **/ |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
21 |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
22 |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
23 #include "OrthancPluginCppWrapper.h" |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
24 |
3749
edabdf07ee83
replacing deprecated std::auto_ptr by boost::movelib in C++ plugin wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3669
diff
changeset
|
25 #include <boost/algorithm/string/predicate.hpp> |
edabdf07ee83
replacing deprecated std::auto_ptr by boost::movelib in C++ plugin wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3669
diff
changeset
|
26 #include <boost/move/unique_ptr.hpp> |
3437
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
27 #include <boost/thread.hpp> |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
28 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
29 |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
30 #include <json/reader.h> |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
31 #include <json/version.h> |
2058
43cd2ab060c7
cont OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2048
diff
changeset
|
32 #include <json/writer.h> |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
33 |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
34 #if !defined(JSONCPP_VERSION_MAJOR) || !defined(JSONCPP_VERSION_MINOR) |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
35 # error Cannot access the version of JsonCpp |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
36 #endif |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
37 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
38 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
39 /** |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
40 * We use deprecated "Json::Reader", "Json::StyledWriter" and |
4396 | 41 * "Json::FastWriter" if JsonCpp < 1.7.0. This choice is rather |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
42 * arbitrary, but if Json >= 1.9.0, gcc generates explicit deprecation |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
43 * warnings (clang was warning in earlier versions). For reference, |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
44 * these classes seem to have been deprecated since JsonCpp 1.4.0 (on |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
45 * February 2015) by the following changeset: |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
46 * https://github.com/open-source-parsers/jsoncpp/commit/8df98f6112890d6272734975dd6d70cf8999bb22 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
47 **/ |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
48 #if (JSONCPP_VERSION_MAJOR >= 2 || \ |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
49 (JSONCPP_VERSION_MAJOR == 1 && JSONCPP_VERSION_MINOR >= 8)) |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
50 # define JSONCPP_USE_DEPRECATED 0 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
51 #else |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
52 # define JSONCPP_USE_DEPRECATED 1 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
53 #endif |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
54 |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
55 |
3916
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
56 #if !ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 2, 0) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
57 static const OrthancPluginErrorCode OrthancPluginErrorCode_NullPointer = OrthancPluginErrorCode_Plugin; |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
58 #endif |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
59 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
60 |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
61 namespace OrthancPlugins |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
62 { |
3028 | 63 static OrthancPluginContext* globalContext_ = NULL; |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
64 static std::string pluginName_; |
2958
bb7a66efbeb1
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2851
diff
changeset
|
65 |
bb7a66efbeb1
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2851
diff
changeset
|
66 |
3028 | 67 void SetGlobalContext(OrthancPluginContext* context) |
2958
bb7a66efbeb1
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2851
diff
changeset
|
68 { |
3028 | 69 if (context == NULL) |
70 { | |
71 ORTHANC_PLUGINS_THROW_EXCEPTION(NullPointer); | |
72 } | |
73 else if (globalContext_ == NULL) | |
74 { | |
75 globalContext_ = context; | |
76 } | |
77 else | |
78 { | |
79 ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls); | |
80 } | |
3026 | 81 } |
82 | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
83 |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
84 void SetGlobalContext(OrthancPluginContext* context, |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
85 const char* pluginName) |
5561
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
86 { |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
87 SetGlobalContext(context); |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
88 pluginName_ = pluginName; |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
89 } |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
90 |
5561
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
91 |
5412
1a351a141653
ServerContextLock -> ServerContextReference to allow multiple plugins to use it at the same time
Alain Mazy <am@osimis.io>
parents:
5375
diff
changeset
|
92 void ResetGlobalContext() |
1a351a141653
ServerContextLock -> ServerContextReference to allow multiple plugins to use it at the same time
Alain Mazy <am@osimis.io>
parents:
5375
diff
changeset
|
93 { |
1a351a141653
ServerContextLock -> ServerContextReference to allow multiple plugins to use it at the same time
Alain Mazy <am@osimis.io>
parents:
5375
diff
changeset
|
94 globalContext_ = NULL; |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
95 pluginName_.clear(); |
5412
1a351a141653
ServerContextLock -> ServerContextReference to allow multiple plugins to use it at the same time
Alain Mazy <am@osimis.io>
parents:
5375
diff
changeset
|
96 } |
3026 | 97 |
3028 | 98 bool HasGlobalContext() |
99 { | |
100 return globalContext_ != NULL; | |
101 } | |
102 | |
103 | |
104 OrthancPluginContext* GetGlobalContext() | |
105 { | |
106 if (globalContext_ == NULL) | |
107 { | |
108 ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls); | |
109 } | |
110 else | |
111 { | |
112 return globalContext_; | |
113 } | |
114 } | |
2958
bb7a66efbeb1
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2851
diff
changeset
|
115 |
5575
d7eaa568da15
Orthanc::Logging automatically detects whether the Orthanc core supports OrthancPluginLogMessage()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5572
diff
changeset
|
116 |
d7eaa568da15
Orthanc::Logging automatically detects whether the Orthanc core supports OrthancPluginLogMessage()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5572
diff
changeset
|
117 #if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1 |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
118 void LogMessage(OrthancPluginLogLevel level, |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
119 const char* file, |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
120 uint32_t line, |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
121 const std::string& message) |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
122 { |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
123 if (HasGlobalContext()) |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
124 { |
5575
d7eaa568da15
Orthanc::Logging automatically detects whether the Orthanc core supports OrthancPluginLogMessage()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5572
diff
changeset
|
125 #if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1 |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
126 const char* pluginName = (pluginName_.empty() ? NULL : pluginName_.c_str()); |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
127 OrthancPluginLogMessage(GetGlobalContext(), message.c_str(), pluginName, file, line, OrthancPluginLogCategory_Generic, level); |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
128 #else |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
129 switch (level) |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
130 { |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
131 case OrthancPluginLogLevel_Error: |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
132 OrthancPluginLogError(GetGlobalContext(), message.c_str()); |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
133 break; |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
134 |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
135 case OrthancPluginLogLevel_Warning: |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
136 OrthancPluginLogWarning(GetGlobalContext(), message.c_str()); |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
137 break; |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
138 |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
139 case OrthancPluginLogLevel_Info: |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
140 OrthancPluginLogInfo(GetGlobalContext(), message.c_str()); |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
141 break; |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
142 |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
143 default: |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
144 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
145 } |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
146 #endif |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
147 } |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
148 } |
5575
d7eaa568da15
Orthanc::Logging automatically detects whether the Orthanc core supports OrthancPluginLogMessage()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5572
diff
changeset
|
149 #endif |
d7eaa568da15
Orthanc::Logging automatically detects whether the Orthanc core supports OrthancPluginLogMessage()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5572
diff
changeset
|
150 |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
151 |
5561
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
152 void LogError(const std::string& message) |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
153 { |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
154 if (HasGlobalContext()) |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
155 { |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
156 OrthancPluginLogError(GetGlobalContext(), message.c_str()); |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
157 } |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
158 } |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
159 |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
160 void LogWarning(const std::string& message) |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
161 { |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
162 if (HasGlobalContext()) |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
163 { |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
164 OrthancPluginLogWarning(GetGlobalContext(), message.c_str()); |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
165 } |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
166 } |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
167 |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
168 void LogInfo(const std::string& message) |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
169 { |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
170 if (HasGlobalContext()) |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
171 { |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
172 OrthancPluginLogInfo(GetGlobalContext(), message.c_str()); |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
173 } |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
174 } |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
175 |
0b18690c1935
SDK: added OrthancPluginLogMessage to display plugin name + file and line from plugin
Alain Mazy <am@orthanc.team>
parents:
5539
diff
changeset
|
176 |
3028 | 177 void MemoryBuffer::Check(OrthancPluginErrorCode code) |
2062
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
178 { |
3028 | 179 if (code != OrthancPluginErrorCode_Success) |
180 { | |
181 // Prevent using garbage information | |
182 buffer_.data = NULL; | |
183 buffer_.size = 0; | |
184 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); | |
185 } | |
2062
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
186 } |
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
187 |
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
188 |
3028 | 189 bool MemoryBuffer::CheckHttp(OrthancPluginErrorCode code) |
2264
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
190 { |
3028 | 191 if (code != OrthancPluginErrorCode_Success) |
192 { | |
193 // Prevent using garbage information | |
194 buffer_.data = NULL; | |
195 buffer_.size = 0; | |
196 } | |
197 | |
198 if (code == OrthancPluginErrorCode_Success) | |
199 { | |
200 return true; | |
201 } | |
202 else if (code == OrthancPluginErrorCode_UnknownResource || | |
203 code == OrthancPluginErrorCode_InexistentItem) | |
204 { | |
205 return false; | |
206 } | |
207 else | |
208 { | |
209 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); | |
210 } | |
2264
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
211 } |
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
212 |
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
213 |
3028 | 214 MemoryBuffer::MemoryBuffer() |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
215 { |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
216 buffer_.data = NULL; |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
217 buffer_.size = 0; |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
218 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
219 |
3028 | 220 |
3934
0b59e2706366
guard on SDK version in OrthancPlugins::MemoryBuffer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3930
diff
changeset
|
221 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) |
3930
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
222 MemoryBuffer::MemoryBuffer(const void* buffer, |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
223 size_t size) |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
224 { |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
225 uint32_t s = static_cast<uint32_t>(size); |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
226 if (static_cast<size_t>(s) != size) |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
227 { |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
228 ORTHANC_PLUGINS_THROW_EXCEPTION(NotEnoughMemory); |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
229 } |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
230 else if (OrthancPluginCreateMemoryBuffer(GetGlobalContext(), &buffer_, s) != |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
231 OrthancPluginErrorCode_Success) |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
232 { |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
233 ORTHANC_PLUGINS_THROW_EXCEPTION(NotEnoughMemory); |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
234 } |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
235 else |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
236 { |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
237 memcpy(buffer_.data, buffer, size); |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
238 } |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
239 } |
3934
0b59e2706366
guard on SDK version in OrthancPlugins::MemoryBuffer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3930
diff
changeset
|
240 #endif |
3930
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
241 |
b99acc213937
transcoder plugins and GDCM transcoding are working
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3923
diff
changeset
|
242 |
3028 | 243 void MemoryBuffer::Clear() |
3026 | 244 { |
3028 | 245 if (buffer_.data != NULL) |
246 { | |
247 OrthancPluginFreeMemoryBuffer(GetGlobalContext(), &buffer_); | |
248 buffer_.data = NULL; | |
249 buffer_.size = 0; | |
250 } | |
3026 | 251 } |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
252 |
3026 | 253 |
3028 | 254 void MemoryBuffer::Assign(OrthancPluginMemoryBuffer& other) |
255 { | |
256 Clear(); | |
257 | |
258 buffer_.data = other.data; | |
259 buffer_.size = other.size; | |
260 | |
261 other.data = NULL; | |
262 other.size = 0; | |
263 } | |
3026 | 264 |
265 | |
3320 | 266 void MemoryBuffer::Swap(MemoryBuffer& other) |
267 { | |
268 std::swap(buffer_.data, other.buffer_.data); | |
269 std::swap(buffer_.size, other.buffer_.size); | |
270 } | |
271 | |
272 | |
3028 | 273 OrthancPluginMemoryBuffer MemoryBuffer::Release() |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
274 { |
3028 | 275 OrthancPluginMemoryBuffer result = buffer_; |
276 | |
3026 | 277 buffer_.data = NULL; |
278 buffer_.size = 0; | |
3028 | 279 |
280 return result; | |
3026 | 281 } |
3028 | 282 |
283 | |
284 void MemoryBuffer::ToString(std::string& target) const | |
285 { | |
286 if (buffer_.size == 0) | |
287 { | |
288 target.clear(); | |
289 } | |
290 else | |
291 { | |
292 target.assign(reinterpret_cast<const char*>(buffer_.data), buffer_.size); | |
293 } | |
294 } | |
3026 | 295 |
296 | |
3028 | 297 void MemoryBuffer::ToJson(Json::Value& target) const |
298 { | |
299 if (buffer_.data == NULL || | |
300 buffer_.size == 0) | |
301 { | |
302 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
303 } | |
3026 | 304 |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
305 if (!ReadJson(target, buffer_.data, buffer_.size)) |
3028 | 306 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
307 ORTHANC_PLUGINS_LOG_ERROR("Cannot convert some memory buffer to JSON"); |
3028 | 308 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
309 } | |
310 } | |
3026 | 311 |
312 | |
3028 | 313 bool MemoryBuffer::RestApiGet(const std::string& uri, |
314 bool applyPlugins) | |
3026 | 315 { |
3028 | 316 Clear(); |
3026 | 317 |
3028 | 318 if (applyPlugins) |
319 { | |
320 return CheckHttp(OrthancPluginRestApiGetAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str())); | |
321 } | |
322 else | |
323 { | |
324 return CheckHttp(OrthancPluginRestApiGet(GetGlobalContext(), &buffer_, uri.c_str())); | |
325 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
326 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
327 |
5049 | 328 // helper class to convert std::map of headers to the plugin SDK C structure |
329 class PluginHttpHeaders | |
330 { | |
5280 | 331 private: |
5049 | 332 std::vector<const char*> headersKeys_; |
333 std::vector<const char*> headersValues_; | |
5280 | 334 |
5049 | 335 public: |
5280 | 336 explicit PluginHttpHeaders(const std::map<std::string, std::string>& httpHeaders) |
5049 | 337 { |
338 for (std::map<std::string, std::string>::const_iterator | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
339 it = httpHeaders.begin(); it != httpHeaders.end(); ++it) |
5049 | 340 { |
341 headersKeys_.push_back(it->first.c_str()); | |
342 headersValues_.push_back(it->second.c_str()); | |
343 } | |
344 } | |
345 | |
346 const char* const* GetKeys() | |
347 { | |
348 return (headersKeys_.empty() ? NULL : &headersKeys_[0]); | |
349 } | |
350 | |
351 const char* const* GetValues() | |
352 { | |
353 return (headersValues_.empty() ? NULL : &headersValues_[0]); | |
354 } | |
355 | |
356 uint32_t GetSize() | |
357 { | |
358 return static_cast<uint32_t>(headersKeys_.size()); | |
359 } | |
360 }; | |
361 | |
3028 | 362 bool MemoryBuffer::RestApiGet(const std::string& uri, |
363 const std::map<std::string, std::string>& httpHeaders, | |
364 bool applyPlugins) | |
3026 | 365 { |
3028 | 366 Clear(); |
367 | |
5049 | 368 PluginHttpHeaders headers(httpHeaders); |
3028 | 369 |
3039 | 370 return CheckHttp(OrthancPluginRestApiGet2( |
5049 | 371 GetGlobalContext(), &buffer_, uri.c_str(), |
372 headers.GetSize(), | |
373 headers.GetKeys(), | |
374 headers.GetValues(), applyPlugins)); | |
3026 | 375 } |
3028 | 376 |
377 bool MemoryBuffer::RestApiPost(const std::string& uri, | |
3400
0faae6f6e3c5
fixed some inconsistencies with pointer types in the plugin sdk
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3399
diff
changeset
|
378 const void* body, |
3028 | 379 size_t bodySize, |
380 bool applyPlugins) | |
381 { | |
382 Clear(); | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
383 |
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
384 // Cast for compatibility with Orthanc SDK <= 1.5.6 |
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
385 const char* b = reinterpret_cast<const char*>(body); |
3028 | 386 |
387 if (applyPlugins) | |
388 { | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
389 return CheckHttp(OrthancPluginRestApiPostAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); |
3028 | 390 } |
391 else | |
392 { | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
393 return CheckHttp(OrthancPluginRestApiPost(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); |
3028 | 394 } |
395 } | |
3026 | 396 |
5049 | 397 #if HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API == 1 |
398 | |
399 bool MemoryBuffer::RestApiPost(const std::string& uri, | |
400 const void* body, | |
401 size_t bodySize, | |
402 const std::map<std::string, std::string>& httpHeaders, | |
403 bool applyPlugins) | |
404 { | |
405 MemoryBuffer answerHeaders; | |
406 uint16_t httpStatus; | |
407 | |
408 PluginHttpHeaders headers(httpHeaders); | |
409 | |
410 return CheckHttp(OrthancPluginCallRestApi(GetGlobalContext(), | |
411 &buffer_, | |
412 *answerHeaders, | |
413 &httpStatus, | |
414 OrthancPluginHttpMethod_Post, | |
415 uri.c_str(), | |
416 headers.GetSize(), headers.GetKeys(), headers.GetValues(), | |
417 body, bodySize, | |
418 applyPlugins)); | |
419 } | |
420 | |
421 | |
422 bool MemoryBuffer::RestApiPost(const std::string& uri, | |
423 const Json::Value& body, | |
424 const std::map<std::string, std::string>& httpHeaders, | |
425 bool applyPlugins) | |
426 { | |
427 std::string s; | |
428 WriteFastJson(s, body); | |
429 return RestApiPost(uri, s.c_str(), s.size(), httpHeaders, applyPlugins); | |
430 } | |
431 #endif | |
3026 | 432 |
3028 | 433 bool MemoryBuffer::RestApiPut(const std::string& uri, |
3400
0faae6f6e3c5
fixed some inconsistencies with pointer types in the plugin sdk
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3399
diff
changeset
|
434 const void* body, |
3028 | 435 size_t bodySize, |
436 bool applyPlugins) | |
437 { | |
438 Clear(); | |
3026 | 439 |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
440 // Cast for compatibility with Orthanc SDK <= 1.5.6 |
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
441 const char* b = reinterpret_cast<const char*>(body); |
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
442 |
3028 | 443 if (applyPlugins) |
444 { | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
445 return CheckHttp(OrthancPluginRestApiPutAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); |
3028 | 446 } |
447 else | |
448 { | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
449 return CheckHttp(OrthancPluginRestApiPut(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); |
3028 | 450 } |
3026 | 451 } |
3028 | 452 |
3026 | 453 |
4444
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
454 static bool ReadJsonInternal(Json::Value& target, |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
455 const void* buffer, |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
456 size_t size, |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
457 bool collectComments) |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
458 { |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
459 #if JSONCPP_USE_DEPRECATED == 1 |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
460 Json::Reader reader; |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
461 return reader.parse(reinterpret_cast<const char*>(buffer), |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
462 reinterpret_cast<const char*>(buffer) + size, target, collectComments); |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
463 #else |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
464 Json::CharReaderBuilder builder; |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
465 builder.settings_["collectComments"] = collectComments; |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
466 |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
467 const std::unique_ptr<Json::CharReader> reader(builder.newCharReader()); |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
468 assert(reader.get() != NULL); |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
469 |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
470 JSONCPP_STRING err; |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
471 if (reader->parse(reinterpret_cast<const char*>(buffer), |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
472 reinterpret_cast<const char*>(buffer) + size, &target, &err)) |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
473 { |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
474 return true; |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
475 } |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
476 else |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
477 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
478 ORTHANC_PLUGINS_LOG_ERROR("Cannot parse JSON: " + std::string(err)); |
4444
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
479 return false; |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
480 } |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
481 #endif |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
482 } |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
483 |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
484 |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
485 bool ReadJson(Json::Value& target, |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
486 const std::string& source) |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
487 { |
4397
3aeb5171fbd4
new function Toolbox::ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4396
diff
changeset
|
488 return ReadJson(target, source.empty() ? NULL : source.c_str(), source.size()); |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
489 } |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
490 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
491 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
492 bool ReadJson(Json::Value& target, |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
493 const void* buffer, |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
494 size_t size) |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
495 { |
4444
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
496 return ReadJsonInternal(target, buffer, size, true); |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
497 } |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
498 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
499 |
4444
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
500 bool ReadJsonWithoutComments(Json::Value& target, |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
501 const std::string& source) |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
502 { |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
503 return ReadJsonWithoutComments(target, source.empty() ? NULL : source.c_str(), source.size()); |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
504 } |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
505 |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
506 |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
507 bool ReadJsonWithoutComments(Json::Value& target, |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
508 const void* buffer, |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
509 size_t size) |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
510 { |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
511 return ReadJsonInternal(target, buffer, size, false); |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
512 } |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
513 |
11ea0a05115b
new function in OrthancPluginCppWrapper: ReadJsonWithoutComments()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
514 |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
515 void WriteFastJson(std::string& target, |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
516 const Json::Value& source) |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
517 { |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
518 #if JSONCPP_USE_DEPRECATED == 1 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
519 Json::FastWriter writer; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
520 target = writer.write(source); |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
521 #else |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
522 Json::StreamWriterBuilder builder; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
523 builder.settings_["indentation"] = ""; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
524 target = Json::writeString(builder, source); |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
525 #endif |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
526 } |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
527 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
528 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
529 void WriteStyledJson(std::string& target, |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
530 const Json::Value& source) |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
531 { |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
532 #if JSONCPP_USE_DEPRECATED == 1 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
533 Json::StyledWriter writer; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
534 target = writer.write(source); |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
535 #else |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
536 Json::StreamWriterBuilder builder; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
537 builder.settings_["indentation"] = " "; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
538 target = Json::writeString(builder, source); |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
539 #endif |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
540 } |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
541 |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
542 |
3028 | 543 bool MemoryBuffer::RestApiPost(const std::string& uri, |
544 const Json::Value& body, | |
545 bool applyPlugins) | |
3026 | 546 { |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
547 std::string s; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
548 WriteFastJson(s, body); |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
549 return RestApiPost(uri, s, applyPlugins); |
3026 | 550 } |
551 | |
3028 | 552 |
553 bool MemoryBuffer::RestApiPut(const std::string& uri, | |
554 const Json::Value& body, | |
555 bool applyPlugins) | |
556 { | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
557 std::string s; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
558 WriteFastJson(s, body); |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
559 return RestApiPut(uri, s, applyPlugins); |
3028 | 560 } |
3026 | 561 |
3028 | 562 |
563 void MemoryBuffer::CreateDicom(const Json::Value& tags, | |
564 OrthancPluginCreateDicomFlags flags) | |
565 { | |
566 Clear(); | |
567 | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
568 std::string s; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
569 WriteFastJson(s, tags); |
3026 | 570 |
3028 | 571 Check(OrthancPluginCreateDicom(GetGlobalContext(), &buffer_, s.c_str(), NULL, flags)); |
3026 | 572 } |
3028 | 573 |
574 void MemoryBuffer::CreateDicom(const Json::Value& tags, | |
575 const OrthancImage& pixelData, | |
576 OrthancPluginCreateDicomFlags flags) | |
3026 | 577 { |
3028 | 578 Clear(); |
579 | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
580 std::string s; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
581 WriteFastJson(s, tags); |
3028 | 582 |
583 Check(OrthancPluginCreateDicom(GetGlobalContext(), &buffer_, s.c_str(), pixelData.GetObject(), flags)); | |
3026 | 584 } |
3028 | 585 |
586 | |
587 void MemoryBuffer::ReadFile(const std::string& path) | |
588 { | |
589 Clear(); | |
590 Check(OrthancPluginReadFile(GetGlobalContext(), &buffer_, path.c_str())); | |
591 } | |
3026 | 592 |
593 | |
3028 | 594 void MemoryBuffer::GetDicomQuery(const OrthancPluginWorklistQuery* query) |
3026 | 595 { |
3028 | 596 Clear(); |
597 Check(OrthancPluginWorklistGetDicomQuery(GetGlobalContext(), &buffer_, query)); | |
3026 | 598 } |
599 | |
600 | |
3028 | 601 void OrthancString::Assign(char* str) |
602 { | |
3440 | 603 Clear(); |
604 | |
605 if (str != NULL) | |
3028 | 606 { |
607 str_ = str; | |
608 } | |
609 } | |
3026 | 610 |
611 | |
3028 | 612 void OrthancString::Clear() |
613 { | |
614 if (str_ != NULL) | |
615 { | |
616 OrthancPluginFreeString(GetGlobalContext(), str_); | |
617 str_ = NULL; | |
618 } | |
619 } | |
3026 | 620 |
621 | |
3028 | 622 void OrthancString::ToString(std::string& target) const |
623 { | |
624 if (str_ == NULL) | |
625 { | |
626 target.clear(); | |
627 } | |
628 else | |
629 { | |
630 target.assign(str_); | |
631 } | |
632 } | |
3026 | 633 |
634 | |
3028 | 635 void OrthancString::ToJson(Json::Value& target) const |
636 { | |
637 if (str_ == NULL) | |
638 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
639 ORTHANC_PLUGINS_LOG_ERROR("Cannot convert an empty memory buffer to JSON"); |
3028 | 640 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
641 } | |
642 | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
643 if (!ReadJson(target, str_)) |
3028 | 644 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
645 ORTHANC_PLUGINS_LOG_ERROR("Cannot convert some memory buffer to JSON"); |
3028 | 646 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
647 } | |
648 } | |
3026 | 649 |
650 | |
4925
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
651 void OrthancString::ToJsonWithoutComments(Json::Value& target) const |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
652 { |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
653 if (str_ == NULL) |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
654 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
655 ORTHANC_PLUGINS_LOG_ERROR("Cannot convert an empty memory buffer to JSON"); |
4925
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
656 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
657 } |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
658 |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
659 if (!ReadJsonWithoutComments(target, str_)) |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
660 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
661 ORTHANC_PLUGINS_LOG_ERROR("Cannot convert some memory buffer to JSON"); |
4925
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
662 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
663 } |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
664 } |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
665 |
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
666 |
3028 | 667 void MemoryBuffer::DicomToJson(Json::Value& target, |
668 OrthancPluginDicomToJsonFormat format, | |
669 OrthancPluginDicomToJsonFlags flags, | |
670 uint32_t maxStringLength) | |
671 { | |
672 OrthancString str; | |
673 str.Assign(OrthancPluginDicomBufferToJson | |
674 (GetGlobalContext(), GetData(), GetSize(), format, flags, maxStringLength)); | |
675 str.ToJson(target); | |
676 } | |
3026 | 677 |
678 | |
3028 | 679 bool MemoryBuffer::HttpGet(const std::string& url, |
680 const std::string& username, | |
681 const std::string& password) | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
682 { |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
683 Clear(); |
3028 | 684 return CheckHttp(OrthancPluginHttpGet(GetGlobalContext(), &buffer_, url.c_str(), |
685 username.empty() ? NULL : username.c_str(), | |
686 password.empty() ? NULL : password.c_str())); | |
3026 | 687 } |
688 | |
689 | |
3028 | 690 bool MemoryBuffer::HttpPost(const std::string& url, |
691 const std::string& body, | |
692 const std::string& username, | |
693 const std::string& password) | |
3026 | 694 { |
3028 | 695 Clear(); |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
696 |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
697 if (body.size() > 0xffffffffu) |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
698 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
699 ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
700 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
701 } |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
702 |
3028 | 703 return CheckHttp(OrthancPluginHttpPost(GetGlobalContext(), &buffer_, url.c_str(), |
704 body.c_str(), body.size(), | |
705 username.empty() ? NULL : username.c_str(), | |
706 password.empty() ? NULL : password.c_str())); | |
3026 | 707 } |
708 | |
709 | |
3028 | 710 bool MemoryBuffer::HttpPut(const std::string& url, |
711 const std::string& body, | |
712 const std::string& username, | |
713 const std::string& password) | |
3026 | 714 { |
3028 | 715 Clear(); |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
716 |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
717 if (body.size() > 0xffffffffu) |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
718 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
719 ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
720 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
721 } |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
722 |
3028 | 723 return CheckHttp(OrthancPluginHttpPut(GetGlobalContext(), &buffer_, url.c_str(), |
724 body.empty() ? NULL : body.c_str(), | |
725 body.size(), | |
726 username.empty() ? NULL : username.c_str(), | |
727 password.empty() ? NULL : password.c_str())); | |
3026 | 728 } |
729 | |
3028 | 730 |
731 void MemoryBuffer::GetDicomInstance(const std::string& instanceId) | |
3026 | 732 { |
3028 | 733 Clear(); |
734 Check(OrthancPluginGetDicomForInstance(GetGlobalContext(), &buffer_, instanceId.c_str())); | |
3026 | 735 } |
736 | |
737 | |
3028 | 738 bool HttpDelete(const std::string& url, |
739 const std::string& username, | |
740 const std::string& password) | |
741 { | |
742 OrthancPluginErrorCode error = OrthancPluginHttpDelete | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
743 (GetGlobalContext(), url.c_str(), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
744 username.empty() ? NULL : username.c_str(), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
745 password.empty() ? NULL : password.c_str()); |
3028 | 746 |
747 if (error == OrthancPluginErrorCode_Success) | |
748 { | |
749 return true; | |
750 } | |
751 else if (error == OrthancPluginErrorCode_UnknownResource || | |
752 error == OrthancPluginErrorCode_InexistentItem) | |
753 { | |
754 return false; | |
755 } | |
756 else | |
757 { | |
758 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); | |
759 } | |
760 } | |
3026 | 761 |
3421
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
762 void OrthancConfiguration::LoadConfiguration() |
3028 | 763 { |
764 OrthancString str; | |
765 str.Assign(OrthancPluginGetConfiguration(GetGlobalContext())); | |
3026 | 766 |
3028 | 767 if (str.GetContent() == NULL) |
768 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
769 ORTHANC_PLUGINS_LOG_ERROR("Cannot access the Orthanc configuration"); |
3028 | 770 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
771 } | |
3026 | 772 |
4925
8785d8442f90
skip json comments when loading config
Alain Mazy <am@osimis.io>
parents:
4870
diff
changeset
|
773 str.ToJsonWithoutComments(configuration_); |
3028 | 774 |
775 if (configuration_.type() != Json::objectValue) | |
776 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
777 ORTHANC_PLUGINS_LOG_ERROR("Unable to read the Orthanc configuration"); |
3028 | 778 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
779 } | |
780 } | |
3421
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
781 |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
782 |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
783 OrthancConfiguration::OrthancConfiguration() |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
784 { |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
785 LoadConfiguration(); |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
786 } |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
787 |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
788 |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
789 OrthancConfiguration::OrthancConfiguration(bool loadConfiguration) |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
790 { |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
791 if (loadConfiguration) |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
792 { |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
793 LoadConfiguration(); |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
794 } |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
795 else |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
796 { |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
797 configuration_ = Json::objectValue; |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
798 } |
decbede6e3ad
OrthancPlugins::OrthancConfiguration(bool)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
799 } |
3026 | 800 |
5168
688b83f915bc
new OrthancConfiguration ctor in c++ wrapper
Alain Mazy <am@osimis.io>
parents:
5138
diff
changeset
|
801 OrthancConfiguration::OrthancConfiguration(const Json::Value& configuration, const std::string& path) : |
688b83f915bc
new OrthancConfiguration ctor in c++ wrapper
Alain Mazy <am@osimis.io>
parents:
5138
diff
changeset
|
802 configuration_(configuration), |
688b83f915bc
new OrthancConfiguration ctor in c++ wrapper
Alain Mazy <am@osimis.io>
parents:
5138
diff
changeset
|
803 path_(path) |
688b83f915bc
new OrthancConfiguration ctor in c++ wrapper
Alain Mazy <am@osimis.io>
parents:
5138
diff
changeset
|
804 { |
688b83f915bc
new OrthancConfiguration ctor in c++ wrapper
Alain Mazy <am@osimis.io>
parents:
5138
diff
changeset
|
805 } |
688b83f915bc
new OrthancConfiguration ctor in c++ wrapper
Alain Mazy <am@osimis.io>
parents:
5138
diff
changeset
|
806 |
3026 | 807 |
3028 | 808 std::string OrthancConfiguration::GetPath(const std::string& key) const |
3026 | 809 { |
3028 | 810 if (path_.empty()) |
811 { | |
812 return key; | |
813 } | |
814 else | |
815 { | |
816 return path_ + "." + key; | |
817 } | |
3026 | 818 } |
3028 | 819 |
820 | |
821 bool OrthancConfiguration::IsSection(const std::string& key) const | |
3026 | 822 { |
3028 | 823 assert(configuration_.type() == Json::objectValue); |
824 | |
825 return (configuration_.isMember(key) && | |
826 configuration_[key].type() == Json::objectValue); | |
3026 | 827 } |
828 | |
829 | |
3028 | 830 void OrthancConfiguration::GetSection(OrthancConfiguration& target, |
831 const std::string& key) const | |
3026 | 832 { |
3028 | 833 assert(configuration_.type() == Json::objectValue); |
3026 | 834 |
3028 | 835 target.path_ = GetPath(key); |
3026 | 836 |
3028 | 837 if (!configuration_.isMember(key)) |
838 { | |
839 target.configuration_ = Json::objectValue; | |
840 } | |
841 else | |
842 { | |
843 if (configuration_[key].type() != Json::objectValue) | |
844 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
845 ORTHANC_PLUGINS_LOG_ERROR("The configuration section \"" + target.path_ + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
846 "\" is not an associative array as expected"); |
3028 | 847 |
848 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
849 } | |
850 | |
851 target.configuration_ = configuration_[key]; | |
852 } | |
3026 | 853 } |
854 | |
855 | |
3028 | 856 bool OrthancConfiguration::LookupStringValue(std::string& target, |
857 const std::string& key) const | |
858 { | |
859 assert(configuration_.type() == Json::objectValue); | |
860 | |
861 if (!configuration_.isMember(key)) | |
862 { | |
863 return false; | |
864 } | |
3026 | 865 |
3028 | 866 if (configuration_[key].type() != Json::stringValue) |
867 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
868 ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
869 "\" is not a string as expected"); |
3028 | 870 |
871 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
872 } | |
873 | |
874 target = configuration_[key].asString(); | |
875 return true; | |
3026 | 876 } |
877 | |
878 | |
3028 | 879 bool OrthancConfiguration::LookupIntegerValue(int& target, |
880 const std::string& key) const | |
3026 | 881 { |
3028 | 882 assert(configuration_.type() == Json::objectValue); |
883 | |
884 if (!configuration_.isMember(key)) | |
885 { | |
886 return false; | |
887 } | |
888 | |
889 switch (configuration_[key].type()) | |
890 { | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
891 case Json::intValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
892 target = configuration_[key].asInt(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
893 return true; |
3028 | 894 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
895 case Json::uintValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
896 target = configuration_[key].asUInt(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
897 return true; |
3028 | 898 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
899 default: |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
900 ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
901 "\" is not an integer as expected"); |
3028 | 902 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
903 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
3028 | 904 } |
3026 | 905 } |
906 | |
907 | |
3028 | 908 bool OrthancConfiguration::LookupUnsignedIntegerValue(unsigned int& target, |
909 const std::string& key) const | |
910 { | |
911 int tmp; | |
912 if (!LookupIntegerValue(tmp, key)) | |
913 { | |
914 return false; | |
915 } | |
3026 | 916 |
3028 | 917 if (tmp < 0) |
918 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
919 ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
920 "\" is not a positive integer as expected"); |
3028 | 921 |
922 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
923 } | |
924 else | |
925 { | |
926 target = static_cast<unsigned int>(tmp); | |
927 return true; | |
928 } | |
929 } | |
3026 | 930 |
931 | |
3028 | 932 bool OrthancConfiguration::LookupBooleanValue(bool& target, |
933 const std::string& key) const | |
3026 | 934 { |
3028 | 935 assert(configuration_.type() == Json::objectValue); |
936 | |
937 if (!configuration_.isMember(key)) | |
3026 | 938 { |
3028 | 939 return false; |
940 } | |
941 | |
942 if (configuration_[key].type() != Json::booleanValue) | |
943 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
944 ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
945 "\" is not a Boolean as expected"); |
3026 | 946 |
947 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
948 } | |
949 | |
3028 | 950 target = configuration_[key].asBool(); |
951 return true; | |
3026 | 952 } |
3028 | 953 |
954 | |
955 bool OrthancConfiguration::LookupFloatValue(float& target, | |
956 const std::string& key) const | |
957 { | |
958 assert(configuration_.type() == Json::objectValue); | |
959 | |
960 if (!configuration_.isMember(key)) | |
961 { | |
962 return false; | |
963 } | |
964 | |
965 switch (configuration_[key].type()) | |
966 { | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
967 case Json::realValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
968 target = configuration_[key].asFloat(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
969 return true; |
3028 | 970 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
971 case Json::intValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
972 target = static_cast<float>(configuration_[key].asInt()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
973 return true; |
3028 | 974 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
975 case Json::uintValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
976 target = static_cast<float>(configuration_[key].asUInt()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
977 return true; |
3028 | 978 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
979 default: |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
980 ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
981 "\" is not an integer as expected"); |
3028 | 982 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
983 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
3028 | 984 } |
985 } | |
3026 | 986 |
987 | |
3028 | 988 bool OrthancConfiguration::LookupListOfStrings(std::list<std::string>& target, |
989 const std::string& key, | |
990 bool allowSingleString) const | |
3026 | 991 { |
3028 | 992 assert(configuration_.type() == Json::objectValue); |
993 | |
994 target.clear(); | |
995 | |
996 if (!configuration_.isMember(key)) | |
997 { | |
998 return false; | |
999 } | |
1000 | |
1001 switch (configuration_[key].type()) | |
1002 { | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1003 case Json::arrayValue: |
3028 | 1004 { |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1005 bool ok = true; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1006 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1007 for (Json::Value::ArrayIndex i = 0; ok && i < configuration_[key].size(); i++) |
3028 | 1008 { |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1009 if (configuration_[key][i].type() == Json::stringValue) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1010 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1011 target.push_back(configuration_[key][i].asString()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1012 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1013 else |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1014 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1015 ok = false; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1016 } |
3028 | 1017 } |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1018 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1019 if (ok) |
3028 | 1020 { |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1021 return true; |
3028 | 1022 } |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1023 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1024 break; |
3028 | 1025 } |
1026 | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1027 case Json::stringValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1028 if (allowSingleString) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1029 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1030 target.push_back(configuration_[key].asString()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1031 return true; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1032 } |
3028 | 1033 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1034 break; |
3028 | 1035 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1036 default: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1037 break; |
3028 | 1038 } |
1039 | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1040 ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1041 "\" is not a list of strings as expected"); |
3026 | 1042 |
1043 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
1044 } | |
1045 | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1046 |
3028 | 1047 bool OrthancConfiguration::LookupSetOfStrings(std::set<std::string>& target, |
1048 const std::string& key, | |
1049 bool allowSingleString) const | |
1050 { | |
1051 std::list<std::string> lst; | |
1052 | |
1053 if (LookupListOfStrings(lst, key, allowSingleString)) | |
1054 { | |
1055 target.clear(); | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1056 |
3028 | 1057 for (std::list<std::string>::const_iterator |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1058 it = lst.begin(); it != lst.end(); ++it) |
3028 | 1059 { |
1060 target.insert(*it); | |
1061 } | |
3026 | 1062 |
3028 | 1063 return true; |
1064 } | |
1065 else | |
1066 { | |
1067 return false; | |
1068 } | |
3026 | 1069 } |
1070 | |
3028 | 1071 |
1072 std::string OrthancConfiguration::GetStringValue(const std::string& key, | |
1073 const std::string& defaultValue) const | |
3026 | 1074 { |
3028 | 1075 std::string tmp; |
1076 if (LookupStringValue(tmp, key)) | |
1077 { | |
1078 return tmp; | |
1079 } | |
1080 else | |
1081 { | |
1082 return defaultValue; | |
1083 } | |
3026 | 1084 } |
1085 | |
1086 | |
3028 | 1087 int OrthancConfiguration::GetIntegerValue(const std::string& key, |
1088 int defaultValue) const | |
3026 | 1089 { |
3028 | 1090 int tmp; |
1091 if (LookupIntegerValue(tmp, key)) | |
1092 { | |
1093 return tmp; | |
1094 } | |
1095 else | |
1096 { | |
1097 return defaultValue; | |
1098 } | |
3026 | 1099 } |
1100 | |
3028 | 1101 |
1102 unsigned int OrthancConfiguration::GetUnsignedIntegerValue(const std::string& key, | |
1103 unsigned int defaultValue) const | |
3026 | 1104 { |
3028 | 1105 unsigned int tmp; |
1106 if (LookupUnsignedIntegerValue(tmp, key)) | |
1107 { | |
1108 return tmp; | |
1109 } | |
1110 else | |
1111 { | |
1112 return defaultValue; | |
1113 } | |
3026 | 1114 } |
2792
57e2d65d37ce
OrthancPlugins::MemoryBuffer::Release(), fixing openssl link
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1115 |
3026 | 1116 |
3028 | 1117 bool OrthancConfiguration::GetBooleanValue(const std::string& key, |
1118 bool defaultValue) const | |
3026 | 1119 { |
3028 | 1120 bool tmp; |
1121 if (LookupBooleanValue(tmp, key)) | |
1122 { | |
1123 return tmp; | |
1124 } | |
1125 else | |
1126 { | |
1127 return defaultValue; | |
1128 } | |
3026 | 1129 } |
1130 | |
3028 | 1131 |
1132 float OrthancConfiguration::GetFloatValue(const std::string& key, | |
1133 float defaultValue) const | |
3026 | 1134 { |
3028 | 1135 float tmp; |
1136 if (LookupFloatValue(tmp, key)) | |
1137 { | |
1138 return tmp; | |
1139 } | |
1140 else | |
1141 { | |
1142 return defaultValue; | |
1143 } | |
3026 | 1144 } |
1145 | |
1146 | |
3028 | 1147 void OrthancConfiguration::GetDictionary(std::map<std::string, std::string>& target, |
1148 const std::string& key) const | |
3026 | 1149 { |
3028 | 1150 assert(configuration_.type() == Json::objectValue); |
1151 | |
1152 target.clear(); | |
1153 | |
1154 if (!configuration_.isMember(key)) | |
1155 { | |
1156 return; | |
1157 } | |
3026 | 1158 |
3028 | 1159 if (configuration_[key].type() != Json::objectValue) |
1160 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1161 ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1162 "\" is not an object as expected"); |
3028 | 1163 |
1164 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
1165 } | |
3026 | 1166 |
3028 | 1167 Json::Value::Members members = configuration_[key].getMemberNames(); |
1168 | |
1169 for (size_t i = 0; i < members.size(); i++) | |
3026 | 1170 { |
3028 | 1171 const Json::Value& value = configuration_[key][members[i]]; |
1172 | |
1173 if (value.type() == Json::stringValue) | |
3026 | 1174 { |
3028 | 1175 target[members[i]] = value.asString(); |
3026 | 1176 } |
1177 else | |
1178 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1179 ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1180 "\" is not a dictionary mapping strings to strings"); |
3028 | 1181 |
1182 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
3026 | 1183 } |
1184 } | |
3028 | 1185 } |
3026 | 1186 |
3028 | 1187 |
1188 void OrthancImage::Clear() | |
1189 { | |
1190 if (image_ != NULL) | |
1191 { | |
1192 OrthancPluginFreeImage(GetGlobalContext(), image_); | |
1193 image_ = NULL; | |
1194 } | |
1195 } | |
1196 | |
1197 | |
3236 | 1198 void OrthancImage::CheckImageAvailable() const |
3028 | 1199 { |
1200 if (image_ == NULL) | |
1201 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1202 ORTHANC_PLUGINS_LOG_ERROR("Trying to access a NULL image"); |
3028 | 1203 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); |
1204 } | |
1205 } | |
1206 | |
1207 | |
1208 OrthancImage::OrthancImage() : | |
1209 image_(NULL) | |
1210 { | |
1211 } | |
1212 | |
1213 | |
1214 OrthancImage::OrthancImage(OrthancPluginImage* image) : | |
1215 image_(image) | |
1216 { | |
1217 } | |
1218 | |
1219 | |
1220 OrthancImage::OrthancImage(OrthancPluginPixelFormat format, | |
1221 uint32_t width, | |
1222 uint32_t height) | |
1223 { | |
1224 image_ = OrthancPluginCreateImage(GetGlobalContext(), format, width, height); | |
1225 | |
1226 if (image_ == NULL) | |
1227 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1228 ORTHANC_PLUGINS_LOG_ERROR("Cannot create an image"); |
3028 | 1229 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
1230 } | |
1231 } | |
1232 | |
1233 | |
1234 OrthancImage::OrthancImage(OrthancPluginPixelFormat format, | |
1235 uint32_t width, | |
1236 uint32_t height, | |
1237 uint32_t pitch, | |
1238 void* buffer) | |
1239 { | |
1240 image_ = OrthancPluginCreateImageAccessor | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1241 (GetGlobalContext(), format, width, height, pitch, buffer); |
3028 | 1242 |
1243 if (image_ == NULL) | |
1244 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1245 ORTHANC_PLUGINS_LOG_ERROR("Cannot create an image accessor"); |
3028 | 1246 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
1247 } | |
1248 } | |
1249 | |
1250 void OrthancImage::UncompressPngImage(const void* data, | |
1251 size_t size) | |
1252 { | |
1253 Clear(); | |
1254 | |
1255 image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Png); | |
1256 | |
1257 if (image_ == NULL) | |
1258 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1259 ORTHANC_PLUGINS_LOG_ERROR("Cannot uncompress a PNG image"); |
3028 | 1260 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); |
1261 } | |
1262 } | |
1263 | |
1264 | |
1265 void OrthancImage::UncompressJpegImage(const void* data, | |
1266 size_t size) | |
1267 { | |
1268 Clear(); | |
1269 image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Jpeg); | |
1270 if (image_ == NULL) | |
1271 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1272 ORTHANC_PLUGINS_LOG_ERROR("Cannot uncompress a JPEG image"); |
3028 | 1273 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); |
1274 } | |
1275 } | |
1276 | |
1277 | |
1278 void OrthancImage::DecodeDicomImage(const void* data, | |
1279 size_t size, | |
1280 unsigned int frame) | |
1281 { | |
1282 Clear(); | |
1283 image_ = OrthancPluginDecodeDicomImage(GetGlobalContext(), data, size, frame); | |
1284 if (image_ == NULL) | |
1285 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1286 ORTHANC_PLUGINS_LOG_ERROR("Cannot uncompress a DICOM image"); |
3028 | 1287 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); |
1288 } | |
1289 } | |
1290 | |
1291 | |
3236 | 1292 OrthancPluginPixelFormat OrthancImage::GetPixelFormat() const |
3028 | 1293 { |
1294 CheckImageAvailable(); | |
1295 return OrthancPluginGetImagePixelFormat(GetGlobalContext(), image_); | |
1296 } | |
1297 | |
1298 | |
3236 | 1299 unsigned int OrthancImage::GetWidth() const |
3028 | 1300 { |
1301 CheckImageAvailable(); | |
1302 return OrthancPluginGetImageWidth(GetGlobalContext(), image_); | |
1303 } | |
1304 | |
1305 | |
3236 | 1306 unsigned int OrthancImage::GetHeight() const |
3028 | 1307 { |
1308 CheckImageAvailable(); | |
1309 return OrthancPluginGetImageHeight(GetGlobalContext(), image_); | |
1310 } | |
1311 | |
1312 | |
3236 | 1313 unsigned int OrthancImage::GetPitch() const |
3028 | 1314 { |
1315 CheckImageAvailable(); | |
1316 return OrthancPluginGetImagePitch(GetGlobalContext(), image_); | |
1317 } | |
1318 | |
1319 | |
3915
7e33516965f8
merging sample GDCM decoder and Orthanc Web viewer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3752
diff
changeset
|
1320 void* OrthancImage::GetBuffer() const |
3028 | 1321 { |
1322 CheckImageAvailable(); | |
1323 return OrthancPluginGetImageBuffer(GetGlobalContext(), image_); | |
1324 } | |
1325 | |
1326 | |
3236 | 1327 void OrthancImage::CompressPngImage(MemoryBuffer& target) const |
3028 | 1328 { |
1329 CheckImageAvailable(); | |
1330 | |
3320 | 1331 OrthancPlugins::MemoryBuffer answer; |
1332 OrthancPluginCompressPngImage(GetGlobalContext(), *answer, GetPixelFormat(), | |
3028 | 1333 GetWidth(), GetHeight(), GetPitch(), GetBuffer()); |
1334 | |
3320 | 1335 target.Swap(answer); |
3028 | 1336 } |
1337 | |
1338 | |
1339 void OrthancImage::CompressJpegImage(MemoryBuffer& target, | |
3236 | 1340 uint8_t quality) const |
3028 | 1341 { |
1342 CheckImageAvailable(); | |
1343 | |
3320 | 1344 OrthancPlugins::MemoryBuffer answer; |
1345 OrthancPluginCompressJpegImage(GetGlobalContext(), *answer, GetPixelFormat(), | |
3028 | 1346 GetWidth(), GetHeight(), GetPitch(), GetBuffer(), quality); |
1347 | |
3320 | 1348 target.Swap(answer); |
3028 | 1349 } |
1350 | |
1351 | |
3236 | 1352 void OrthancImage::AnswerPngImage(OrthancPluginRestOutput* output) const |
3028 | 1353 { |
1354 CheckImageAvailable(); | |
1355 OrthancPluginCompressAndAnswerPngImage(GetGlobalContext(), output, GetPixelFormat(), | |
1356 GetWidth(), GetHeight(), GetPitch(), GetBuffer()); | |
1357 } | |
1358 | |
1359 | |
1360 void OrthancImage::AnswerJpegImage(OrthancPluginRestOutput* output, | |
3236 | 1361 uint8_t quality) const |
3028 | 1362 { |
1363 CheckImageAvailable(); | |
1364 OrthancPluginCompressAndAnswerJpegImage(GetGlobalContext(), output, GetPixelFormat(), | |
1365 GetWidth(), GetHeight(), GetPitch(), GetBuffer(), quality); | |
1366 } | |
1367 | |
1368 | |
3915
7e33516965f8
merging sample GDCM decoder and Orthanc Web viewer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3752
diff
changeset
|
1369 OrthancPluginImage* OrthancImage::Release() |
7e33516965f8
merging sample GDCM decoder and Orthanc Web viewer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3752
diff
changeset
|
1370 { |
7e33516965f8
merging sample GDCM decoder and Orthanc Web viewer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3752
diff
changeset
|
1371 CheckImageAvailable(); |
7e33516965f8
merging sample GDCM decoder and Orthanc Web viewer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3752
diff
changeset
|
1372 OrthancPluginImage* tmp = image_; |
7e33516965f8
merging sample GDCM decoder and Orthanc Web viewer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3752
diff
changeset
|
1373 image_ = NULL; |
7e33516965f8
merging sample GDCM decoder and Orthanc Web viewer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3752
diff
changeset
|
1374 return tmp; |
7e33516965f8
merging sample GDCM decoder and Orthanc Web viewer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3752
diff
changeset
|
1375 } |
7e33516965f8
merging sample GDCM decoder and Orthanc Web viewer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3752
diff
changeset
|
1376 |
3028 | 1377 |
1378 #if HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 | |
1379 FindMatcher::FindMatcher(const OrthancPluginWorklistQuery* worklist) : | |
1380 matcher_(NULL), | |
1381 worklist_(worklist) | |
1382 { | |
1383 if (worklist_ == NULL) | |
1384 { | |
1385 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); | |
1386 } | |
1387 } | |
1388 | |
1389 | |
1390 void FindMatcher::SetupDicom(const void* query, | |
1391 uint32_t size) | |
1392 { | |
1393 worklist_ = NULL; | |
1394 | |
1395 matcher_ = OrthancPluginCreateFindMatcher(GetGlobalContext(), query, size); | |
1396 if (matcher_ == NULL) | |
1397 { | |
1398 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
1399 } | |
1400 } | |
1401 | |
1402 | |
1403 FindMatcher::~FindMatcher() | |
1404 { | |
1405 // The "worklist_" field | |
1406 | |
1407 if (matcher_ != NULL) | |
1408 { | |
1409 OrthancPluginFreeFindMatcher(GetGlobalContext(), matcher_); | |
1410 } | |
1411 } | |
1412 | |
1413 | |
1414 | |
1415 bool FindMatcher::IsMatch(const void* dicom, | |
1416 uint32_t size) const | |
1417 { | |
1418 int32_t result; | |
1419 | |
1420 if (matcher_ != NULL) | |
1421 { | |
1422 result = OrthancPluginFindMatcherIsMatch(GetGlobalContext(), matcher_, dicom, size); | |
1423 } | |
1424 else if (worklist_ != NULL) | |
1425 { | |
1426 result = OrthancPluginWorklistIsMatch(GetGlobalContext(), worklist_, dicom, size); | |
1427 } | |
1428 else | |
1429 { | |
1430 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
1431 } | |
1432 | |
1433 if (result == 0) | |
1434 { | |
1435 return false; | |
1436 } | |
1437 else if (result == 1) | |
1438 { | |
1439 return true; | |
1440 } | |
1441 else | |
1442 { | |
1443 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
1444 } | |
1445 } | |
1446 | |
1447 #endif /* HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 */ | |
1448 | |
1449 void AnswerJson(const Json::Value& value, | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1450 OrthancPluginRestOutput* output) |
3028 | 1451 { |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1452 std::string bodyString; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1453 WriteStyledJson(bodyString, value); |
3028 | 1454 OrthancPluginAnswerBuffer(GetGlobalContext(), output, bodyString.c_str(), bodyString.size(), "application/json"); |
1455 } | |
1456 | |
1457 void AnswerString(const std::string& answer, | |
1458 const char* mimeType, | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1459 OrthancPluginRestOutput* output) |
3028 | 1460 { |
1461 OrthancPluginAnswerBuffer(GetGlobalContext(), output, answer.c_str(), answer.size(), mimeType); | |
1462 } | |
1463 | |
1464 void AnswerHttpError(uint16_t httpError, OrthancPluginRestOutput *output) | |
1465 { | |
1466 OrthancPluginSendHttpStatusCode(GetGlobalContext(), output, httpError); | |
1467 } | |
1468 | |
1469 void AnswerMethodNotAllowed(OrthancPluginRestOutput *output, const char* allowedMethods) | |
1470 { | |
1471 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowedMethods); | |
1472 } | |
1473 | |
1474 bool RestApiGetString(std::string& result, | |
1475 const std::string& uri, | |
1476 bool applyPlugins) | |
1477 { | |
1478 MemoryBuffer answer; | |
1479 if (!answer.RestApiGet(uri, applyPlugins)) | |
1480 { | |
1481 return false; | |
1482 } | |
1483 else | |
1484 { | |
1485 answer.ToString(result); | |
1486 return true; | |
1487 } | |
1488 } | |
1489 | |
1490 bool RestApiGetString(std::string& result, | |
1491 const std::string& uri, | |
1492 const std::map<std::string, std::string>& httpHeaders, | |
1493 bool applyPlugins) | |
1494 { | |
1495 MemoryBuffer answer; | |
1496 if (!answer.RestApiGet(uri, httpHeaders, applyPlugins)) | |
1497 { | |
1498 return false; | |
1499 } | |
1500 else | |
1501 { | |
1502 answer.ToString(result); | |
1503 return true; | |
1504 } | |
1505 } | |
1506 | |
1507 | |
5171 | 1508 bool RestApiGet(Json::Value& result, |
1509 const std::string& uri, | |
1510 const std::map<std::string, std::string>& httpHeaders, | |
1511 bool applyPlugins) | |
1512 { | |
1513 MemoryBuffer answer; | |
1514 | |
1515 if (!answer.RestApiGet(uri, httpHeaders, applyPlugins)) | |
1516 { | |
1517 return false; | |
1518 } | |
1519 else | |
1520 { | |
1521 if (!answer.IsEmpty()) | |
1522 { | |
1523 answer.ToJson(result); | |
1524 } | |
1525 return true; | |
1526 } | |
1527 } | |
1528 | |
3028 | 1529 |
1530 bool RestApiGet(Json::Value& result, | |
1531 const std::string& uri, | |
1532 bool applyPlugins) | |
1533 { | |
1534 MemoryBuffer answer; | |
1535 | |
1536 if (!answer.RestApiGet(uri, applyPlugins)) | |
1537 { | |
1538 return false; | |
1539 } | |
1540 else | |
1541 { | |
1542 if (!answer.IsEmpty()) | |
1543 { | |
1544 answer.ToJson(result); | |
1545 } | |
1546 return true; | |
1547 } | |
1548 } | |
1549 | |
1550 | |
3478
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1551 bool RestApiPost(std::string& result, |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1552 const std::string& uri, |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1553 const void* body, |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1554 size_t bodySize, |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1555 bool applyPlugins) |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1556 { |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1557 MemoryBuffer answer; |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1558 |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1559 if (!answer.RestApiPost(uri, body, bodySize, applyPlugins)) |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1560 { |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1561 return false; |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1562 } |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1563 else |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1564 { |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1565 if (!answer.IsEmpty()) |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1566 { |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1567 result.assign(answer.GetData(), answer.GetSize()); |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1568 } |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1569 return true; |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1570 } |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1571 } |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1572 |
f93a9c6c00c5
added RestApiPost overload to retrieve a string response
Alain Mazy <alain@mazy.be>
parents:
3443
diff
changeset
|
1573 |
3028 | 1574 bool RestApiPost(Json::Value& result, |
1575 const std::string& uri, | |
3400
0faae6f6e3c5
fixed some inconsistencies with pointer types in the plugin sdk
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3399
diff
changeset
|
1576 const void* body, |
3028 | 1577 size_t bodySize, |
1578 bool applyPlugins) | |
1579 { | |
1580 MemoryBuffer answer; | |
1581 | |
1582 if (!answer.RestApiPost(uri, body, bodySize, applyPlugins)) | |
1583 { | |
1584 return false; | |
1585 } | |
1586 else | |
1587 { | |
1588 if (!answer.IsEmpty()) | |
1589 { | |
1590 answer.ToJson(result); | |
1591 } | |
1592 return true; | |
1593 } | |
1594 } | |
1595 | |
5049 | 1596 #if HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API == 1 |
1597 bool RestApiPost(Json::Value& result, | |
1598 const std::string& uri, | |
1599 const Json::Value& body, | |
1600 const std::map<std::string, std::string>& httpHeaders, | |
1601 bool applyPlugins) | |
1602 { | |
1603 MemoryBuffer answer; | |
1604 | |
1605 if (!answer.RestApiPost(uri, body, httpHeaders, applyPlugins)) | |
1606 { | |
1607 return false; | |
1608 } | |
1609 else | |
1610 { | |
1611 if (!answer.IsEmpty()) | |
1612 { | |
1613 answer.ToJson(result); | |
1614 } | |
1615 return true; | |
1616 } | |
1617 } | |
1618 #endif | |
1619 | |
3028 | 1620 |
1621 bool RestApiPost(Json::Value& result, | |
1622 const std::string& uri, | |
1623 const Json::Value& body, | |
1624 bool applyPlugins) | |
1625 { | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1626 std::string s; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1627 WriteFastJson(s, body); |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1628 return RestApiPost(result, uri, s, applyPlugins); |
3028 | 1629 } |
1630 | |
1631 | |
1632 bool RestApiPut(Json::Value& result, | |
1633 const std::string& uri, | |
3400
0faae6f6e3c5
fixed some inconsistencies with pointer types in the plugin sdk
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3399
diff
changeset
|
1634 const void* body, |
3028 | 1635 size_t bodySize, |
1636 bool applyPlugins) | |
1637 { | |
1638 MemoryBuffer answer; | |
1639 | |
1640 if (!answer.RestApiPut(uri, body, bodySize, applyPlugins)) | |
1641 { | |
1642 return false; | |
1643 } | |
1644 else | |
1645 { | |
3422
8b4169a88039
ORTHANC_PLUGINS_API using visibility
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3421
diff
changeset
|
1646 if (!answer.IsEmpty()) // i.e, on a PUT to metadata/..., orthanc returns an empty response |
3028 | 1647 { |
1648 answer.ToJson(result); | |
1649 } | |
1650 return true; | |
1651 } | |
1652 } | |
1653 | |
1654 | |
1655 bool RestApiPut(Json::Value& result, | |
1656 const std::string& uri, | |
1657 const Json::Value& body, | |
1658 bool applyPlugins) | |
1659 { | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1660 std::string s; |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1661 WriteFastJson(s, body); |
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
1662 return RestApiPut(result, uri, s, applyPlugins); |
3028 | 1663 } |
1664 | |
1665 | |
1666 bool RestApiDelete(const std::string& uri, | |
1667 bool applyPlugins) | |
1668 { | |
1669 OrthancPluginErrorCode error; | |
1670 | |
1671 if (applyPlugins) | |
1672 { | |
1673 error = OrthancPluginRestApiDeleteAfterPlugins(GetGlobalContext(), uri.c_str()); | |
1674 } | |
1675 else | |
1676 { | |
1677 error = OrthancPluginRestApiDelete(GetGlobalContext(), uri.c_str()); | |
1678 } | |
1679 | |
1680 if (error == OrthancPluginErrorCode_Success) | |
1681 { | |
1682 return true; | |
1683 } | |
1684 else if (error == OrthancPluginErrorCode_UnknownResource || | |
1685 error == OrthancPluginErrorCode_InexistentItem) | |
1686 { | |
1687 return false; | |
1688 } | |
1689 else | |
1690 { | |
1691 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); | |
1692 } | |
1693 } | |
1694 | |
1695 | |
1696 void ReportMinimalOrthancVersion(unsigned int major, | |
1697 unsigned int minor, | |
1698 unsigned int revision) | |
1699 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1700 ORTHANC_PLUGINS_LOG_ERROR("Your version of the Orthanc core (" + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1701 std::string(GetGlobalContext()->orthancVersion) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1702 ") is too old to run this plugin (version " + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1703 boost::lexical_cast<std::string>(major) + "." + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1704 boost::lexical_cast<std::string>(minor) + "." + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1705 boost::lexical_cast<std::string>(revision) + |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1706 " is required)"); |
3028 | 1707 } |
1708 | |
4961 | 1709 bool CheckMinimalVersion(const char* version, |
1710 unsigned int major, | |
1711 unsigned int minor, | |
1712 unsigned int revision) | |
3028 | 1713 { |
4961 | 1714 if (!strcmp(version, "mainline")) |
3028 | 1715 { |
1716 // Assume compatibility with the mainline | |
1717 return true; | |
1718 } | |
1719 | |
5375
984300e70069
updated Housekeeper plugin to handle DicomWeb cache
Alain Mazy <am@osimis.io>
parents:
5321
diff
changeset
|
1720 #ifdef _MSC_VER |
984300e70069
updated Housekeeper plugin to handle DicomWeb cache
Alain Mazy <am@osimis.io>
parents:
5321
diff
changeset
|
1721 #define ORTHANC_SCANF sscanf_s |
984300e70069
updated Housekeeper plugin to handle DicomWeb cache
Alain Mazy <am@osimis.io>
parents:
5321
diff
changeset
|
1722 #else |
984300e70069
updated Housekeeper plugin to handle DicomWeb cache
Alain Mazy <am@osimis.io>
parents:
5321
diff
changeset
|
1723 #define ORTHANC_SCANF sscanf |
984300e70069
updated Housekeeper plugin to handle DicomWeb cache
Alain Mazy <am@osimis.io>
parents:
5321
diff
changeset
|
1724 #endif |
984300e70069
updated Housekeeper plugin to handle DicomWeb cache
Alain Mazy <am@osimis.io>
parents:
5321
diff
changeset
|
1725 |
4961 | 1726 // Parse the version |
5375
984300e70069
updated Housekeeper plugin to handle DicomWeb cache
Alain Mazy <am@osimis.io>
parents:
5321
diff
changeset
|
1727 int aa, bb, cc = 0; |
984300e70069
updated Housekeeper plugin to handle DicomWeb cache
Alain Mazy <am@osimis.io>
parents:
5321
diff
changeset
|
1728 if ((ORTHANC_SCANF(version, "%4d.%4d.%4d", &aa, &bb, &cc) != 3 && |
984300e70069
updated Housekeeper plugin to handle DicomWeb cache
Alain Mazy <am@osimis.io>
parents:
5321
diff
changeset
|
1729 ORTHANC_SCANF(version, "%4d.%4d", &aa, &bb) != 2) || |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1730 aa < 0 || |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1731 bb < 0 || |
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1732 cc < 0) |
3028 | 1733 { |
1734 return false; | |
1735 } | |
1736 | |
1737 unsigned int a = static_cast<unsigned int>(aa); | |
1738 unsigned int b = static_cast<unsigned int>(bb); | |
1739 unsigned int c = static_cast<unsigned int>(cc); | |
1740 | |
1741 // Check the major version number | |
1742 | |
1743 if (a > major) | |
3026 | 1744 { |
1745 return true; | |
1746 } | |
1747 | |
3028 | 1748 if (a < major) |
1749 { | |
1750 return false; | |
1751 } | |
1752 | |
1753 // Check the minor version number | |
1754 assert(a == major); | |
1755 | |
1756 if (b > minor) | |
3026 | 1757 { |
1758 return true; | |
1759 } | |
2792
57e2d65d37ce
OrthancPlugins::MemoryBuffer::Release(), fixing openssl link
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1760 |
3028 | 1761 if (b < minor) |
3026 | 1762 { |
3028 | 1763 return false; |
3026 | 1764 } |
1765 | |
3028 | 1766 // Check the patch level version number |
1767 assert(a == major && b == minor); | |
3026 | 1768 |
3028 | 1769 if (c >= revision) |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1770 { |
3028 | 1771 return true; |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1772 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1773 else |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1774 { |
3028 | 1775 return false; |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1776 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1777 } |
2058
43cd2ab060c7
cont OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2048
diff
changeset
|
1778 |
43cd2ab060c7
cont OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2048
diff
changeset
|
1779 |
4961 | 1780 bool CheckMinimalOrthancVersion(unsigned int major, |
1781 unsigned int minor, | |
1782 unsigned int revision) | |
1783 { | |
1784 if (!HasGlobalContext()) | |
1785 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1786 ORTHANC_PLUGINS_LOG_ERROR("Bad Orthanc context in the plugin"); |
4961 | 1787 return false; |
1788 } | |
1789 | |
1790 return CheckMinimalVersion(GetGlobalContext()->orthancVersion, | |
1791 major, minor, revision); | |
1792 } | |
1793 | |
1794 | |
3028 | 1795 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 0) |
1796 const char* AutodetectMimeType(const std::string& path) | |
3026 | 1797 { |
3028 | 1798 const char* mime = OrthancPluginAutodetectMimeType(GetGlobalContext(), path.c_str()); |
2062
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
1799 |
3028 | 1800 if (mime == NULL) |
1801 { | |
1802 // Should never happen, just for safety | |
1803 return "application/octet-stream"; | |
1804 } | |
1805 else | |
1806 { | |
1807 return mime; | |
1808 } | |
2848 | 1809 } |
3026 | 1810 #endif |
1811 | |
1812 | |
1813 #if HAS_ORTHANC_PLUGIN_PEERS == 1 | |
3028 | 1814 size_t OrthancPeers::GetPeerIndex(const std::string& name) const |
3026 | 1815 { |
3028 | 1816 size_t index; |
1817 if (LookupName(index, name)) | |
1818 { | |
1819 return index; | |
1820 } | |
1821 else | |
1822 { | |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
1823 ORTHANC_PLUGINS_LOG_ERROR("Inexistent peer: " + name); |
3028 | 1824 ORTHANC_PLUGINS_THROW_EXCEPTION(UnknownResource); |
1825 } | |
3026 | 1826 } |
2059 | 1827 |
1828 | |
3028 | 1829 OrthancPeers::OrthancPeers() : |
1830 peers_(NULL), | |
1831 timeout_(0) | |
2205
395522e46b2b
refactoring of the worklist sample using OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2177
diff
changeset
|
1832 { |
3028 | 1833 peers_ = OrthancPluginGetPeers(GetGlobalContext()); |
3026 | 1834 |
3028 | 1835 if (peers_ == NULL) |
3026 | 1836 { |
1837 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); | |
1838 } | |
1839 | |
3028 | 1840 uint32_t count = OrthancPluginGetPeersCount(GetGlobalContext(), peers_); |
1841 | |
1842 for (uint32_t i = 0; i < count; i++) | |
1843 { | |
1844 const char* name = OrthancPluginGetPeerName(GetGlobalContext(), peers_, i); | |
1845 if (name == NULL) | |
1846 { | |
1847 OrthancPluginFreePeers(GetGlobalContext(), peers_); | |
1848 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); | |
1849 } | |
1850 | |
1851 index_[name] = i; | |
1852 } | |
1853 } | |
1854 | |
1855 | |
1856 OrthancPeers::~OrthancPeers() | |
1857 { | |
1858 if (peers_ != NULL) | |
1859 { | |
1860 OrthancPluginFreePeers(GetGlobalContext(), peers_); | |
1861 } | |
1862 } | |
1863 | |
1864 | |
1865 bool OrthancPeers::LookupName(size_t& target, | |
1866 const std::string& name) const | |
1867 { | |
1868 Index::const_iterator found = index_.find(name); | |
1869 | |
1870 if (found == index_.end()) | |
1871 { | |
1872 return false; | |
1873 } | |
1874 else | |
1875 { | |
1876 target = found->second; | |
1877 return true; | |
1878 } | |
3026 | 1879 } |
3028 | 1880 |
1881 | |
1882 std::string OrthancPeers::GetPeerName(size_t index) const | |
1883 { | |
1884 if (index >= index_.size()) | |
1885 { | |
1886 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1887 } | |
1888 else | |
1889 { | |
1890 const char* s = OrthancPluginGetPeerName(GetGlobalContext(), peers_, static_cast<uint32_t>(index)); | |
1891 if (s == NULL) | |
1892 { | |
1893 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); | |
1894 } | |
1895 else | |
1896 { | |
1897 return s; | |
1898 } | |
1899 } | |
1900 } | |
1901 | |
1902 | |
1903 std::string OrthancPeers::GetPeerUrl(size_t index) const | |
1904 { | |
1905 if (index >= index_.size()) | |
1906 { | |
1907 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1908 } | |
1909 else | |
1910 { | |
1911 const char* s = OrthancPluginGetPeerUrl(GetGlobalContext(), peers_, static_cast<uint32_t>(index)); | |
1912 if (s == NULL) | |
1913 { | |
1914 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); | |
1915 } | |
1916 else | |
1917 { | |
1918 return s; | |
1919 } | |
1920 } | |
1921 } | |
1922 | |
1923 | |
1924 std::string OrthancPeers::GetPeerUrl(const std::string& name) const | |
1925 { | |
1926 return GetPeerUrl(GetPeerIndex(name)); | |
1927 } | |
1928 | |
1929 | |
1930 bool OrthancPeers::LookupUserProperty(std::string& value, | |
1931 size_t index, | |
1932 const std::string& key) const | |
1933 { | |
1934 if (index >= index_.size()) | |
1935 { | |
1936 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1937 } | |
1938 else | |
1939 { | |
1940 const char* s = OrthancPluginGetPeerUserProperty(GetGlobalContext(), peers_, static_cast<uint32_t>(index), key.c_str()); | |
1941 if (s == NULL) | |
1942 { | |
1943 return false; | |
1944 } | |
1945 else | |
1946 { | |
1947 value.assign(s); | |
1948 return true; | |
1949 } | |
1950 } | |
1951 } | |
1952 | |
1953 | |
1954 bool OrthancPeers::LookupUserProperty(std::string& value, | |
1955 const std::string& peer, | |
1956 const std::string& key) const | |
1957 { | |
1958 return LookupUserProperty(value, GetPeerIndex(peer), key); | |
1959 } | |
3026 | 1960 |
2205
395522e46b2b
refactoring of the worklist sample using OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2177
diff
changeset
|
1961 |
3028 | 1962 bool OrthancPeers::DoGet(MemoryBuffer& target, |
1963 size_t index, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
1964 const std::string& uri, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
1965 const std::map<std::string, std::string>& headers) const |
3028 | 1966 { |
1967 if (index >= index_.size()) | |
1968 { | |
1969 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1970 } | |
1971 | |
3320 | 1972 OrthancPlugins::MemoryBuffer answer; |
3028 | 1973 uint16_t status; |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
1974 PluginHttpHeaders pluginHeaders(headers); |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
1975 |
3028 | 1976 OrthancPluginErrorCode code = OrthancPluginCallPeerApi |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1977 (GetGlobalContext(), *answer, NULL, &status, peers_, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1978 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Get, uri.c_str(), |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
1979 pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), NULL, 0, timeout_); |
3028 | 1980 |
1981 if (code == OrthancPluginErrorCode_Success) | |
1982 { | |
3320 | 1983 target.Swap(answer); |
3028 | 1984 return (status == 200); |
1985 } | |
1986 else | |
1987 { | |
1988 return false; | |
1989 } | |
1990 } | |
1991 | |
1992 | |
1993 bool OrthancPeers::DoGet(MemoryBuffer& target, | |
1994 const std::string& name, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
1995 const std::string& uri, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
1996 const std::map<std::string, std::string>& headers) const |
3028 | 1997 { |
1998 size_t index; | |
1999 return (LookupName(index, name) && | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2000 DoGet(target, index, uri, headers)); |
3028 | 2001 } |
2002 | |
2003 | |
2004 bool OrthancPeers::DoGet(Json::Value& target, | |
2005 size_t index, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2006 const std::string& uri, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2007 const std::map<std::string, std::string>& headers) const |
3028 | 2008 { |
2009 MemoryBuffer buffer; | |
2010 | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2011 if (DoGet(buffer, index, uri, headers)) |
3028 | 2012 { |
2013 buffer.ToJson(target); | |
2014 return true; | |
2015 } | |
2016 else | |
2017 { | |
2018 return false; | |
2019 } | |
2020 } | |
2021 | |
2022 | |
2023 bool OrthancPeers::DoGet(Json::Value& target, | |
2024 const std::string& name, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2025 const std::string& uri, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2026 const std::map<std::string, std::string>& headers) const |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2027 { |
3028 | 2028 MemoryBuffer buffer; |
2029 | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2030 if (DoGet(buffer, name, uri, headers)) |
3028 | 2031 { |
2032 buffer.ToJson(target); | |
2033 return true; | |
2034 } | |
2035 else | |
2036 { | |
2037 return false; | |
2038 } | |
2039 } | |
2040 | |
2041 | |
2042 bool OrthancPeers::DoPost(MemoryBuffer& target, | |
2043 const std::string& name, | |
2044 const std::string& uri, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2045 const std::string& body, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2046 const std::map<std::string, std::string>& headers) const |
3028 | 2047 { |
2048 size_t index; | |
2049 return (LookupName(index, name) && | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2050 DoPost(target, index, uri, body, headers)); |
3028 | 2051 } |
2052 | |
2053 | |
2054 bool OrthancPeers::DoPost(Json::Value& target, | |
2055 size_t index, | |
2056 const std::string& uri, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2057 const std::string& body, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2058 const std::map<std::string, std::string>& headers) const |
3028 | 2059 { |
2060 MemoryBuffer buffer; | |
2061 | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2062 if (DoPost(buffer, index, uri, body, headers)) |
3028 | 2063 { |
2064 buffer.ToJson(target); | |
2065 return true; | |
2066 } | |
2067 else | |
2068 { | |
2069 return false; | |
2070 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2071 } |
3028 | 2072 |
2073 | |
2074 bool OrthancPeers::DoPost(Json::Value& target, | |
2075 const std::string& name, | |
2076 const std::string& uri, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2077 const std::string& body, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2078 const std::map<std::string, std::string>& headers) const |
3028 | 2079 { |
2080 MemoryBuffer buffer; | |
2081 | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2082 if (DoPost(buffer, name, uri, body, headers)) |
3028 | 2083 { |
2084 buffer.ToJson(target); | |
2085 return true; | |
2086 } | |
2087 else | |
2088 { | |
2089 return false; | |
2090 } | |
2091 } | |
2092 | |
2093 | |
2094 bool OrthancPeers::DoPost(MemoryBuffer& target, | |
2095 size_t index, | |
2096 const std::string& uri, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2097 const std::string& body, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2098 const std::map<std::string, std::string>& headers) const |
3028 | 2099 { |
2100 if (index >= index_.size()) | |
2101 { | |
2102 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
2103 } | |
2104 | |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2105 if (body.size() > 0xffffffffu) |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2106 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
2107 ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2108 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2109 } |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2110 |
3320 | 2111 OrthancPlugins::MemoryBuffer answer; |
3028 | 2112 uint16_t status; |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2113 PluginHttpHeaders pluginHeaders(headers); |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2114 |
3028 | 2115 OrthancPluginErrorCode code = OrthancPluginCallPeerApi |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2116 (GetGlobalContext(), *answer, NULL, &status, peers_, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2117 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Post, uri.c_str(), |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2118 pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), body.empty() ? NULL : body.c_str(), body.size(), timeout_); |
3028 | 2119 |
2120 if (code == OrthancPluginErrorCode_Success) | |
2121 { | |
3320 | 2122 target.Swap(answer); |
3028 | 2123 return (status == 200); |
2124 } | |
2125 else | |
2126 { | |
2127 return false; | |
2128 } | |
2129 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2130 |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2131 |
3028 | 2132 bool OrthancPeers::DoPut(size_t index, |
2133 const std::string& uri, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2134 const std::string& body, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2135 const std::map<std::string, std::string>& headers) const |
3028 | 2136 { |
2137 if (index >= index_.size()) | |
2138 { | |
2139 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
2140 } | |
2141 | |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2142 if (body.size() > 0xffffffffu) |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2143 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
2144 ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2145 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2146 } |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
2147 |
3320 | 2148 OrthancPlugins::MemoryBuffer answer; |
3028 | 2149 uint16_t status; |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2150 PluginHttpHeaders pluginHeaders(headers); |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2151 |
3028 | 2152 OrthancPluginErrorCode code = OrthancPluginCallPeerApi |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2153 (GetGlobalContext(), *answer, NULL, &status, peers_, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2154 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Put, uri.c_str(), |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2155 pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), body.empty() ? NULL : body.c_str(), body.size(), timeout_); |
3026 | 2156 |
3028 | 2157 if (code == OrthancPluginErrorCode_Success) |
2158 { | |
2159 return (status == 200); | |
2160 } | |
2161 else | |
2162 { | |
2163 return false; | |
2164 } | |
2165 } | |
2166 | |
2167 | |
2168 bool OrthancPeers::DoPut(const std::string& name, | |
2169 const std::string& uri, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2170 const std::string& body, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2171 const std::map<std::string, std::string>& headers) const |
3028 | 2172 { |
2173 size_t index; | |
2174 return (LookupName(index, name) && | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2175 DoPut(index, uri, body, headers)); |
3028 | 2176 } |
2177 | |
2178 | |
2179 bool OrthancPeers::DoDelete(size_t index, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2180 const std::string& uri, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2181 const std::map<std::string, std::string>& headers) const |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2182 { |
3028 | 2183 if (index >= index_.size()) |
2184 { | |
2185 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
2186 } | |
2187 | |
3320 | 2188 OrthancPlugins::MemoryBuffer answer; |
3028 | 2189 uint16_t status; |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2190 PluginHttpHeaders pluginHeaders(headers); |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2191 |
3028 | 2192 OrthancPluginErrorCode code = OrthancPluginCallPeerApi |
3320 | 2193 (GetGlobalContext(), *answer, NULL, &status, peers_, |
2194 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Delete, uri.c_str(), | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2195 pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), NULL, 0, timeout_); |
3028 | 2196 |
2197 if (code == OrthancPluginErrorCode_Success) | |
2198 { | |
2199 return (status == 200); | |
2200 } | |
2201 else | |
2202 { | |
2203 return false; | |
2204 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2205 } |
3028 | 2206 |
2207 | |
2208 bool OrthancPeers::DoDelete(const std::string& name, | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2209 const std::string& uri, |
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2210 const std::map<std::string, std::string>& headers) const |
3026 | 2211 { |
3028 | 2212 size_t index; |
2213 return (LookupName(index, name) && | |
5101
fcb2ed6c88ff
Added a 'header' argument to all OrthancPeers::DoPost, DoPut, ...
Alain Mazy <am@osimis.io>
parents:
5049
diff
changeset
|
2214 DoDelete(index, uri, headers)); |
3028 | 2215 } |
2216 #endif | |
2217 | |
2218 | |
2219 | |
3397
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2220 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2221 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2222 /****************************************************************** |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2223 ** JOBS |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2224 ******************************************************************/ |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2225 |
3028 | 2226 #if HAS_ORTHANC_PLUGIN_JOB == 1 |
2227 void OrthancJob::CallbackFinalize(void* job) | |
2228 { | |
2229 if (job != NULL) | |
2230 { | |
2231 delete reinterpret_cast<OrthancJob*>(job); | |
2232 } | |
3026 | 2233 } |
3028 | 2234 |
2235 | |
2236 float OrthancJob::CallbackGetProgress(void* job) | |
2237 { | |
2238 assert(job != NULL); | |
2239 | |
2240 try | |
2241 { | |
2242 return reinterpret_cast<OrthancJob*>(job)->progress_; | |
2243 } | |
2244 catch (...) | |
2245 { | |
2246 return 0; | |
2247 } | |
2248 } | |
2249 | |
2250 | |
5138
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2251 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2252 static OrthancPluginErrorCode CopyStringToMemoryBuffer(OrthancPluginMemoryBuffer* target, |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2253 const std::string& source) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2254 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2255 if (OrthancPluginCreateMemoryBuffer(globalContext_, target, source.size()) != OrthancPluginErrorCode_Success) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2256 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2257 return OrthancPluginErrorCode_NotEnoughMemory; |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2258 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2259 else |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2260 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2261 if (!source.empty()) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2262 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2263 memcpy(target->data, source.c_str(), source.size()); |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2264 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2265 |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2266 return OrthancPluginErrorCode_Success; |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2267 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2268 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2269 #endif |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2270 |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2271 |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2272 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2273 OrthancPluginErrorCode OrthancJob::CallbackGetContent(OrthancPluginMemoryBuffer* target, |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2274 void* job) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2275 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2276 assert(job != NULL); |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2277 OrthancJob& that = *reinterpret_cast<OrthancJob*>(job); |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2278 return CopyStringToMemoryBuffer(target, that.content_); |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2279 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2280 #else |
3028 | 2281 const char* OrthancJob::CallbackGetContent(void* job) |
2282 { | |
2283 assert(job != NULL); | |
2284 | |
2285 try | |
2286 { | |
2287 return reinterpret_cast<OrthancJob*>(job)->content_.c_str(); | |
2288 } | |
2289 catch (...) | |
2290 { | |
2291 return 0; | |
2292 } | |
2293 } | |
5138
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2294 #endif |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2295 |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2296 |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2297 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2298 int32_t OrthancJob::CallbackGetSerialized(OrthancPluginMemoryBuffer* target, |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2299 void* job) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2300 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2301 assert(job != NULL); |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2302 OrthancJob& that = *reinterpret_cast<OrthancJob*>(job); |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2303 |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2304 if (that.hasSerialized_) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2305 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2306 if (CopyStringToMemoryBuffer(target, that.serialized_) == OrthancPluginErrorCode_Success) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2307 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2308 return 1; |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2309 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2310 else |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2311 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2312 return -1; |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2313 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2314 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2315 else |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2316 { |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2317 return 0; |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2318 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2319 } |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2320 #else |
3028 | 2321 const char* OrthancJob::CallbackGetSerialized(void* job) |
2322 { | |
2323 assert(job != NULL); | |
2324 | |
2325 try | |
2326 { | |
2327 const OrthancJob& tmp = *reinterpret_cast<OrthancJob*>(job); | |
2328 | |
2329 if (tmp.hasSerialized_) | |
2330 { | |
2331 return tmp.serialized_.c_str(); | |
2332 } | |
2333 else | |
2334 { | |
2335 return NULL; | |
2336 } | |
2337 } | |
2338 catch (...) | |
2339 { | |
2340 return 0; | |
2341 } | |
2342 } | |
5138
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2343 #endif |
3028 | 2344 |
2345 | |
2346 OrthancPluginJobStepStatus OrthancJob::CallbackStep(void* job) | |
2347 { | |
2348 assert(job != NULL); | |
2349 | |
2350 try | |
2351 { | |
2352 return reinterpret_cast<OrthancJob*>(job)->Step(); | |
2353 } | |
2354 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS&) | |
2355 { | |
2356 return OrthancPluginJobStepStatus_Failure; | |
2357 } | |
2358 catch (...) | |
2359 { | |
2360 return OrthancPluginJobStepStatus_Failure; | |
2361 } | |
2362 } | |
2363 | |
2364 | |
2365 OrthancPluginErrorCode OrthancJob::CallbackStop(void* job, | |
2366 OrthancPluginJobStopReason reason) | |
2367 { | |
2368 assert(job != NULL); | |
2369 | |
2370 try | |
2371 { | |
2372 reinterpret_cast<OrthancJob*>(job)->Stop(reason); | |
2373 return OrthancPluginErrorCode_Success; | |
2374 } | |
2375 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) | |
2376 { | |
2377 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); | |
2378 } | |
2379 catch (...) | |
2380 { | |
2381 return OrthancPluginErrorCode_Plugin; | |
2382 } | |
2383 } | |
2384 | |
2385 | |
2386 OrthancPluginErrorCode OrthancJob::CallbackReset(void* job) | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2387 { |
3028 | 2388 assert(job != NULL); |
2389 | |
2390 try | |
2391 { | |
2392 reinterpret_cast<OrthancJob*>(job)->Reset(); | |
2393 return OrthancPluginErrorCode_Success; | |
2394 } | |
2395 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) | |
2396 { | |
2397 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); | |
2398 } | |
2399 catch (...) | |
2400 { | |
2401 return OrthancPluginErrorCode_Plugin; | |
2402 } | |
2403 } | |
2404 | |
2405 | |
2406 void OrthancJob::ClearContent() | |
2407 { | |
2408 Json::Value empty = Json::objectValue; | |
2409 UpdateContent(empty); | |
2410 } | |
2411 | |
2412 | |
2413 void OrthancJob::UpdateContent(const Json::Value& content) | |
2414 { | |
2415 if (content.type() != Json::objectValue) | |
2416 { | |
2417 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_BadFileFormat); | |
2418 } | |
2419 else | |
2420 { | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
2421 WriteFastJson(content_, content); |
3028 | 2422 } |
2423 } | |
2424 | |
2425 | |
2426 void OrthancJob::ClearSerialized() | |
2427 { | |
2428 hasSerialized_ = false; | |
2429 serialized_.clear(); | |
3026 | 2430 } |
3028 | 2431 |
2432 | |
2433 void OrthancJob::UpdateSerialized(const Json::Value& serialized) | |
2434 { | |
2435 if (serialized.type() != Json::objectValue) | |
2436 { | |
2437 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_BadFileFormat); | |
2438 } | |
2439 else | |
2440 { | |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
2441 WriteFastJson(serialized_, serialized); |
3028 | 2442 hasSerialized_ = true; |
2443 } | |
2444 } | |
2445 | |
2446 | |
2447 void OrthancJob::UpdateProgress(float progress) | |
3026 | 2448 { |
3028 | 2449 if (progress < 0 || |
2450 progress > 1) | |
2451 { | |
2452 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
2453 } | |
2454 | |
2455 progress_ = progress; | |
2456 } | |
2457 | |
2458 | |
2459 OrthancJob::OrthancJob(const std::string& jobType) : | |
2460 jobType_(jobType), | |
2461 progress_(0) | |
2462 { | |
2463 ClearContent(); | |
2464 ClearSerialized(); | |
2465 } | |
2466 | |
2467 | |
2468 OrthancPluginJob* OrthancJob::Create(OrthancJob* job) | |
2469 { | |
2470 if (job == NULL) | |
2471 { | |
2472 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer); | |
2473 } | |
2474 | |
5138
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2475 OrthancPluginJob* orthanc = |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2476 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2477 OrthancPluginCreateJob2 |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2478 #else |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2479 OrthancPluginCreateJob |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2480 #endif |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2481 (GetGlobalContext(), job, CallbackFinalize, job->jobType_.c_str(), |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2482 CallbackGetProgress, CallbackGetContent, CallbackGetSerialized, |
d00db9fb48fb
added OrthancPluginCreateJob2() in the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5101
diff
changeset
|
2483 CallbackStep, CallbackStop, CallbackReset); |
3028 | 2484 |
2485 if (orthanc == NULL) | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2486 { |
3026 | 2487 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2488 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2489 else |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2490 { |
3028 | 2491 return orthanc; |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2492 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2493 } |
2205
395522e46b2b
refactoring of the worklist sample using OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2177
diff
changeset
|
2494 |
2264
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
2495 |
3028 | 2496 std::string OrthancJob::Submit(OrthancJob* job, |
2497 int priority) | |
2264
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
2498 { |
3437
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2499 if (job == NULL) |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2500 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2501 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer); |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2502 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2503 |
3028 | 2504 OrthancPluginJob* orthanc = Create(job); |
2505 | |
2506 char* id = OrthancPluginSubmitJob(GetGlobalContext(), orthanc, priority); | |
2507 | |
2508 if (id == NULL) | |
3026 | 2509 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
2510 ORTHANC_PLUGINS_LOG_ERROR("Plugin cannot submit job"); |
3028 | 2511 OrthancPluginFreeJob(GetGlobalContext(), orthanc); |
3026 | 2512 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); |
2513 } | |
2514 else | |
2515 { | |
3028 | 2516 std::string tmp(id); |
2517 tmp.assign(id); | |
2518 OrthancPluginFreeString(GetGlobalContext(), id); | |
3026 | 2519 |
3028 | 2520 return tmp; |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2521 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2522 } |
3437
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2523 |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2524 |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2525 void OrthancJob::SubmitAndWait(Json::Value& result, |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2526 OrthancJob* job /* takes ownership */, |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2527 int priority) |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2528 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2529 std::string id = Submit(job, priority); |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2530 |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2531 for (;;) |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2532 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2533 boost::this_thread::sleep(boost::posix_time::milliseconds(100)); |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2534 |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2535 Json::Value status; |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2536 if (!RestApiGet(status, "/jobs/" + id, false) || |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2537 !status.isMember("State") || |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2538 status["State"].type() != Json::stringValue) |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2539 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2540 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_InexistentItem); |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2541 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2542 |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2543 const std::string state = status["State"].asString(); |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2544 if (state == "Success") |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2545 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2546 if (status.isMember("Content")) |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2547 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2548 result = status["Content"]; |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2549 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2550 else |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2551 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2552 result = Json::objectValue; |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2553 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2554 |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2555 return; |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2556 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2557 else if (state == "Running") |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2558 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2559 continue; |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2560 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2561 else if (!status.isMember("ErrorCode") || |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2562 status["ErrorCode"].type() != Json::intValue) |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2563 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2564 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_InternalError); |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2565 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2566 else |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2567 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2568 if (!status.isMember("ErrorDescription") || |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2569 status["ErrorDescription"].type() != Json::stringValue) |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2570 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2571 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(status["ErrorCode"].asInt()); |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2572 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2573 else |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2574 { |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2575 #if HAS_ORTHANC_EXCEPTION == 1 |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2576 throw Orthanc::OrthancException(static_cast<Orthanc::ErrorCode>(status["ErrorCode"].asInt()), |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2577 status["ErrorDescription"].asString()); |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2578 #else |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
2579 ORTHANC_PLUGINS_LOG_ERROR("Exception while executing the job: " + status["ErrorDescription"].asString()); |
3437
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2580 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(status["ErrorCode"].asInt()); |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2581 #endif |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2582 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2583 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2584 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2585 } |
dbaf439c8888
OrthancPlugins::OrthancJob::SubmitAndWait()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3434
diff
changeset
|
2586 |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2587 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2588 void OrthancJob::SubmitFromRestApiPost(OrthancPluginRestOutput* output, |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2589 const Json::Value& body, |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2590 OrthancJob* job) |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2591 { |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2592 static const char* KEY_SYNCHRONOUS = "Synchronous"; |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2593 static const char* KEY_ASYNCHRONOUS = "Asynchronous"; |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2594 static const char* KEY_PRIORITY = "Priority"; |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2595 |
3749
edabdf07ee83
replacing deprecated std::auto_ptr by boost::movelib in C++ plugin wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3669
diff
changeset
|
2596 boost::movelib::unique_ptr<OrthancJob> protection(job); |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2597 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2598 if (body.type() != Json::objectValue) |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2599 { |
3669 | 2600 #if HAS_ORTHANC_EXCEPTION == 1 |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2601 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2602 "Expected a JSON object in the body"); |
3669 | 2603 #else |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
2604 ORTHANC_PLUGINS_LOG_ERROR("Expected a JSON object in the body"); |
3669 | 2605 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
2606 #endif | |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2607 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2608 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2609 bool synchronous = true; |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2610 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2611 if (body.isMember(KEY_SYNCHRONOUS)) |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2612 { |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2613 if (body[KEY_SYNCHRONOUS].type() != Json::booleanValue) |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2614 { |
3669 | 2615 #if HAS_ORTHANC_EXCEPTION == 1 |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2616 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2617 "Option \"" + std::string(KEY_SYNCHRONOUS) + |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2618 "\" must be Boolean"); |
3669 | 2619 #else |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
2620 ORTHANC_PLUGINS_LOG_ERROR("Option \"" + std::string(KEY_SYNCHRONOUS) + "\" must be Boolean"); |
3669 | 2621 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
2622 #endif | |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2623 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2624 else |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2625 { |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2626 synchronous = body[KEY_SYNCHRONOUS].asBool(); |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2627 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2628 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2629 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2630 if (body.isMember(KEY_ASYNCHRONOUS)) |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2631 { |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2632 if (body[KEY_ASYNCHRONOUS].type() != Json::booleanValue) |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2633 { |
3669 | 2634 #if HAS_ORTHANC_EXCEPTION == 1 |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2635 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2636 "Option \"" + std::string(KEY_ASYNCHRONOUS) + |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2637 "\" must be Boolean"); |
3669 | 2638 #else |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
2639 ORTHANC_PLUGINS_LOG_ERROR("Option \"" + std::string(KEY_ASYNCHRONOUS) + "\" must be Boolean"); |
3669 | 2640 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
2641 #endif | |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2642 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2643 else |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2644 { |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2645 synchronous = !body[KEY_ASYNCHRONOUS].asBool(); |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2646 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2647 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2648 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2649 int priority = 0; |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2650 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2651 if (body.isMember(KEY_PRIORITY)) |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2652 { |
5441 | 2653 if (body[KEY_PRIORITY].type() != Json::intValue) |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2654 { |
3669 | 2655 #if HAS_ORTHANC_EXCEPTION == 1 |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2656 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2657 "Option \"" + std::string(KEY_PRIORITY) + |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2658 "\" must be an integer"); |
3669 | 2659 #else |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
2660 ORTHANC_PLUGINS_LOG_ERROR("Option \"" + std::string(KEY_PRIORITY) + "\" must be an integer"); |
3669 | 2661 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
2662 #endif | |
3667
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2663 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2664 else |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2665 { |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2666 priority = !body[KEY_PRIORITY].asInt(); |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2667 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2668 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2669 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2670 Json::Value result; |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2671 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2672 if (synchronous) |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2673 { |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2674 OrthancPlugins::OrthancJob::SubmitAndWait(result, protection.release(), priority); |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2675 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2676 else |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2677 { |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2678 std::string id = OrthancPlugins::OrthancJob::Submit(protection.release(), priority); |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2679 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2680 result = Json::objectValue; |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2681 result["ID"] = id; |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2682 result["Path"] = "/jobs/" + id; |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2683 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2684 |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2685 std::string s = result.toStyledString(); |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2686 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2687 s.size(), "application/json"); |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2688 } |
c8d8c3b5f47c
OrthancJob::SubmitFromRestApiPost()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2689 |
2817
473bf302d629
C++ wrappers around OrthancPluginJob and OrthancPluginPeers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2803
diff
changeset
|
2690 #endif |
3179
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2691 |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2692 |
3397
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2693 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2694 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2695 /****************************************************************** |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2696 ** METRICS |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2697 ******************************************************************/ |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2698 |
3179
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2699 #if HAS_ORTHANC_PLUGIN_METRICS == 1 |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2700 MetricsTimer::MetricsTimer(const char* name) : |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2701 name_(name) |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2702 { |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2703 start_ = boost::posix_time::microsec_clock::universal_time(); |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2704 } |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2705 |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2706 MetricsTimer::~MetricsTimer() |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2707 { |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2708 const boost::posix_time::ptime stop = boost::posix_time::microsec_clock::universal_time(); |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2709 const boost::posix_time::time_duration diff = stop - start_; |
3418 | 2710 OrthancPluginSetMetricsValue(GetGlobalContext(), name_.c_str(), static_cast<float>(diff.total_milliseconds()), |
3179
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2711 OrthancPluginMetricsType_Timer); |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2712 } |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2713 #endif |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2714 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2715 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2716 |
3397
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2717 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2718 /****************************************************************** |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2719 ** HTTP CLIENT |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2720 ******************************************************************/ |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2721 |
3388 | 2722 #if HAS_ORTHANC_PLUGIN_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2723 class HttpClient::RequestBodyWrapper : public boost::noncopyable |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2724 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2725 private: |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2726 static RequestBodyWrapper& GetObject(void* body) |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2727 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2728 assert(body != NULL); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2729 return *reinterpret_cast<RequestBodyWrapper*>(body); |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2730 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2731 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2732 IRequestBody& body_; |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2733 bool done_; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2734 std::string chunk_; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2735 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2736 public: |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2737 RequestBodyWrapper(IRequestBody& body) : |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2738 body_(body), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2739 done_(false) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2740 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2741 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2742 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2743 static uint8_t IsDone(void* body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2744 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2745 return GetObject(body).done_; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2746 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2747 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2748 static const void* GetChunkData(void* body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2749 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2750 return GetObject(body).chunk_.c_str(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2751 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2752 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2753 static uint32_t GetChunkSize(void* body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2754 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2755 return static_cast<uint32_t>(GetObject(body).chunk_.size()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2756 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2757 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2758 static OrthancPluginErrorCode Next(void* body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2759 { |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2760 RequestBodyWrapper& that = GetObject(body); |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2761 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2762 if (that.done_) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2763 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2764 return OrthancPluginErrorCode_BadSequenceOfCalls; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2765 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2766 else |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2767 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2768 try |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2769 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2770 that.done_ = !that.body_.ReadNextChunk(that.chunk_); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2771 return OrthancPluginErrorCode_Success; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2772 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2773 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2774 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2775 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2776 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2777 catch (...) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2778 { |
4943
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
2779 return OrthancPluginErrorCode_Plugin; |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2780 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2781 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2782 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2783 }; |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2784 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2785 |
3413 | 2786 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2787 static OrthancPluginErrorCode AnswerAddHeaderCallback(void* answer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2788 const char* key, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2789 const char* value) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2790 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2791 assert(answer != NULL && key != NULL && value != NULL); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2792 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2793 try |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2794 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2795 reinterpret_cast<HttpClient::IAnswer*>(answer)->AddHeader(key, value); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2796 return OrthancPluginErrorCode_Success; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2797 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2798 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2799 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2800 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2801 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2802 catch (...) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2803 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2804 return OrthancPluginErrorCode_Plugin; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2805 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2806 } |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2807 #endif |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2808 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2809 |
3413 | 2810 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2811 static OrthancPluginErrorCode AnswerAddChunkCallback(void* answer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2812 const void* data, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2813 uint32_t size) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2814 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2815 assert(answer != NULL); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2816 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2817 try |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2818 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2819 reinterpret_cast<HttpClient::IAnswer*>(answer)->AddChunk(data, size); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2820 return OrthancPluginErrorCode_Success; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2821 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2822 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2823 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2824 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2825 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2826 catch (...) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2827 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2828 return OrthancPluginErrorCode_Plugin; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2829 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2830 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2831 #endif |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2832 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2833 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2834 HttpClient::HttpClient() : |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2835 httpStatus_(0), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2836 method_(OrthancPluginHttpMethod_Get), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2837 timeout_(0), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2838 pkcs11_(false), |
3443
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
2839 chunkedBody_(NULL), |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
2840 allowChunkedTransfers_(true) |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2841 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2842 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2843 |
3426
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2844 |
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2845 void HttpClient::AddHeaders(const HttpHeaders& headers) |
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2846 { |
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2847 for (HttpHeaders::const_iterator it = headers.begin(); |
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2848 it != headers.end(); ++it) |
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2849 { |
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2850 headers_[it->first] = it->second; |
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2851 } |
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2852 } |
00737cd21f40
OrthancPlugins::HttpClient::AddHeaders()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3422
diff
changeset
|
2853 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2854 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2855 void HttpClient::SetCredentials(const std::string& username, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2856 const std::string& password) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2857 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2858 username_ = username; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2859 password_ = password; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2860 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2861 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2862 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2863 void HttpClient::ClearCredentials() |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2864 { |
4846
b2e08d83e21d
fix OrthancPlugins::HttpClient::ClearCredentials()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4838
diff
changeset
|
2865 username_.clear(); |
b2e08d83e21d
fix OrthancPlugins::HttpClient::ClearCredentials()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4838
diff
changeset
|
2866 password_.clear(); |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2867 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2868 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2869 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2870 void HttpClient::SetCertificate(const std::string& certificateFile, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2871 const std::string& keyFile, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2872 const std::string& keyPassword) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2873 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2874 certificateFile_ = certificateFile; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2875 certificateKeyFile_ = keyFile; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2876 certificateKeyPassword_ = keyPassword; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2877 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2878 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2879 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2880 void HttpClient::ClearCertificate() |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2881 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2882 certificateFile_.clear(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2883 certificateKeyFile_.clear(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2884 certificateKeyPassword_.clear(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2885 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2886 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2887 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2888 void HttpClient::ClearBody() |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2889 { |
3413 | 2890 fullBody_.clear(); |
2891 chunkedBody_ = NULL; | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2892 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2893 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2894 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2895 void HttpClient::SwapBody(std::string& body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2896 { |
3413 | 2897 fullBody_.swap(body); |
2898 chunkedBody_ = NULL; | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2899 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2900 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2901 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2902 void HttpClient::SetBody(const std::string& body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2903 { |
3413 | 2904 fullBody_ = body; |
2905 chunkedBody_ = NULL; | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2906 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2907 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2908 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2909 void HttpClient::SetBody(IRequestBody& body) |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2910 { |
3413 | 2911 fullBody_.clear(); |
2912 chunkedBody_ = &body; | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2913 } |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2914 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2915 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2916 namespace |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2917 { |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2918 class HeadersWrapper : public boost::noncopyable |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2919 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2920 private: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2921 std::vector<const char*> headersKeys_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2922 std::vector<const char*> headersValues_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2923 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2924 public: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2925 HeadersWrapper(const HttpClient::HttpHeaders& headers) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2926 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2927 headersKeys_.reserve(headers.size()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2928 headersValues_.reserve(headers.size()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2929 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2930 for (HttpClient::HttpHeaders::const_iterator it = headers.begin(); it != headers.end(); ++it) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2931 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2932 headersKeys_.push_back(it->first.c_str()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2933 headersValues_.push_back(it->second.c_str()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2934 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2935 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2936 |
3394 | 2937 void AddStaticString(const char* key, |
2938 const char* value) | |
2939 { | |
2940 headersKeys_.push_back(key); | |
2941 headersValues_.push_back(value); | |
2942 } | |
2943 | |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2944 uint32_t GetCount() const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2945 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2946 return headersKeys_.size(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2947 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2948 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2949 const char* const* GetKeys() const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2950 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2951 return headersKeys_.empty() ? NULL : &headersKeys_[0]; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2952 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2953 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2954 const char* const* GetValues() const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2955 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2956 return headersValues_.empty() ? NULL : &headersValues_[0]; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2957 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2958 }; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2959 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2960 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2961 class MemoryRequestBody : public HttpClient::IRequestBody |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2962 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2963 private: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2964 std::string body_; |
3420
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2965 bool done_; |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2966 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2967 public: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2968 MemoryRequestBody(const std::string& body) : |
3420
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2969 body_(body), |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2970 done_(false) |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2971 { |
3434 | 2972 if (body_.empty()) |
2973 { | |
2974 done_ = true; | |
2975 } | |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2976 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2977 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2978 virtual bool ReadNextChunk(std::string& chunk) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2979 { |
3420
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2980 if (done_) |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2981 { |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2982 return false; |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2983 } |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2984 else |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2985 { |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2986 chunk.swap(body_); |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2987 done_ = true; |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2988 return true; |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
2989 } |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2990 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2991 }; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2992 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2993 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2994 // This class mimics Orthanc::ChunkedBuffer |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2995 class ChunkedBuffer : public boost::noncopyable |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2996 { |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2997 private: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2998 typedef std::list<std::string*> Content; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2999 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3000 Content content_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3001 size_t size_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3002 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3003 public: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3004 ChunkedBuffer() : |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3005 size_(0) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3006 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3007 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3008 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3009 ~ChunkedBuffer() |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3010 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3011 Clear(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3012 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3013 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3014 void Clear() |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3015 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3016 for (Content::iterator it = content_.begin(); it != content_.end(); ++it) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3017 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3018 assert(*it != NULL); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3019 delete *it; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3020 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3021 |
4651
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3022 size_ = 0; |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3023 content_.clear(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3024 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3025 |
4651
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3026 /** |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3027 * Since Orthanc 1.9.3, this function also clears the content of |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3028 * the ChunkedBuffer in order to mimic the behavior of the |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3029 * original class "Orthanc::ChunkedBuffer". This prevents the |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3030 * forgetting of calling "Clear()" in order to reduce memory |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3031 * consumption. |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3032 **/ |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3033 void Flatten(std::string& target) |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3034 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3035 target.resize(size_); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3036 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3037 size_t pos = 0; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3038 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3039 for (Content::const_iterator it = content_.begin(); it != content_.end(); ++it) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3040 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3041 assert(*it != NULL); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3042 size_t s = (*it)->size(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3043 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3044 if (s != 0) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3045 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3046 memcpy(&target[pos], (*it)->c_str(), s); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3047 pos += s; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3048 } |
4651
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3049 |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3050 delete *it; |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3051 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3052 |
4651
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3053 assert(pos == target.size()); |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3054 |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3055 size_ = 0; |
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3056 content_.clear(); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3057 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3058 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3059 void AddChunk(const void* data, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3060 size_t size) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3061 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3062 content_.push_back(new std::string(reinterpret_cast<const char*>(data), size)); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3063 size_ += size; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3064 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3065 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3066 void AddChunk(const std::string& chunk) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3067 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3068 content_.push_back(new std::string(chunk)); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3069 size_ += chunk.size(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3070 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3071 }; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3072 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3073 |
3413 | 3074 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3075 class MemoryAnswer : public HttpClient::IAnswer |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
3076 { |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3077 private: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3078 HttpClient::HttpHeaders headers_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3079 ChunkedBuffer body_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3080 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3081 public: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3082 const HttpClient::HttpHeaders& GetHeaders() const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3083 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3084 return headers_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3085 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3086 |
4651
365f51fae413
reduce memory consumption of OrthancPlugins::HttpClient::Execute() in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4445
diff
changeset
|
3087 ChunkedBuffer& GetBody() |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3088 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3089 return body_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3090 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3091 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3092 virtual void AddHeader(const std::string& key, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3093 const std::string& value) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3094 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3095 headers_[key] = value; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3096 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3097 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3098 virtual void AddChunk(const void* data, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3099 size_t size) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3100 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3101 body_.AddChunk(data, size); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3102 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3103 }; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3104 #endif |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3105 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3106 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3107 |
3413 | 3108 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3109 void HttpClient::ExecuteWithStream(uint16_t& httpStatus, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3110 IAnswer& answer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3111 IRequestBody& body) const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3112 { |
3394 | 3113 HeadersWrapper h(headers_); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3114 |
3434 | 3115 if (method_ == OrthancPluginHttpMethod_Post || |
3116 method_ == OrthancPluginHttpMethod_Put) | |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3117 { |
3434 | 3118 // Automatically set the "Transfer-Encoding" header if absent |
3119 bool found = false; | |
3120 | |
3121 for (HttpHeaders::const_iterator it = headers_.begin(); it != headers_.end(); ++it) | |
3394 | 3122 { |
3434 | 3123 if (boost::iequals(it->first, "Transfer-Encoding")) |
3124 { | |
3125 found = true; | |
3126 break; | |
3127 } | |
3394 | 3128 } |
3434 | 3129 |
3130 if (!found) | |
3131 { | |
3132 h.AddStaticString("Transfer-Encoding", "chunked"); | |
3133 } | |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3134 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3135 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3136 RequestBodyWrapper request(body); |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
3137 |
3413 | 3138 OrthancPluginErrorCode error = OrthancPluginChunkedHttpClient( |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3139 GetGlobalContext(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3140 &answer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3141 AnswerAddChunkCallback, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3142 AnswerAddHeaderCallback, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3143 &httpStatus, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3144 method_, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3145 url_.c_str(), |
3394 | 3146 h.GetCount(), |
3147 h.GetKeys(), | |
3148 h.GetValues(), | |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3149 &request, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3150 RequestBodyWrapper::IsDone, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3151 RequestBodyWrapper::GetChunkData, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3152 RequestBodyWrapper::GetChunkSize, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3153 RequestBodyWrapper::Next, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3154 username_.empty() ? NULL : username_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3155 password_.empty() ? NULL : password_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3156 timeout_, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3157 certificateFile_.empty() ? NULL : certificateFile_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3158 certificateFile_.empty() ? NULL : certificateKeyFile_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3159 certificateFile_.empty() ? NULL : certificateKeyPassword_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3160 pkcs11_ ? 1 : 0); |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
3161 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
3162 if (error != OrthancPluginErrorCode_Success) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
3163 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
3164 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
3165 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
3166 } |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3167 #endif |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3168 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3169 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3170 void HttpClient::ExecuteWithoutStream(uint16_t& httpStatus, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3171 HttpHeaders& answerHeaders, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3172 std::string& answerBody, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3173 const std::string& body) const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3174 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3175 HeadersWrapper headers(headers_); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3176 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3177 MemoryBuffer answerBodyBuffer, answerHeadersBuffer; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3178 |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
3179 if (body.size() > 0xffffffffu) |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
3180 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
3181 ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); |
4837
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
3182 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
3183 } |
a678ff1b8278
CPP Wrapper: fail when trying to use body > 4GB
Alain Mazy <am@osimis.io>
parents:
4651
diff
changeset
|
3184 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3185 OrthancPluginErrorCode error = OrthancPluginHttpClient( |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3186 GetGlobalContext(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3187 *answerBodyBuffer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3188 *answerHeadersBuffer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3189 &httpStatus, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3190 method_, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3191 url_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3192 headers.GetCount(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3193 headers.GetKeys(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3194 headers.GetValues(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3195 body.empty() ? NULL : body.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3196 body.size(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3197 username_.empty() ? NULL : username_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3198 password_.empty() ? NULL : password_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3199 timeout_, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3200 certificateFile_.empty() ? NULL : certificateFile_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3201 certificateFile_.empty() ? NULL : certificateKeyFile_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3202 certificateFile_.empty() ? NULL : certificateKeyPassword_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3203 pkcs11_ ? 1 : 0); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3204 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3205 if (error != OrthancPluginErrorCode_Success) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3206 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3207 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3208 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3209 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3210 Json::Value v; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3211 answerHeadersBuffer.ToJson(v); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3212 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3213 if (v.type() != Json::objectValue) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3214 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3215 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3216 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3217 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3218 Json::Value::Members members = v.getMemberNames(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3219 answerHeaders.clear(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3220 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3221 for (size_t i = 0; i < members.size(); i++) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3222 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3223 const Json::Value& h = v[members[i]]; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3224 if (h.type() != Json::stringValue) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3225 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3226 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3227 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3228 else |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3229 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3230 answerHeaders[members[i]] = h.asString(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3231 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3232 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3233 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3234 answerBodyBuffer.ToString(answerBody); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3235 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3236 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3237 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3238 void HttpClient::Execute(IAnswer& answer) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3239 { |
3438
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3240 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3443
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3241 if (allowChunkedTransfers_) |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3242 { |
3443
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3243 if (chunkedBody_ != NULL) |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3244 { |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3245 ExecuteWithStream(httpStatus_, answer, *chunkedBody_); |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3246 } |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3247 else |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3248 { |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3249 MemoryRequestBody wrapper(fullBody_); |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3250 ExecuteWithStream(httpStatus_, answer, wrapper); |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3251 } |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3252 |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3253 return; |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3254 } |
3443
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3255 #endif |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3256 |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3257 // Compatibility mode for Orthanc SDK <= 1.5.6 or if chunked |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3258 // transfers are disabled. This results in higher memory usage |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3259 // (all chunks from the answer body are sent at once) |
3438
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3260 |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3261 HttpHeaders answerHeaders; |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3262 std::string answerBody; |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3263 Execute(answerHeaders, answerBody); |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3264 |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3265 for (HttpHeaders::const_iterator it = answerHeaders.begin(); |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3266 it != answerHeaders.end(); ++it) |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3267 { |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3268 answer.AddHeader(it->first, it->second); |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3269 } |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3270 |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3271 if (!answerBody.empty()) |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3272 { |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3273 answer.AddChunk(answerBody.c_str(), answerBody.size()); |
d97ef941d521
compatibility mode for OrthancPlugins::HttpClient::IAnswer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3437
diff
changeset
|
3274 } |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3275 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3276 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3277 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3278 void HttpClient::Execute(HttpHeaders& answerHeaders /* out */, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3279 std::string& answerBody /* out */) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3280 { |
3413 | 3281 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3443
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3282 if (allowChunkedTransfers_) |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3283 { |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3284 MemoryAnswer answer; |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3285 Execute(answer); |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3286 answerHeaders = answer.GetHeaders(); |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3287 answer.GetBody().Flatten(answerBody); |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3288 return; |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3289 } |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3290 #endif |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3291 |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3292 // Compatibility mode for Orthanc SDK <= 1.5.6 or if chunked |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3293 // transfers are disabled. This results in higher memory usage |
0371b65d5f76
OrthancPlugins::HttpClient::SetChunkedTransfersAllowed()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3440
diff
changeset
|
3294 // (all chunks from the request body are sent at once) |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3295 |
3413 | 3296 if (chunkedBody_ != NULL) |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3297 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3298 ChunkedBuffer buffer; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3299 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3300 std::string chunk; |
3413 | 3301 while (chunkedBody_->ReadNextChunk(chunk)) |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3302 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3303 buffer.AddChunk(chunk); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3304 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3305 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3306 std::string body; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3307 buffer.Flatten(body); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3308 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3309 ExecuteWithoutStream(httpStatus_, answerHeaders, answerBody, body); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3310 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3311 else |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3312 { |
3413 | 3313 ExecuteWithoutStream(httpStatus_, answerHeaders, answerBody, fullBody_); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3314 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3315 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
3316 |
3420
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3317 |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3318 void HttpClient::Execute(HttpHeaders& answerHeaders /* out */, |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3319 Json::Value& answerBody /* out */) |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3320 { |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3321 std::string body; |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3322 Execute(answerHeaders, body); |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3323 |
4394
f7104e9d044c
functions to read/write JSON in OrthancPluginCppWrapper.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4122
diff
changeset
|
3324 if (!ReadJson(answerBody, body)) |
3420
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3325 { |
5572
f0dc99bc811c
removed circular dependency of OrthancPluginsCppWrapper with Orthanc::Logging
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5570
diff
changeset
|
3326 ORTHANC_PLUGINS_LOG_ERROR("Cannot convert HTTP answer body to JSON"); |
3420
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3327 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3328 } |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3329 } |
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3418
diff
changeset
|
3330 |
3434 | 3331 |
3332 void HttpClient::Execute() | |
3333 { | |
3334 HttpHeaders answerHeaders; | |
3335 std::string body; | |
3336 Execute(answerHeaders, body); | |
3337 } | |
3338 | |
3388 | 3339 #endif /* HAS_ORTHANC_PLUGIN_HTTP_CLIENT == 1 */ |
3416 | 3340 |
3341 | |
3342 | |
3343 | |
3344 | |
3345 /****************************************************************** | |
3346 ** CHUNKED HTTP SERVER | |
3347 ******************************************************************/ | |
3348 | |
3349 namespace Internals | |
3350 { | |
3351 void NullRestCallback(OrthancPluginRestOutput* output, | |
3352 const char* url, | |
3353 const OrthancPluginHttpRequest* request) | |
3354 { | |
3355 } | |
3356 | |
3357 IChunkedRequestReader *NullChunkedRestCallback(const char* url, | |
3358 const OrthancPluginHttpRequest* request) | |
3359 { | |
3360 return NULL; | |
3361 } | |
3362 | |
3363 | |
3364 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_SERVER == 1 | |
3365 | |
3366 OrthancPluginErrorCode ChunkedRequestReaderAddChunk( | |
3367 OrthancPluginServerChunkedRequestReader* reader, | |
3368 const void* data, | |
3369 uint32_t size) | |
3370 { | |
3371 try | |
3372 { | |
3373 if (reader == NULL) | |
3374 { | |
3375 return OrthancPluginErrorCode_InternalError; | |
3376 } | |
3377 | |
3378 reinterpret_cast<IChunkedRequestReader*>(reader)->AddChunk(data, size); | |
3379 return OrthancPluginErrorCode_Success; | |
3380 } | |
3381 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) | |
3382 { | |
3383 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); | |
3384 } | |
3385 catch (boost::bad_lexical_cast&) | |
3386 { | |
3387 return OrthancPluginErrorCode_BadFileFormat; | |
3388 } | |
3389 catch (...) | |
3390 { | |
3391 return OrthancPluginErrorCode_Plugin; | |
3392 } | |
3393 } | |
3394 | |
3395 | |
3396 OrthancPluginErrorCode ChunkedRequestReaderExecute( | |
3397 OrthancPluginServerChunkedRequestReader* reader, | |
3398 OrthancPluginRestOutput* output) | |
3399 { | |
3400 try | |
3401 { | |
3402 if (reader == NULL) | |
3403 { | |
3404 return OrthancPluginErrorCode_InternalError; | |
3405 } | |
3406 | |
3407 reinterpret_cast<IChunkedRequestReader*>(reader)->Execute(output); | |
3408 return OrthancPluginErrorCode_Success; | |
3409 } | |
3410 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) | |
3411 { | |
3412 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); | |
3413 } | |
3414 catch (boost::bad_lexical_cast&) | |
3415 { | |
3416 return OrthancPluginErrorCode_BadFileFormat; | |
3417 } | |
3418 catch (...) | |
3419 { | |
3420 return OrthancPluginErrorCode_Plugin; | |
3421 } | |
3422 } | |
3423 | |
3424 | |
3425 void ChunkedRequestReaderFinalize( | |
3426 OrthancPluginServerChunkedRequestReader* reader) | |
3427 { | |
3428 if (reader != NULL) | |
3429 { | |
3430 delete reinterpret_cast<IChunkedRequestReader*>(reader); | |
3431 } | |
3432 } | |
3433 | |
3434 #else | |
3435 | |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3436 OrthancPluginErrorCode ChunkedRestCompatibility(OrthancPluginRestOutput* output, |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3437 const char* url, |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3438 const OrthancPluginHttpRequest* request, |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3439 RestCallback GetHandler, |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3440 ChunkedRestCallback PostHandler, |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3441 RestCallback DeleteHandler, |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3442 ChunkedRestCallback PutHandler) |
3416 | 3443 { |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3444 try |
3416 | 3445 { |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3446 std::string allowed; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3447 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3448 if (GetHandler != Internals::NullRestCallback) |
3416 | 3449 { |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3450 allowed += "GET"; |
3416 | 3451 } |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3452 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3453 if (PostHandler != Internals::NullChunkedRestCallback) |
3416 | 3454 { |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3455 if (!allowed.empty()) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3456 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3457 allowed += ","; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3458 } |
3416 | 3459 |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3460 allowed += "POST"; |
3416 | 3461 } |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3462 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3463 if (DeleteHandler != Internals::NullRestCallback) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3464 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3465 if (!allowed.empty()) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3466 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3467 allowed += ","; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3468 } |
3416 | 3469 |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3470 allowed += "DELETE"; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3471 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3472 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3473 if (PutHandler != Internals::NullChunkedRestCallback) |
3416 | 3474 { |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3475 if (!allowed.empty()) |
3416 | 3476 { |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3477 allowed += ","; |
3416 | 3478 } |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3479 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3480 allowed += "PUT"; |
3416 | 3481 } |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3482 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3483 switch (request->method) |
3416 | 3484 { |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3485 case OrthancPluginHttpMethod_Get: |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3486 if (GetHandler == Internals::NullRestCallback) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3487 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3488 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3489 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3490 else |
3416 | 3491 { |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3492 GetHandler(output, url, request); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3493 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3494 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3495 break; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3496 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3497 case OrthancPluginHttpMethod_Post: |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3498 if (PostHandler == Internals::NullChunkedRestCallback) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3499 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3500 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); |
3416 | 3501 } |
3502 else | |
3503 { | |
3749
edabdf07ee83
replacing deprecated std::auto_ptr by boost::movelib in C++ plugin wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3669
diff
changeset
|
3504 boost::movelib::unique_ptr<IChunkedRequestReader> reader(PostHandler(url, request)); |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3505 if (reader.get() == NULL) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3506 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3507 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3508 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3509 else |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3510 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3511 reader->AddChunk(request->body, request->bodySize); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3512 reader->Execute(output); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3513 } |
3416 | 3514 } |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3515 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3516 break; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3517 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3518 case OrthancPluginHttpMethod_Delete: |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3519 if (DeleteHandler == Internals::NullRestCallback) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3520 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3521 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3522 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3523 else |
3416 | 3524 { |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3525 DeleteHandler(output, url, request); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3526 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3527 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3528 break; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3529 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3530 case OrthancPluginHttpMethod_Put: |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3531 if (PutHandler == Internals::NullChunkedRestCallback) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3532 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3533 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); |
3416 | 3534 } |
3535 else | |
3536 { | |
3749
edabdf07ee83
replacing deprecated std::auto_ptr by boost::movelib in C++ plugin wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3669
diff
changeset
|
3537 boost::movelib::unique_ptr<IChunkedRequestReader> reader(PutHandler(url, request)); |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3538 if (reader.get() == NULL) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3539 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3540 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3541 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3542 else |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3543 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3544 reader->AddChunk(request->body, request->bodySize); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3545 reader->Execute(output); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3546 } |
3416 | 3547 } |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3548 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3549 break; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3550 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3551 default: |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3552 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
3416 | 3553 } |
3554 | |
3433
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3555 return OrthancPluginErrorCode_Success; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3556 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3557 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3558 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3559 #if HAS_ORTHANC_EXCEPTION == 1 && HAS_ORTHANC_PLUGIN_EXCEPTION_DETAILS == 1 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3560 if (HasGlobalContext() && |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3561 e.HasDetails()) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3562 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3563 // The "false" instructs Orthanc not to log the detailed |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3564 // error message. This is to avoid duplicating the details, |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3565 // because "OrthancException" already does it on construction. |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3566 OrthancPluginSetHttpErrorDetails |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3567 (GetGlobalContext(), output, e.GetDetails(), false); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3568 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3569 #endif |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3570 |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3571 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3572 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3573 catch (boost::bad_lexical_cast&) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3574 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3575 return OrthancPluginErrorCode_BadFileFormat; |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3576 } |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3577 catch (...) |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3578 { |
caa526bb65cc
fixed C++ compatibility wrapper for OrthancPluginRegisterRestCallbackNoLock()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3426
diff
changeset
|
3579 return OrthancPluginErrorCode_Plugin; |
3416 | 3580 } |
3581 } | |
3582 #endif | |
3583 } | |
3664
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3584 |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3585 |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3586 #if HAS_ORTHANC_PLUGIN_STORAGE_COMMITMENT_SCP == 1 |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3587 OrthancPluginErrorCode IStorageCommitmentScpHandler::Lookup( |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3588 OrthancPluginStorageCommitmentFailureReason* target, |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3589 void* rawHandler, |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3590 const char* sopClassUid, |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3591 const char* sopInstanceUid) |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3592 { |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3593 assert(target != NULL && |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3594 rawHandler != NULL); |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3595 |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3596 try |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3597 { |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3598 IStorageCommitmentScpHandler& handler = *reinterpret_cast<IStorageCommitmentScpHandler*>(rawHandler); |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3599 *target = handler.Lookup(sopClassUid, sopInstanceUid); |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3600 return OrthancPluginErrorCode_Success; |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3601 } |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3602 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3603 { |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3604 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3605 } |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3606 catch (...) |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3607 { |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3608 return OrthancPluginErrorCode_Plugin; |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3609 } |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3610 } |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3611 #endif |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3612 |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3613 |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3614 #if HAS_ORTHANC_PLUGIN_STORAGE_COMMITMENT_SCP == 1 |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3615 void IStorageCommitmentScpHandler::Destructor(void* rawHandler) |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3616 { |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3617 assert(rawHandler != NULL); |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3618 delete reinterpret_cast<IStorageCommitmentScpHandler*>(rawHandler); |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3619 } |
85acfcc15829
sample storage commitment plugin, C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
3620 #endif |
3916
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3621 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3622 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3623 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3624 DicomInstance::DicomInstance(const OrthancPluginDicomInstance* instance) : |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3625 toFree_(false), |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3626 instance_(instance) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3627 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3628 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3629 #else |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3630 DicomInstance::DicomInstance(OrthancPluginDicomInstance* instance) : |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3631 toFree_(false), |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3632 instance_(instance) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3633 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3634 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3635 #endif |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3636 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3637 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3638 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3639 DicomInstance::DicomInstance(const void* buffer, |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3640 size_t size) : |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3641 toFree_(true), |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3642 instance_(OrthancPluginCreateDicomInstance(GetGlobalContext(), buffer, size)) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3643 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3644 if (instance_ == NULL) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3645 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3646 ORTHANC_PLUGINS_THROW_EXCEPTION(NullPointer); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3647 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3648 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3649 #endif |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3650 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3651 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3652 DicomInstance::~DicomInstance() |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3653 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3654 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3655 if (toFree_ && |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3656 instance_ != NULL) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3657 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3658 OrthancPluginFreeDicomInstance( |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3659 GetGlobalContext(), const_cast<OrthancPluginDicomInstance*>(instance_)); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3660 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3661 #endif |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3662 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3663 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3664 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3665 std::string DicomInstance::GetRemoteAet() const |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3666 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3667 const char* s = OrthancPluginGetInstanceRemoteAet(GetGlobalContext(), instance_); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3668 if (s == NULL) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3669 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3670 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3671 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3672 else |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3673 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3674 return std::string(s); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3675 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3676 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3677 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3678 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3679 void DicomInstance::GetJson(Json::Value& target) const |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3680 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3681 OrthancString s; |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3682 s.Assign(OrthancPluginGetInstanceJson(GetGlobalContext(), instance_)); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3683 s.ToJson(target); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3684 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3685 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3686 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3687 void DicomInstance::GetSimplifiedJson(Json::Value& target) const |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3688 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3689 OrthancString s; |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3690 s.Assign(OrthancPluginGetInstanceSimplifiedJson(GetGlobalContext(), instance_)); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3691 s.ToJson(target); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3692 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3693 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3694 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3695 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3696 std::string DicomInstance::GetTransferSyntaxUid() const |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3697 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3698 OrthancString s; |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3699 s.Assign(OrthancPluginGetInstanceTransferSyntaxUid(GetGlobalContext(), instance_)); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3700 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3701 std::string result; |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3702 s.ToString(result); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3703 return result; |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3704 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3705 #endif |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3706 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3707 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3708 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3709 bool DicomInstance::HasPixelData() const |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3710 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3711 int32_t result = OrthancPluginHasInstancePixelData(GetGlobalContext(), instance_); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3712 if (result < 0) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3713 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3714 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3715 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3716 else |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3717 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3718 return (result != 0); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3719 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3720 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3721 #endif |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3722 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3723 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3724 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3725 void DicomInstance::GetRawFrame(std::string& target, |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3726 unsigned int frameIndex) const |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3727 { |
3919
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3728 MemoryBuffer buffer; |
3916
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3729 OrthancPluginErrorCode code = OrthancPluginGetInstanceRawFrame( |
3919
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3730 GetGlobalContext(), *buffer, instance_, frameIndex); |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3731 |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3732 if (code == OrthancPluginErrorCode_Success) |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3733 { |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3734 buffer.ToString(target); |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3735 } |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3736 else |
3916
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3737 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3738 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3739 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3740 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3741 #endif |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3742 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3743 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3744 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3745 OrthancImage* DicomInstance::GetDecodedFrame(unsigned int frameIndex) const |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3746 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3747 OrthancPluginImage* image = OrthancPluginGetInstanceDecodedFrame( |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3748 GetGlobalContext(), instance_, frameIndex); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3749 |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3750 if (image == NULL) |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3751 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3752 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3753 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3754 else |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3755 { |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3756 return new OrthancImage(image); |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3757 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3758 } |
0e3849268a55
new plugin SDK primitives related to OrthancPluginDicomInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3915
diff
changeset
|
3759 #endif |
3919
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3760 |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3761 |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3762 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3763 void DicomInstance::Serialize(std::string& target) const |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3764 { |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3765 MemoryBuffer buffer; |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3766 OrthancPluginErrorCode code = OrthancPluginSerializeDicomInstance( |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3767 GetGlobalContext(), *buffer, instance_); |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3768 |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3769 if (code == OrthancPluginErrorCode_Success) |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3770 { |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3771 buffer.ToString(target); |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3772 } |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3773 else |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3774 { |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3775 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3776 } |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3777 } |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3778 #endif |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3779 |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3780 |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3781 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3782 DicomInstance* DicomInstance::Transcode(const void* buffer, |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3783 size_t size, |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3784 const std::string& transferSyntax) |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3785 { |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3786 OrthancPluginDicomInstance* instance = OrthancPluginTranscodeDicomInstance( |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3787 GetGlobalContext(), buffer, size, transferSyntax.c_str()); |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3788 |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3789 if (instance == NULL) |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3790 { |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3791 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3792 } |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3793 else |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3794 { |
3923
2434e98987ba
fix for older compilers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3921
diff
changeset
|
3795 boost::movelib::unique_ptr<DicomInstance> result(new DicomInstance(instance)); |
3921 | 3796 result->toFree_ = true; |
3797 return result.release(); | |
3919
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3798 } |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3799 } |
6f11b3233a06
OrthancPluginTranscodeDicomInstance() and OrthancPluginSerializeDicomInstance()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3916
diff
changeset
|
3800 #endif |
4943
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3801 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3802 |
5321
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3803 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 1) |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3804 DicomInstance* DicomInstance::Load(const std::string& instanceId, |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3805 OrthancPluginLoadDicomInstanceMode mode) |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3806 { |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3807 OrthancPluginDicomInstance* instance = OrthancPluginLoadDicomInstance( |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3808 GetGlobalContext(), instanceId.c_str(), mode); |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3809 |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3810 if (instance == NULL) |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3811 { |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3812 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3813 } |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3814 else |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3815 { |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3816 boost::movelib::unique_ptr<DicomInstance> result(new DicomInstance(instance)); |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3817 result->toFree_ = true; |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3818 return result.release(); |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3819 } |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3820 } |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3821 #endif |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3822 |
5fae323b11ed
added OrthancPlugins::DicomInstance::Load()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5280
diff
changeset
|
3823 |
4943
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3824 #if HAS_ORTHANC_PLUGIN_WEBDAV == 1 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3825 static std::vector<std::string> WebDavConvertPath(uint32_t pathSize, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3826 const char* const* pathItems) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3827 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3828 std::vector<std::string> result(pathSize); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3829 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3830 for (uint32_t i = 0; i < pathSize; i++) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3831 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3832 result[i] = pathItems[i]; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3833 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3834 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3835 return result; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3836 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3837 #endif |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3838 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3839 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3840 #if HAS_ORTHANC_PLUGIN_WEBDAV == 1 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3841 static OrthancPluginErrorCode WebDavIsExistingFolder(uint8_t* isExisting, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3842 uint32_t pathSize, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3843 const char* const* pathItems, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3844 void* payload) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3845 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3846 IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3847 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3848 try |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3849 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3850 *isExisting = (that.IsExistingFolder(WebDavConvertPath(pathSize, pathItems)) ? 1 : 0); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3851 return OrthancPluginErrorCode_Success; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3852 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3853 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3854 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3855 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3856 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3857 catch (...) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3858 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3859 return OrthancPluginErrorCode_Plugin; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3860 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3861 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3862 #endif |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3863 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3864 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3865 #if HAS_ORTHANC_PLUGIN_WEBDAV == 1 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3866 static OrthancPluginErrorCode WebDavListFolder(uint8_t* isExisting, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3867 OrthancPluginWebDavCollection* collection, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3868 OrthancPluginWebDavAddFile addFile, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3869 OrthancPluginWebDavAddFolder addFolder, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3870 uint32_t pathSize, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3871 const char* const* pathItems, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3872 void* payload) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3873 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3874 IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3875 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3876 try |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3877 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3878 std::list<IWebDavCollection::FileInfo> files; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3879 std::list<IWebDavCollection::FolderInfo> subfolders; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3880 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3881 if (!that.ListFolder(files, subfolders, WebDavConvertPath(pathSize, pathItems))) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3882 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3883 *isExisting = 0; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3884 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3885 else |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3886 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3887 *isExisting = 1; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3888 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3889 for (std::list<IWebDavCollection::FileInfo>::const_iterator |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3890 it = files.begin(); it != files.end(); ++it) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3891 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3892 OrthancPluginErrorCode code = addFile( |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3893 collection, it->GetName().c_str(), it->GetContentSize(), |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3894 it->GetMimeType().c_str(), it->GetDateTime().c_str()); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3895 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3896 if (code != OrthancPluginErrorCode_Success) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3897 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3898 return code; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3899 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3900 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3901 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3902 for (std::list<IWebDavCollection::FolderInfo>::const_iterator it = |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3903 subfolders.begin(); it != subfolders.end(); ++it) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3904 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3905 OrthancPluginErrorCode code = addFolder( |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3906 collection, it->GetName().c_str(), it->GetDateTime().c_str()); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3907 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3908 if (code != OrthancPluginErrorCode_Success) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3909 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3910 return code; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3911 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3912 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3913 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3914 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3915 return OrthancPluginErrorCode_Success; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3916 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3917 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3918 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3919 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3920 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3921 catch (...) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3922 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3923 return OrthancPluginErrorCode_Plugin; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3924 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3925 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3926 #endif |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3927 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3928 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3929 #if HAS_ORTHANC_PLUGIN_WEBDAV == 1 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3930 static OrthancPluginErrorCode WebDavRetrieveFile(OrthancPluginWebDavCollection* collection, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3931 OrthancPluginWebDavRetrieveFile retrieveFile, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3932 uint32_t pathSize, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3933 const char* const* pathItems, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3934 void* payload) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3935 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3936 IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3937 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3938 try |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3939 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3940 std::string content, mime, dateTime; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3941 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3942 if (that.GetFile(content, mime, dateTime, WebDavConvertPath(pathSize, pathItems))) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3943 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3944 return retrieveFile(collection, content.empty() ? NULL : content.c_str(), |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3945 content.size(), mime.c_str(), dateTime.c_str()); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3946 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3947 else |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3948 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3949 // Inexisting file |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3950 return OrthancPluginErrorCode_Success; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3951 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3952 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3953 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3954 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3955 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3956 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3957 catch (...) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3958 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3959 return OrthancPluginErrorCode_InternalError; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3960 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3961 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3962 #endif |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3963 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3964 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3965 #if HAS_ORTHANC_PLUGIN_WEBDAV == 1 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3966 static OrthancPluginErrorCode WebDavStoreFileCallback(uint8_t* isReadOnly, /* out */ |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3967 uint32_t pathSize, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3968 const char* const* pathItems, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3969 const void* data, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3970 uint64_t size, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3971 void* payload) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3972 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3973 IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3974 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3975 try |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3976 { |
4973
17c91e054636
minor improvements
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4943
diff
changeset
|
3977 if (static_cast<uint64_t>(static_cast<size_t>(size)) != size) |
17c91e054636
minor improvements
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4943
diff
changeset
|
3978 { |
17c91e054636
minor improvements
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4943
diff
changeset
|
3979 ORTHANC_PLUGINS_THROW_EXCEPTION(NotEnoughMemory); |
17c91e054636
minor improvements
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4943
diff
changeset
|
3980 } |
17c91e054636
minor improvements
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4943
diff
changeset
|
3981 |
17c91e054636
minor improvements
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4943
diff
changeset
|
3982 *isReadOnly = (that.StoreFile(WebDavConvertPath(pathSize, pathItems), data, |
17c91e054636
minor improvements
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4943
diff
changeset
|
3983 static_cast<size_t>(size)) ? 1 : 0); |
4943
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3984 return OrthancPluginErrorCode_Success; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3985 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3986 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3987 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3988 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3989 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3990 catch (...) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3991 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3992 return OrthancPluginErrorCode_InternalError; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3993 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3994 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3995 #endif |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3996 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3997 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3998 #if HAS_ORTHANC_PLUGIN_WEBDAV == 1 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
3999 static OrthancPluginErrorCode WebDavCreateFolderCallback(uint8_t* isReadOnly, /* out */ |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4000 uint32_t pathSize, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4001 const char* const* pathItems, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4002 void* payload) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4003 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4004 IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4005 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4006 try |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4007 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4008 *isReadOnly = (that.CreateFolder(WebDavConvertPath(pathSize, pathItems)) ? 1 : 0); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4009 return OrthancPluginErrorCode_Success; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4010 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4011 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4012 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4013 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4014 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4015 catch (...) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4016 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4017 return OrthancPluginErrorCode_InternalError; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4018 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4019 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4020 #endif |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4021 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4022 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4023 #if HAS_ORTHANC_PLUGIN_WEBDAV == 1 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4024 static OrthancPluginErrorCode WebDavDeleteItemCallback(uint8_t* isReadOnly, /* out */ |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4025 uint32_t pathSize, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4026 const char* const* pathItems, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4027 void* payload) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4028 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4029 IWebDavCollection& that = *reinterpret_cast<IWebDavCollection*>(payload); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4030 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4031 try |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4032 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4033 *isReadOnly = (that.DeleteItem(WebDavConvertPath(pathSize, pathItems)) ? 1 : 0); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4034 return OrthancPluginErrorCode_Success; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4035 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4036 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4037 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4038 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4039 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4040 catch (...) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4041 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4042 return OrthancPluginErrorCode_InternalError; |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4043 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4044 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4045 #endif |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4046 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4047 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4048 #if HAS_ORTHANC_PLUGIN_WEBDAV == 1 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4049 void IWebDavCollection::Register(const std::string& uri, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4050 IWebDavCollection& collection) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4051 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4052 OrthancPluginErrorCode code = OrthancPluginRegisterWebDavCollection( |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4053 GetGlobalContext(), uri.c_str(), WebDavIsExistingFolder, WebDavListFolder, WebDavRetrieveFile, |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4054 WebDavStoreFileCallback, WebDavCreateFolderCallback, WebDavDeleteItemCallback, &collection); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4055 |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4056 if (code != OrthancPluginErrorCode_Success) |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4057 { |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4058 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4059 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4060 } |
47d734fa30f6
adding function OrthancPluginRegisterWebDavCollection() to the plugin SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4925
diff
changeset
|
4061 #endif |
5049 | 4062 |
4063 void GetHttpHeaders(std::map<std::string, std::string>& result, const OrthancPluginHttpRequest* request) | |
4064 { | |
4065 result.clear(); | |
4066 | |
4067 for (uint32_t i = 0; i < request->headersCount; ++i) | |
4068 { | |
4069 result[request->headersKeys[i]] = request->headersValues[i]; | |
4070 } | |
4071 } | |
5539
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4072 |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4073 #if !ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 4) |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4074 static void SetPluginProperty(const std::string& pluginIdentifier, |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4075 _OrthancPluginProperty property, |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4076 const std::string& value) |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4077 { |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4078 _OrthancPluginSetPluginProperty params; |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4079 params.plugin = pluginIdentifier.c_str(); |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4080 params.property = property; |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4081 params.value = value.c_str(); |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4082 |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4083 GetGlobalContext()->InvokeService(GetGlobalContext(), _OrthancPluginService_SetPluginProperty, ¶ms); |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4084 } |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4085 #endif |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4086 |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4087 void SetRootUri(const std::string& pluginIdentifier, |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4088 const std::string& uri) |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4089 { |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4090 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 4) |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4091 OrthancPluginSetRootUri2(GetGlobalContext(), pluginIdentifier.c_str(), uri.c_str()); |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4092 #else |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4093 SetPluginProperty(pluginIdentifier, _OrthancPluginProperty_RootUri, uri); |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4094 #endif |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4095 } |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4096 |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4097 void SetDescription(const std::string& pluginIdentifier, |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4098 const std::string& description) |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4099 { |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4100 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 4) |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4101 OrthancPluginSetDescription2(GetGlobalContext(), pluginIdentifier.c_str(), description.c_str()); |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4102 #else |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4103 SetPluginProperty(pluginIdentifier, _OrthancPluginProperty_Description, description); |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4104 #endif |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4105 } |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4106 |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4107 void ExtendOrthancExplorer(const std::string& pluginIdentifier, |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4108 const std::string& javascript) |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4109 { |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4110 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 4) |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4111 OrthancPluginExtendOrthancExplorer2(GetGlobalContext(), pluginIdentifier.c_str(), javascript.c_str()); |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4112 #else |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4113 SetPluginProperty(pluginIdentifier, _OrthancPluginProperty_OrthancExplorer, javascript); |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4114 #endif |
2b3eeacf636c
added SetRootUri(), SetDescription() and ExtendOrthancExplorer() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5485
diff
changeset
|
4115 } |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
4116 } |