Mercurial > hg > orthanc
annotate Core/Toolbox.cpp @ 3760:98b25ccc9b4a Orthanc-1.5.7
closing branch Orthanc-1.5.7
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Mon, 16 Mar 2020 12:17:07 +0100 |
parents | 962e5f00744b |
children | cbbe0bb80bd4 |
rev | line source |
---|---|
0 | 1 /** |
59 | 2 * Orthanc - A Lightweight, RESTful DICOM Store |
1900 | 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics |
1288
6e7e5ed91c2d
upgrade to year 2015
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1145
diff
changeset
|
4 * Department, University Hospital of Liege, Belgium |
3060
4e43e67f8ecf
preparing for 2019
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2954
diff
changeset
|
5 * Copyright (C) 2017-2019 Osimis S.A., Belgium |
0 | 6 * |
7 * This program is free software: you can redistribute it and/or | |
8 * modify it under the terms of the GNU General Public License as | |
9 * published by the Free Software Foundation, either version 3 of the | |
10 * License, or (at your option) any later version. | |
136 | 11 * |
12 * In addition, as a special exception, the copyright holders of this | |
13 * program give permission to link the code of its release with the | |
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it | |
15 * that use the same license as the "OpenSSL" library), and distribute | |
16 * the linked executables. You must obey the GNU General Public License | |
17 * in all respects for all of the code used other than "OpenSSL". If you | |
18 * modify file(s) with this exception, you may extend this exception to | |
19 * your version of the file(s), but you are not obligated to do so. If | |
20 * you do not wish to do so, delete this exception statement from your | |
21 * version. If you delete this exception statement from all source files | |
22 * in the program, then also delete it here. | |
0 | 23 * |
24 * This program is distributed in the hope that it will be useful, but | |
25 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
27 * General Public License for more details. | |
28 * | |
29 * You should have received a copy of the GNU General Public License | |
30 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
31 **/ | |
32 | |
33 | |
824
a811bdf8b8eb
precompiled headers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
34 #include "PrecompiledHeaders.h" |
0 | 35 #include "Toolbox.h" |
36 | |
59 | 37 #include "OrthancException.h" |
1486
f967bdf8534e
refactoring to Logging.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1480
diff
changeset
|
38 #include "Logging.h" |
0 | 39 |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
40 #include <boost/algorithm/string/case_conv.hpp> |
2143
fd5875662670
creation of namespace SystemToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2141
diff
changeset
|
41 #include <boost/algorithm/string/replace.hpp> |
fd5875662670
creation of namespace SystemToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2141
diff
changeset
|
42 #include <boost/lexical_cast.hpp> |
2931 | 43 #include <boost/regex.hpp> |
44 | |
45 #if BOOST_VERSION >= 106600 | |
46 # include <boost/uuid/detail/sha1.hpp> | |
47 #else | |
48 # include <boost/uuid/sha1.hpp> | |
49 #endif | |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
50 |
1397 | 51 #include <string> |
453 | 52 #include <stdint.h> |
0 | 53 #include <string.h> |
54 #include <algorithm> | |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
55 #include <ctype.h> |
1397 | 56 |
915
703bef350e89
Orthanc now relies entirely on boost::locale
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
890
diff
changeset
|
57 |
2137
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
58 #if ORTHANC_ENABLE_MD5 == 1 |
2931 | 59 // TODO - Could be replaced by <boost/uuid/detail/md5.hpp> starting |
60 // with Boost >= 1.66.0 | |
2137
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
61 # include "../Resources/ThirdParty/md5/md5.h" |
1479
8f28a1cd2354
possibility to disable md5 and base64 support in the toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1446
diff
changeset
|
62 #endif |
8f28a1cd2354
possibility to disable md5 and base64 support in the toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1446
diff
changeset
|
63 |
2137
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
64 #if ORTHANC_ENABLE_BASE64 == 1 |
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
65 # include "../Resources/ThirdParty/base64/base64.h" |
1479
8f28a1cd2354
possibility to disable md5 and base64 support in the toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1446
diff
changeset
|
66 #endif |
0 | 67 |
2367
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
68 #if ORTHANC_ENABLE_LOCALE == 1 |
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
69 # include <boost/locale.hpp> |
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
70 #endif |
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
71 |
2677
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
72 #if ORTHANC_ENABLE_SSL == 1 |
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
73 // For OpenSSL initialization and finalization |
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
74 # include <openssl/conf.h> |
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
75 # include <openssl/engine.h> |
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
76 # include <openssl/err.h> |
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
77 # include <openssl/evp.h> |
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
78 # include <openssl/ssl.h> |
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
79 #endif |
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
80 |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
81 |
1111
929bf8c2123d
Fixes for Visual Studio 2013 64bit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1103
diff
changeset
|
82 #if defined(_MSC_VER) && (_MSC_VER < 1800) |
929bf8c2123d
Fixes for Visual Studio 2013 64bit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1103
diff
changeset
|
83 // Patch for the missing "_strtoll" symbol when compiling with Visual Studio < 2013 |
570 | 84 extern "C" |
85 { | |
915
703bef350e89
Orthanc now relies entirely on boost::locale
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
890
diff
changeset
|
86 int64_t _strtoi64(const char *nptr, char **endptr, int base); |
703bef350e89
Orthanc now relies entirely on boost::locale
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
890
diff
changeset
|
87 int64_t strtoll(const char *nptr, char **endptr, int base) |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
88 { |
915
703bef350e89
Orthanc now relies entirely on boost::locale
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
890
diff
changeset
|
89 return _strtoi64(nptr, endptr, base); |
703bef350e89
Orthanc now relies entirely on boost::locale
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
890
diff
changeset
|
90 } |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
91 } |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
92 #endif |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
93 |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
94 |
2173 | 95 #if defined(_WIN32) |
96 # include <windows.h> // For ::Sleep | |
97 #endif | |
98 | |
2141 | 99 |
2136
dd609a99d39a
uniformization of the macro naming
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2129
diff
changeset
|
100 #if ORTHANC_ENABLE_PUGIXML == 1 |
2143
fd5875662670
creation of namespace SystemToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2141
diff
changeset
|
101 # include "ChunkedBuffer.h" |
1045
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
102 #endif |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
103 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
104 |
2512
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
105 // Inclusions for UUID |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
106 // http://stackoverflow.com/a/1626302 |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
107 |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
108 extern "C" |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
109 { |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
110 #if defined(_WIN32) |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
111 # include <rpc.h> |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
112 #else |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
113 # include <uuid/uuid.h> |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
114 #endif |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
115 } |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
116 |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
117 |
3333
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
118 #if defined(ORTHANC_STATIC_ICU) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
119 # if (ORTHANC_STATIC_ICU == 1 && ORTHANC_ENABLE_LOCALE == 1) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
120 # include <EmbeddedResources.h> |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
121 # include <unicode/udata.h> |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
122 # include <unicode/uloc.h> |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
123 # include "Compression/GzipCompressor.h" |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
124 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
125 static std::string globalIcuData_; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
126 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
127 extern "C" |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
128 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
129 // This is dummy content for the "icudt58_dat" (resp. "icudt63_dat") |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
130 // global variable from the autogenerated "icudt58l_dat.c" |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
131 // (resp. "icudt63l_dat.c") file that contains a huge C array. In |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
132 // Orthanc, this array is compressed using gzip and attached as a |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
133 // resource, then uncompressed during the launch of Orthanc by |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
134 // static function "InitializeIcu()". |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
135 struct |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
136 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
137 double bogus; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
138 uint8_t *bytes; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
139 } U_ICUDATA_ENTRY_POINT = { 0.0, NULL }; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
140 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
141 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
142 # endif |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
143 #endif |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
144 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
145 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
146 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
147 |
2512
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
148 |
59 | 149 namespace Orthanc |
0 | 150 { |
2513
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
151 void Toolbox::LinesIterator::FindEndOfLine() |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
152 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
153 lineEnd_ = lineStart_; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
154 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
155 while (lineEnd_ < content_.size() && |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
156 content_[lineEnd_] != '\n' && |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
157 content_[lineEnd_] != '\r') |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
158 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
159 lineEnd_ += 1; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
160 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
161 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
162 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
163 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
164 Toolbox::LinesIterator::LinesIterator(const std::string& content) : |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
165 content_(content), |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
166 lineStart_(0) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
167 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
168 FindEndOfLine(); |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
169 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
170 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
171 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
172 bool Toolbox::LinesIterator::GetLine(std::string& target) const |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
173 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
174 assert(lineStart_ <= content_.size() && |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
175 lineEnd_ <= content_.size() && |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
176 lineStart_ <= lineEnd_); |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
177 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
178 if (lineStart_ == content_.size()) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
179 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
180 return false; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
181 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
182 else |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
183 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
184 target = content_.substr(lineStart_, lineEnd_ - lineStart_); |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
185 return true; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
186 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
187 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
188 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
189 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
190 void Toolbox::LinesIterator::Next() |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
191 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
192 lineStart_ = lineEnd_; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
193 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
194 if (lineStart_ != content_.size()) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
195 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
196 assert(content_[lineStart_] == '\r' || |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
197 content_[lineStart_] == '\n'); |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
198 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
199 char second; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
200 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
201 if (content_[lineStart_] == '\r') |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
202 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
203 second = '\n'; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
204 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
205 else |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
206 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
207 second = '\r'; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
208 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
209 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
210 lineStart_ += 1; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
211 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
212 if (lineStart_ < content_.size() && |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
213 content_[lineStart_] == second) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
214 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
215 lineStart_ += 1; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
216 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
217 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
218 FindEndOfLine(); |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
219 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
220 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
221 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
222 |
0 | 223 void Toolbox::ToUpperCase(std::string& s) |
224 { | |
225 std::transform(s.begin(), s.end(), s.begin(), toupper); | |
226 } | |
227 | |
228 | |
229 void Toolbox::ToLowerCase(std::string& s) | |
230 { | |
231 std::transform(s.begin(), s.end(), s.begin(), tolower); | |
232 } | |
233 | |
234 | |
690
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
235 void Toolbox::ToUpperCase(std::string& result, |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
236 const std::string& source) |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
237 { |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
238 result = source; |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
239 ToUpperCase(result); |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
240 } |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
241 |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
242 void Toolbox::ToLowerCase(std::string& result, |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
243 const std::string& source) |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
244 { |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
245 result = source; |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
246 ToLowerCase(result); |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
247 } |
2e67366aab83
case-insensitive matching of Application Entity Titles
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
248 |
0 | 249 |
250 void Toolbox::SplitUriComponents(UriComponents& components, | |
251 const std::string& uri) | |
252 { | |
253 static const char URI_SEPARATOR = '/'; | |
254 | |
255 components.clear(); | |
256 | |
257 if (uri.size() == 0 || | |
258 uri[0] != URI_SEPARATOR) | |
259 { | |
59 | 260 throw OrthancException(ErrorCode_UriSyntax); |
0 | 261 } |
262 | |
263 // Count the number of slashes in the URI to make an assumption | |
264 // about the number of components in the URI | |
265 unsigned int estimatedSize = 0; | |
266 for (unsigned int i = 0; i < uri.size(); i++) | |
267 { | |
268 if (uri[i] == URI_SEPARATOR) | |
269 estimatedSize++; | |
270 } | |
271 | |
272 components.reserve(estimatedSize - 1); | |
273 | |
274 unsigned int start = 1; | |
275 unsigned int end = 1; | |
276 while (end < uri.size()) | |
277 { | |
278 // This is the loop invariant | |
279 assert(uri[start - 1] == '/' && (end >= start)); | |
280 | |
281 if (uri[end] == '/') | |
282 { | |
283 components.push_back(std::string(&uri[start], end - start)); | |
284 end++; | |
285 start = end; | |
286 } | |
287 else | |
288 { | |
289 end++; | |
290 } | |
291 } | |
292 | |
293 if (start < uri.size()) | |
294 { | |
295 components.push_back(std::string(&uri[start], end - start)); | |
296 } | |
207 | 297 |
298 for (size_t i = 0; i < components.size(); i++) | |
299 { | |
300 if (components[i].size() == 0) | |
301 { | |
302 // Empty component, as in: "/coucou//e" | |
303 throw OrthancException(ErrorCode_UriSyntax); | |
304 } | |
305 } | |
0 | 306 } |
307 | |
308 | |
966
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
309 void Toolbox::TruncateUri(UriComponents& target, |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
310 const UriComponents& source, |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
311 size_t fromLevel) |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
312 { |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
313 target.clear(); |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
314 |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
315 if (source.size() > fromLevel) |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
316 { |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
317 target.resize(source.size() - fromLevel); |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
318 |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
319 size_t j = 0; |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
320 for (size_t i = fromLevel; i < source.size(); i++, j++) |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
321 { |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
322 target[j] = source[i]; |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
323 } |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
324 |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
325 assert(j == target.size()); |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
326 } |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
327 } |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
328 |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
329 |
886652370ff2
accelerating REST API matching
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
957
diff
changeset
|
330 |
0 | 331 bool Toolbox::IsChildUri(const UriComponents& baseUri, |
332 const UriComponents& testedUri) | |
333 { | |
334 if (testedUri.size() < baseUri.size()) | |
335 { | |
336 return false; | |
337 } | |
338 | |
339 for (size_t i = 0; i < baseUri.size(); i++) | |
340 { | |
341 if (baseUri[i] != testedUri[i]) | |
342 return false; | |
343 } | |
344 | |
345 return true; | |
346 } | |
347 | |
348 | |
349 std::string Toolbox::FlattenUri(const UriComponents& components, | |
350 size_t fromLevel) | |
351 { | |
352 if (components.size() <= fromLevel) | |
353 { | |
354 return "/"; | |
355 } | |
356 else | |
357 { | |
358 std::string r; | |
359 | |
360 for (size_t i = fromLevel; i < components.size(); i++) | |
361 { | |
362 r += "/" + components[i]; | |
363 } | |
364 | |
365 return r; | |
366 } | |
367 } | |
368 | |
369 | |
2137
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
370 #if ORTHANC_ENABLE_MD5 == 1 |
22 | 371 static char GetHexadecimalCharacter(uint8_t value) |
372 { | |
373 assert(value < 16); | |
374 | |
375 if (value < 10) | |
1654
3727a09e7b53
fix some icc warnings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1648
diff
changeset
|
376 { |
22 | 377 return value + '0'; |
1654
3727a09e7b53
fix some icc warnings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1648
diff
changeset
|
378 } |
22 | 379 else |
1654
3727a09e7b53
fix some icc warnings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1648
diff
changeset
|
380 { |
22 | 381 return (value - 10) + 'a'; |
1654
3727a09e7b53
fix some icc warnings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1648
diff
changeset
|
382 } |
22 | 383 } |
384 | |
23 | 385 |
22 | 386 void Toolbox::ComputeMD5(std::string& result, |
387 const std::string& data) | |
388 { | |
693
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
389 if (data.size() > 0) |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
390 { |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
391 ComputeMD5(result, &data[0], data.size()); |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
392 } |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
393 else |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
394 { |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
395 ComputeMD5(result, NULL, 0); |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
396 } |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
397 } |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
398 |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
399 |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
400 void Toolbox::ComputeMD5(std::string& result, |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
401 const void* data, |
1833
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
402 size_t size) |
693
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
403 { |
22 | 404 md5_state_s state; |
405 md5_init(&state); | |
406 | |
1833
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
407 if (size > 0) |
22 | 408 { |
693
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
409 md5_append(&state, |
01d8611c4a60
md5 for attached files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
690
diff
changeset
|
410 reinterpret_cast<const md5_byte_t*>(data), |
1833
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
411 static_cast<int>(size)); |
22 | 412 } |
413 | |
414 md5_byte_t actualHash[16]; | |
415 md5_finish(&state, actualHash); | |
416 | |
417 result.resize(32); | |
418 for (unsigned int i = 0; i < 16; i++) | |
419 { | |
1654
3727a09e7b53
fix some icc warnings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1648
diff
changeset
|
420 result[2 * i] = GetHexadecimalCharacter(static_cast<uint8_t>(actualHash[i] / 16)); |
3727a09e7b53
fix some icc warnings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1648
diff
changeset
|
421 result[2 * i + 1] = GetHexadecimalCharacter(static_cast<uint8_t>(actualHash[i] % 16)); |
22 | 422 } |
423 } | |
1479
8f28a1cd2354
possibility to disable md5 and base64 support in the toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1446
diff
changeset
|
424 #endif |
24 | 425 |
426 | |
2137
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
427 #if ORTHANC_ENABLE_BASE64 == 1 |
809
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
803
diff
changeset
|
428 void Toolbox::EncodeBase64(std::string& result, |
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
803
diff
changeset
|
429 const std::string& data) |
24 | 430 { |
3326
b21d4cc8e5d1
speed up base64 decoding + added tests
Alain Mazy <alain@mazy.be>
parents:
3325
diff
changeset
|
431 result.clear(); |
3325
2e7c5c15ba25
reserve size for base64 decoding + avoid copy. In a test in WASM, encoding 3MB took 110ms instead of 1400ms previously
Alain Mazy <alain@mazy.be>
parents:
3322
diff
changeset
|
432 base64_encode(result, data); |
24 | 433 } |
434 | |
809
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
803
diff
changeset
|
435 void Toolbox::DecodeBase64(std::string& result, |
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
803
diff
changeset
|
436 const std::string& data) |
365 | 437 { |
1988
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
438 for (size_t i = 0; i < data.length(); i++) |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
439 { |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
440 if (!isalnum(data[i]) && |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
441 data[i] != '+' && |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
442 data[i] != '/' && |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
443 data[i] != '=') |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
444 { |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
445 // This is not a valid character for a Base64 string |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
446 throw OrthancException(ErrorCode_BadFileFormat); |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
447 } |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
448 } |
e29aea2349b9
test validity of base64 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
449 |
3326
b21d4cc8e5d1
speed up base64 decoding + added tests
Alain Mazy <alain@mazy.be>
parents:
3325
diff
changeset
|
450 result.clear(); |
3325
2e7c5c15ba25
reserve size for base64 decoding + avoid copy. In a test in WASM, encoding 3MB took 110ms instead of 1400ms previously
Alain Mazy <alain@mazy.be>
parents:
3322
diff
changeset
|
451 base64_decode(result, data); |
365 | 452 } |
1648 | 453 |
454 | |
1981
4b545a8b1f95
return code in Toolbox::DecodeDataUriScheme
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1976
diff
changeset
|
455 bool Toolbox::DecodeDataUriScheme(std::string& mime, |
1648 | 456 std::string& content, |
457 const std::string& source) | |
458 { | |
459 boost::regex pattern("data:([^;]+);base64,([a-zA-Z0-9=+/]*)", | |
460 boost::regex::icase /* case insensitive search */); | |
461 | |
462 boost::cmatch what; | |
463 if (regex_match(source.c_str(), what, pattern)) | |
464 { | |
465 mime = what[1]; | |
466 DecodeBase64(content, what[2]); | |
1981
4b545a8b1f95
return code in Toolbox::DecodeDataUriScheme
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1976
diff
changeset
|
467 return true; |
1648 | 468 } |
469 else | |
470 { | |
1981
4b545a8b1f95
return code in Toolbox::DecodeDataUriScheme
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1976
diff
changeset
|
471 return false; |
1648 | 472 } |
473 } | |
474 | |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1767
diff
changeset
|
475 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1767
diff
changeset
|
476 void Toolbox::EncodeDataUriScheme(std::string& result, |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1767
diff
changeset
|
477 const std::string& mime, |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1767
diff
changeset
|
478 const std::string& content) |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1767
diff
changeset
|
479 { |
3325
2e7c5c15ba25
reserve size for base64 decoding + avoid copy. In a test in WASM, encoding 3MB took 110ms instead of 1400ms previously
Alain Mazy <alain@mazy.be>
parents:
3322
diff
changeset
|
480 result = "data:" + mime + ";base64,"; |
2e7c5c15ba25
reserve size for base64 decoding + avoid copy. In a test in WASM, encoding 3MB took 110ms instead of 1400ms previously
Alain Mazy <alain@mazy.be>
parents:
3322
diff
changeset
|
481 base64_encode(result, content); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1767
diff
changeset
|
482 } |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1767
diff
changeset
|
483 |
1479
8f28a1cd2354
possibility to disable md5 and base64 support in the toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1446
diff
changeset
|
484 #endif |
8f28a1cd2354
possibility to disable md5 and base64 support in the toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1446
diff
changeset
|
485 |
365 | 486 |
2412
cad393b41bc3
handy shortcuts in DicomMap
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2373
diff
changeset
|
487 #if ORTHANC_ENABLE_LOCALE == 1 |
1557 | 488 static const char* GetBoostLocaleEncoding(const Encoding sourceEncoding) |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
489 { |
949
766a57997121
enumeration for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
942
diff
changeset
|
490 switch (sourceEncoding) |
766a57997121
enumeration for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
942
diff
changeset
|
491 { |
766a57997121
enumeration for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
942
diff
changeset
|
492 case Encoding_Utf8: |
1557 | 493 return "UTF-8"; |
949
766a57997121
enumeration for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
942
diff
changeset
|
494 |
956
2fd5a163776d
primitives for proper encoding handling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
950
diff
changeset
|
495 case Encoding_Ascii: |
1557 | 496 return "ASCII"; |
956
2fd5a163776d
primitives for proper encoding handling
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
950
diff
changeset
|
497 |
949
766a57997121
enumeration for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
942
diff
changeset
|
498 case Encoding_Latin1: |
1557 | 499 return "ISO-8859-1"; |
949
766a57997121
enumeration for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
942
diff
changeset
|
500 |
1087 | 501 case Encoding_Latin2: |
1557 | 502 return "ISO-8859-2"; |
1087 | 503 |
504 case Encoding_Latin3: | |
1557 | 505 return "ISO-8859-3"; |
1087 | 506 |
507 case Encoding_Latin4: | |
1557 | 508 return "ISO-8859-4"; |
1087 | 509 |
510 case Encoding_Latin5: | |
1557 | 511 return "ISO-8859-9"; |
1087 | 512 |
513 case Encoding_Cyrillic: | |
1557 | 514 return "ISO-8859-5"; |
1087 | 515 |
1347 | 516 case Encoding_Windows1251: |
1557 | 517 return "WINDOWS-1251"; |
1347 | 518 |
1087 | 519 case Encoding_Arabic: |
1557 | 520 return "ISO-8859-6"; |
1087 | 521 |
522 case Encoding_Greek: | |
1557 | 523 return "ISO-8859-7"; |
1087 | 524 |
525 case Encoding_Hebrew: | |
1557 | 526 return "ISO-8859-8"; |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1087
diff
changeset
|
527 |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1087
diff
changeset
|
528 case Encoding_Japanese: |
1557 | 529 return "SHIFT-JIS"; |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1087
diff
changeset
|
530 |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1087
diff
changeset
|
531 case Encoding_Chinese: |
1557 | 532 return "GB18030"; |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1087
diff
changeset
|
533 |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1087
diff
changeset
|
534 case Encoding_Thai: |
3230
4b042ec734c1
dynamic linking against libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
535 #if BOOST_LOCALE_WITH_ICU == 1 |
4b042ec734c1
dynamic linking against libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
536 return "tis620.2533"; |
4b042ec734c1
dynamic linking against libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
537 #else |
1557 | 538 return "TIS620.2533-0"; |
3230
4b042ec734c1
dynamic linking against libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
539 #endif |
1087 | 540 |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
541 case Encoding_Korean: |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
542 return "ISO-IR-149"; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
543 |
3218 | 544 case Encoding_JapaneseKanji: |
545 return "JIS"; | |
546 | |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3221
diff
changeset
|
547 case Encoding_SimplifiedChinese: |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3221
diff
changeset
|
548 return "GB2312"; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3221
diff
changeset
|
549 |
949
766a57997121
enumeration for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
942
diff
changeset
|
550 default: |
957
63973b76a51f
detection of encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
956
diff
changeset
|
551 throw OrthancException(ErrorCode_NotImplemented); |
949
766a57997121
enumeration for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
942
diff
changeset
|
552 } |
1557 | 553 } |
2412
cad393b41bc3
handy shortcuts in DicomMap
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2373
diff
changeset
|
554 #endif |
1557 | 555 |
556 | |
2367
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
557 #if ORTHANC_ENABLE_LOCALE == 1 |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
558 // http://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.12.html#sect_C.12.1.1.2 |
1557 | 559 std::string Toolbox::ConvertToUtf8(const std::string& source, |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
560 Encoding sourceEncoding, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
561 bool hasCodeExtensions) |
1557 | 562 { |
3333
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
563 #if ORTHANC_STATIC_ICU == 1 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
564 if (globalIcuData_.empty()) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
565 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
566 throw OrthancException(ErrorCode_BadSequenceOfCalls, |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
567 "Call Toolbox::InitializeGlobalLocale()"); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
568 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
569 #endif |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
570 |
2907
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
571 // The "::skip" flag makes boost skip invalid UTF-8 |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
572 // characters. This can occur in badly-encoded DICOM files. |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
573 |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
574 try |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
575 { |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
576 if (sourceEncoding == Encoding_Ascii) |
2907
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
577 { |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
578 return ConvertToAscii(source); |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
579 } |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
580 else |
2907
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
581 { |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
582 std::string s; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
583 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
584 if (sourceEncoding == Encoding_Utf8) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
585 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
586 // Already in UTF-8: No conversion is required, but we ensure |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
587 // the output is correctly encoded |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
588 s = boost::locale::conv::utf_to_utf<char>(source, boost::locale::conv::skip); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
589 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
590 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
591 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
592 const char* encoding = GetBoostLocaleEncoding(sourceEncoding); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
593 s = boost::locale::conv::to_utf<char>(source, encoding, boost::locale::conv::skip); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
594 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
595 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
596 if (hasCodeExtensions) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
597 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
598 std::string t; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
599 RemoveIso2022EscapeSequences(t, s); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
600 return t; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
601 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
602 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
603 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
604 return s; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
605 } |
2907
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
606 } |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
607 } |
3218 | 608 catch (std::runtime_error& e) |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
609 { |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
610 // Bad input string or bad encoding |
3218 | 611 LOG(INFO) << e.what(); |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
612 return ConvertToAscii(source); |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
613 } |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
614 } |
2367
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
615 #endif |
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
616 |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
617 |
2367
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
618 #if ORTHANC_ENABLE_LOCALE == 1 |
1557 | 619 std::string Toolbox::ConvertFromUtf8(const std::string& source, |
620 Encoding targetEncoding) | |
621 { | |
3333
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
622 #if ORTHANC_STATIC_ICU == 1 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
623 if (globalIcuData_.empty()) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
624 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
625 throw OrthancException(ErrorCode_BadSequenceOfCalls, |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
626 "Call Toolbox::InitializeGlobalLocale()"); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
627 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
628 #endif |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
629 |
2907
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
630 // The "::skip" flag makes boost skip invalid UTF-8 |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
631 // characters. This can occur in badly-encoded DICOM files. |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
632 |
1557 | 633 try |
634 { | |
2907
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
635 if (targetEncoding == Encoding_Utf8) |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
636 { |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
637 // Already in UTF-8: No conversion is required. |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
638 return boost::locale::conv::utf_to_utf<char>(source, boost::locale::conv::skip); |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
639 } |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
640 else if (targetEncoding == Encoding_Ascii) |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
641 { |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
642 return ConvertToAscii(source); |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
643 } |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
644 else |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
645 { |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
646 const char* encoding = GetBoostLocaleEncoding(targetEncoding); |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
647 return boost::locale::conv::from_utf<char>(source, encoding, boost::locale::conv::skip); |
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
648 } |
1557 | 649 } |
650 catch (std::runtime_error&) | |
651 { | |
652 // Bad input string or bad encoding | |
653 return ConvertToAscii(source); | |
654 } | |
655 } | |
2367
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
656 #endif |
1557 | 657 |
658 | |
2900 | 659 static bool IsAsciiCharacter(uint8_t c) |
660 { | |
661 return (c != 0 && | |
662 c <= 127 && | |
663 (c == '\n' || !iscntrl(c))); | |
664 } | |
665 | |
666 | |
2129
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
667 bool Toolbox::IsAsciiString(const void* data, |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
668 size_t size) |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
669 { |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
670 const uint8_t* p = reinterpret_cast<const uint8_t*>(data); |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
671 |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
672 for (size_t i = 0; i < size; i++, p++) |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
673 { |
2900 | 674 if (!IsAsciiCharacter(*p)) |
2129
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
675 { |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
676 return false; |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
677 } |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
678 } |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
679 |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
680 return true; |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
681 } |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
682 |
0c09d1af22f3
"/tools/invalidate-tags" to invalidate the JSON summary of all the DICOM files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2087
diff
changeset
|
683 |
2442
330349d712f9
fix Toolbox::IsAsciiString
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2412
diff
changeset
|
684 bool Toolbox::IsAsciiString(const std::string& s) |
330349d712f9
fix Toolbox::IsAsciiString
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2412
diff
changeset
|
685 { |
330349d712f9
fix Toolbox::IsAsciiString
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2412
diff
changeset
|
686 return IsAsciiString(s.c_str(), s.size()); |
330349d712f9
fix Toolbox::IsAsciiString
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2412
diff
changeset
|
687 } |
330349d712f9
fix Toolbox::IsAsciiString
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2412
diff
changeset
|
688 |
330349d712f9
fix Toolbox::IsAsciiString
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2412
diff
changeset
|
689 |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
690 std::string Toolbox::ConvertToAscii(const std::string& source) |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
691 { |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
692 std::string result; |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
693 |
942
b3f6fb1130cd
fixes thanks to cppcheck
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
930
diff
changeset
|
694 result.reserve(source.size() + 1); |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
695 for (size_t i = 0; i < source.size(); i++) |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
696 { |
2900 | 697 if (IsAsciiCharacter(source[i])) |
107
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
698 { |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
699 result.push_back(source[i]); |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
700 } |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
701 } |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
702 |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
703 return result; |
3b45473c0a73
replace boost::locale with iconv for debian
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
87
diff
changeset
|
704 } |
177 | 705 |
1833
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
706 |
177 | 707 void Toolbox::ComputeSHA1(std::string& result, |
1833
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
708 const void* data, |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
709 size_t size) |
177 | 710 { |
560
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
711 boost::uuids::detail::sha1 sha1; |
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
712 |
1833
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
713 if (size > 0) |
177 | 714 { |
1833
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
715 sha1.process_bytes(data, size); |
177 | 716 } |
717 | |
560
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
718 unsigned int digest[5]; |
177 | 719 |
720 // Sanity check for the memory layout: A SHA-1 digest is 160 bits wide | |
560
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
721 assert(sizeof(unsigned int) == 4 && sizeof(digest) == (160 / 8)); |
177 | 722 |
560
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
723 sha1.get_digest(digest); |
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
724 |
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
725 result.resize(8 * 5 + 4); |
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
726 sprintf(&result[0], "%08x-%08x-%08x-%08x-%08x", |
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
727 digest[0], |
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
728 digest[1], |
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
729 digest[2], |
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
730 digest[3], |
69c024f9c06b
fix of Debian bug #724947
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
483
diff
changeset
|
731 digest[4]); |
177 | 732 } |
733 | |
1833
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
734 void Toolbox::ComputeSHA1(std::string& result, |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
735 const std::string& data) |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
736 { |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
737 if (data.size() > 0) |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
738 { |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
739 ComputeSHA1(result, data.c_str(), data.size()); |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
740 } |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
741 else |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
742 { |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
743 ComputeSHA1(result, NULL, 0); |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
744 } |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
745 } |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
746 |
47d032c48818
"OrthancPluginComputeMd5()" and "OrthancPluginComputeSha1()" to compute MD5/SHA-1 hash
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1818
diff
changeset
|
747 |
3401 | 748 bool Toolbox::IsSHA1(const void* str, |
1446
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
749 size_t size) |
402 | 750 { |
1446
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
751 if (size == 0) |
1428 | 752 { |
753 return false; | |
754 } | |
755 | |
3401 | 756 const char* start = reinterpret_cast<const char*>(str); |
757 const char* end = start + size; | |
1428 | 758 |
759 // Trim the beginning of the string | |
760 while (start < end) | |
761 { | |
762 if (*start == '\0' || | |
763 isspace(*start)) | |
764 { | |
765 start++; | |
766 } | |
767 else | |
768 { | |
769 break; | |
770 } | |
771 } | |
772 | |
773 // Trim the trailing of the string | |
774 while (start < end) | |
775 { | |
776 if (*(end - 1) == '\0' || | |
777 isspace(*(end - 1))) | |
778 { | |
779 end--; | |
780 } | |
781 else | |
782 { | |
783 break; | |
784 } | |
785 } | |
786 | |
787 if (end - start != 44) | |
402 | 788 { |
789 return false; | |
790 } | |
791 | |
792 for (unsigned int i = 0; i < 44; i++) | |
793 { | |
794 if (i == 8 || | |
795 i == 17 || | |
796 i == 26 || | |
797 i == 35) | |
798 { | |
1428 | 799 if (start[i] != '-') |
402 | 800 return false; |
801 } | |
802 else | |
803 { | |
1428 | 804 if (!isalnum(start[i])) |
402 | 805 return false; |
806 } | |
807 } | |
808 | |
809 return true; | |
810 } | |
811 | |
1397 | 812 |
1446
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
813 bool Toolbox::IsSHA1(const std::string& s) |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
814 { |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
815 if (s.size() == 0) |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
816 { |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
817 return false; |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
818 } |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
819 else |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
820 { |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
821 return IsSHA1(s.c_str(), s.size()); |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
822 } |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
823 } |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
824 |
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1430
diff
changeset
|
825 |
247
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
826 std::string Toolbox::StripSpaces(const std::string& source) |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
827 { |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
828 size_t first = 0; |
177 | 829 |
247
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
830 while (first < source.length() && |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
831 isspace(source[first])) |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
832 { |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
833 first++; |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
834 } |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
835 |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
836 if (first == source.length()) |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
837 { |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
838 // String containing only spaces |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
839 return ""; |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
840 } |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
841 |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
842 size_t last = source.length(); |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
843 while (last > first && |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
844 isspace(source[last - 1])) |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
845 { |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
846 last--; |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
847 } |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
848 |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
849 assert(first <= last); |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
850 return source.substr(first, last - first); |
c9b3ba0fd140
path management in zip files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
207
diff
changeset
|
851 } |
336 | 852 |
853 | |
337 | 854 static char Hex2Dec(char c) |
336 | 855 { |
856 return ((c >= '0' && c <= '9') ? c - '0' : | |
857 ((c >= 'a' && c <= 'f') ? c - 'a' + 10 : c - 'A' + 10)); | |
858 } | |
859 | |
860 void Toolbox::UrlDecode(std::string& s) | |
861 { | |
862 // http://en.wikipedia.org/wiki/Percent-encoding | |
863 // http://www.w3schools.com/tags/ref_urlencode.asp | |
864 // http://stackoverflow.com/questions/154536/encode-decode-urls-in-c | |
865 | |
866 if (s.size() == 0) | |
867 { | |
868 return; | |
869 } | |
870 | |
871 size_t source = 0; | |
872 size_t target = 0; | |
873 | |
874 while (source < s.size()) | |
875 { | |
876 if (s[source] == '%' && | |
877 source + 2 < s.size() && | |
878 isalnum(s[source + 1]) && | |
879 isalnum(s[source + 2])) | |
880 { | |
881 s[target] = (Hex2Dec(s[source + 1]) << 4) | Hex2Dec(s[source + 2]); | |
882 source += 3; | |
883 target += 1; | |
884 } | |
885 else | |
886 { | |
887 if (s[source] == '+') | |
888 s[target] = ' '; | |
889 else | |
890 s[target] = s[source]; | |
891 | |
892 source++; | |
893 target++; | |
894 } | |
895 } | |
896 | |
897 s.resize(target); | |
898 } | |
453 | 899 |
900 | |
901 Endianness Toolbox::DetectEndianness() | |
902 { | |
903 // http://sourceforge.net/p/predef/wiki/Endianness/ | |
904 | |
905 uint8_t buffer[4]; | |
906 | |
907 buffer[0] = 0x00; | |
908 buffer[1] = 0x01; | |
909 buffer[2] = 0x02; | |
910 buffer[3] = 0x03; | |
911 | |
912 switch (*((uint32_t *)buffer)) | |
913 { | |
914 case 0x00010203: | |
915 return Endianness_Big; | |
916 | |
917 case 0x03020100: | |
918 return Endianness_Little; | |
919 | |
920 default: | |
921 throw OrthancException(ErrorCode_NotImplemented); | |
922 } | |
923 } | |
608 | 924 |
925 | |
926 std::string Toolbox::WildcardToRegularExpression(const std::string& source) | |
927 { | |
928 // TODO - Speed up this with a regular expression | |
929 | |
930 std::string result = source; | |
931 | |
932 // Escape all special characters | |
933 boost::replace_all(result, "\\", "\\\\"); | |
934 boost::replace_all(result, "^", "\\^"); | |
935 boost::replace_all(result, ".", "\\."); | |
936 boost::replace_all(result, "$", "\\$"); | |
937 boost::replace_all(result, "|", "\\|"); | |
938 boost::replace_all(result, "(", "\\("); | |
939 boost::replace_all(result, ")", "\\)"); | |
940 boost::replace_all(result, "[", "\\["); | |
941 boost::replace_all(result, "]", "\\]"); | |
942 boost::replace_all(result, "+", "\\+"); | |
943 boost::replace_all(result, "/", "\\/"); | |
944 boost::replace_all(result, "{", "\\{"); | |
945 boost::replace_all(result, "}", "\\}"); | |
946 | |
947 // Convert wildcards '*' and '?' to their regex equivalents | |
948 boost::replace_all(result, "?", "."); | |
949 boost::replace_all(result, "*", ".*"); | |
950 | |
951 return result; | |
952 } | |
953 | |
954 | |
955 void Toolbox::TokenizeString(std::vector<std::string>& result, | |
956 const std::string& value, | |
957 char separator) | |
958 { | |
3382
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
959 size_t countSeparators = 0; |
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
960 |
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
961 for (size_t i = 0; i < value.size(); i++) |
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
962 { |
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
963 if (value[i] == separator) |
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
964 { |
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
965 countSeparators++; |
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
966 } |
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
967 } |
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
968 |
608 | 969 result.clear(); |
3382
a2862d4484f5
optimization of Toolbox::TokenizeString()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3333
diff
changeset
|
970 result.reserve(countSeparators + 1); |
608 | 971 |
972 std::string currentItem; | |
973 | |
974 for (size_t i = 0; i < value.size(); i++) | |
975 { | |
976 if (value[i] == separator) | |
977 { | |
978 result.push_back(currentItem); | |
979 currentItem.clear(); | |
980 } | |
981 else | |
982 { | |
983 currentItem.push_back(value[i]); | |
984 } | |
985 } | |
986 | |
987 result.push_back(currentItem); | |
988 } | |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
707
diff
changeset
|
989 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
707
diff
changeset
|
990 |
2136
dd609a99d39a
uniformization of the macro naming
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2129
diff
changeset
|
991 #if ORTHANC_ENABLE_PUGIXML == 1 |
1045
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
992 class ChunkedBufferWriter : public pugi::xml_writer |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
993 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
994 private: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
995 ChunkedBuffer buffer_; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
996 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
997 public: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
998 virtual void write(const void *data, size_t size) |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
999 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1000 if (size > 0) |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1001 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1002 buffer_.AddChunk(reinterpret_cast<const char*>(data), size); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1003 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1004 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1005 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1006 void Flatten(std::string& s) |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1007 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1008 buffer_.Flatten(s); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1009 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1010 }; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1011 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1012 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1013 static void JsonToXmlInternal(pugi::xml_node& target, |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1014 const Json::Value& source, |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1015 const std::string& arrayElement) |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1016 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1017 // http://jsoncpp.sourceforge.net/value_8h_source.html#l00030 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1018 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1019 switch (source.type()) |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1020 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1021 case Json::nullValue: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1022 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1023 target.append_child(pugi::node_pcdata).set_value("null"); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1024 break; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1025 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1026 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1027 case Json::intValue: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1028 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1029 std::string s = boost::lexical_cast<std::string>(source.asInt()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1030 target.append_child(pugi::node_pcdata).set_value(s.c_str()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1031 break; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1032 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1033 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1034 case Json::uintValue: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1035 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1036 std::string s = boost::lexical_cast<std::string>(source.asUInt()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1037 target.append_child(pugi::node_pcdata).set_value(s.c_str()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1038 break; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1039 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1040 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1041 case Json::realValue: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1042 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1043 std::string s = boost::lexical_cast<std::string>(source.asFloat()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1044 target.append_child(pugi::node_pcdata).set_value(s.c_str()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1045 break; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1046 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1047 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1048 case Json::stringValue: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1049 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1050 target.append_child(pugi::node_pcdata).set_value(source.asString().c_str()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1051 break; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1052 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1053 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1054 case Json::booleanValue: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1055 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1056 target.append_child(pugi::node_pcdata).set_value(source.asBool() ? "true" : "false"); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1057 break; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1058 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1059 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1060 case Json::arrayValue: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1061 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1062 for (Json::Value::ArrayIndex i = 0; i < source.size(); i++) |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1063 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1064 pugi::xml_node node = target.append_child(); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1065 node.set_name(arrayElement.c_str()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1066 JsonToXmlInternal(node, source[i], arrayElement); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1067 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1068 break; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1069 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1070 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1071 case Json::objectValue: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1072 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1073 Json::Value::Members members = source.getMemberNames(); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1074 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1075 for (size_t i = 0; i < members.size(); i++) |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1076 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1077 pugi::xml_node node = target.append_child(); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1078 node.set_name(members[i].c_str()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1079 JsonToXmlInternal(node, source[members[i]], arrayElement); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1080 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1081 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1082 break; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1083 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1084 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1085 default: |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1086 throw OrthancException(ErrorCode_NotImplemented); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1087 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1088 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1089 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1090 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1091 void Toolbox::JsonToXml(std::string& target, |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1092 const Json::Value& source, |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1093 const std::string& rootElement, |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1094 const std::string& arrayElement) |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1095 { |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1096 pugi::xml_document doc; |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1097 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1098 pugi::xml_node n = doc.append_child(rootElement.c_str()); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1099 JsonToXmlInternal(n, source, arrayElement); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1100 |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1101 pugi::xml_node decl = doc.prepend_child(pugi::node_declaration); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1102 decl.append_attribute("version").set_value("1.0"); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1103 decl.append_attribute("encoding").set_value("utf-8"); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1104 |
3203
810772486249
URI "/instances/.../file" can return DICOMweb JSON or XML, depending on Accept header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1105 XmlToString(target, doc); |
810772486249
URI "/instances/.../file" can return DICOMweb JSON or XML, depending on Accept header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1106 } |
810772486249
URI "/instances/.../file" can return DICOMweb JSON or XML, depending on Accept header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1107 |
810772486249
URI "/instances/.../file" can return DICOMweb JSON or XML, depending on Accept header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1108 void Toolbox::XmlToString(std::string& target, |
810772486249
URI "/instances/.../file" can return DICOMweb JSON or XML, depending on Accept header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1109 const pugi::xml_document& source) |
810772486249
URI "/instances/.../file" can return DICOMweb JSON or XML, depending on Accept header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1110 { |
1045
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1111 ChunkedBufferWriter writer; |
3203
810772486249
URI "/instances/.../file" can return DICOMweb JSON or XML, depending on Accept header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1112 source.save(writer, " ", pugi::format_default, pugi::encoding_utf8); |
1045
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1113 writer.Flatten(target); |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1114 } |
0bfeeb6d340f
json to xml conversion with pugixml
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
971
diff
changeset
|
1115 #endif |
1050
64f1842aae2e
Toolbox::ExecuteSystemCommand
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1045
diff
changeset
|
1116 |
64f1842aae2e
Toolbox::ExecuteSystemCommand
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1045
diff
changeset
|
1117 |
1102
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1118 |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1119 bool Toolbox::IsInteger(const std::string& str) |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1120 { |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1121 std::string s = StripSpaces(str); |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1122 |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1123 if (s.size() == 0) |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1124 { |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1125 return false; |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1126 } |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1127 |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1128 size_t pos = 0; |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1129 if (s[0] == '-') |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1130 { |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1131 if (s.size() == 1) |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1132 { |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1133 return false; |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1134 } |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1135 |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1136 pos = 1; |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1137 } |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1138 |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1139 while (pos < s.size()) |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1140 { |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1141 if (!isdigit(s[pos])) |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1142 { |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1143 return false; |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1144 } |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1145 |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1146 pos++; |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1147 } |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1148 |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1149 return true; |
ce6386b37afd
avoid unnecessary exceptions on Orthanc startup
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1101
diff
changeset
|
1150 } |
1424
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1151 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1152 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1153 void Toolbox::CopyJsonWithoutComments(Json::Value& target, |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1154 const Json::Value& source) |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1155 { |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1156 switch (source.type()) |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1157 { |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1158 case Json::nullValue: |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1159 target = Json::nullValue; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1160 break; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1161 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1162 case Json::intValue: |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1163 target = source.asInt64(); |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1164 break; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1165 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1166 case Json::uintValue: |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1167 target = source.asUInt64(); |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1168 break; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1169 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1170 case Json::realValue: |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1171 target = source.asDouble(); |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1172 break; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1173 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1174 case Json::stringValue: |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1175 target = source.asString(); |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1176 break; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1177 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1178 case Json::booleanValue: |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1179 target = source.asBool(); |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1180 break; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1181 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1182 case Json::arrayValue: |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1183 { |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1184 target = Json::arrayValue; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1185 for (Json::Value::ArrayIndex i = 0; i < source.size(); i++) |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1186 { |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1187 Json::Value& item = target.append(Json::nullValue); |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1188 CopyJsonWithoutComments(item, source[i]); |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1189 } |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1190 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1191 break; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1192 } |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1193 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1194 case Json::objectValue: |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1195 { |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1196 target = Json::objectValue; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1197 Json::Value::Members members = source.getMemberNames(); |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1198 for (Json::Value::ArrayIndex i = 0; i < members.size(); i++) |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1199 { |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1200 const std::string item = members[i]; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1201 CopyJsonWithoutComments(target[item], source[item]); |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1202 } |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1203 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1204 break; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1205 } |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1206 |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1207 default: |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1208 break; |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1209 } |
fe384a9d3b51
OrthancPluginGetConfiguration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1397
diff
changeset
|
1210 } |
1430
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1211 |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1212 |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1213 bool Toolbox::StartsWith(const std::string& str, |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1214 const std::string& prefix) |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1215 { |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1216 if (str.size() < prefix.size()) |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1217 { |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1218 return false; |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1219 } |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1220 else |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1221 { |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1222 return str.compare(0, prefix.size(), prefix) == 0; |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1223 } |
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1428
diff
changeset
|
1224 } |
2043
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1225 |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1226 |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1227 static bool IsUnreservedCharacter(char c) |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1228 { |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1229 // This function checks whether "c" is an unserved character |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1230 // wrt. an URI percent-encoding |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1231 // https://en.wikipedia.org/wiki/Percent-encoding#Percent-encoding%5Fin%5Fa%5FURI |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1232 |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1233 return ((c >= 'A' && c <= 'Z') || |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1234 (c >= 'a' && c <= 'z') || |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1235 (c >= '0' && c <= '9') || |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1236 c == '-' || |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1237 c == '_' || |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1238 c == '.' || |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1239 c == '~'); |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1240 } |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1241 |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1242 void Toolbox::UriEncode(std::string& target, |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1243 const std::string& source) |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1244 { |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1245 // Estimate the length of the percent-encoded URI |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1246 size_t length = 0; |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1247 |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1248 for (size_t i = 0; i < source.size(); i++) |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1249 { |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1250 if (IsUnreservedCharacter(source[i])) |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1251 { |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1252 length += 1; |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1253 } |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1254 else |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1255 { |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1256 // This character must be percent-encoded |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1257 length += 3; |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1258 } |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1259 } |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1260 |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1261 target.clear(); |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1262 target.reserve(length); |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1263 |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1264 for (size_t i = 0; i < source.size(); i++) |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1265 { |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1266 if (IsUnreservedCharacter(source[i])) |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1267 { |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1268 target.push_back(source[i]); |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1269 } |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1270 else |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1271 { |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1272 // This character must be percent-encoded |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1273 uint8_t byte = static_cast<uint8_t>(source[i]); |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1274 uint8_t a = byte >> 4; |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1275 uint8_t b = byte & 0x0f; |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1276 |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1277 target.push_back('%'); |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1278 target.push_back(a < 10 ? a + '0' : a - 10 + 'A'); |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1279 target.push_back(b < 10 ? b + '0' : b - 10 + 'A'); |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1280 } |
35ccba7adae9
Toolbox::UriEncode
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2017
diff
changeset
|
1281 } |
2071 | 1282 } |
1283 | |
1284 | |
1285 static bool HasField(const Json::Value& json, | |
1286 const std::string& key, | |
1287 Json::ValueType expectedType) | |
1288 { | |
1289 if (json.type() != Json::objectValue || | |
1290 !json.isMember(key)) | |
1291 { | |
1292 return false; | |
1293 } | |
1294 else if (json[key].type() == expectedType) | |
1295 { | |
1296 return true; | |
1297 } | |
1298 else | |
1299 { | |
1300 throw OrthancException(ErrorCode_BadParameterType); | |
1301 } | |
1302 } | |
1303 | |
1304 | |
1305 std::string Toolbox::GetJsonStringField(const Json::Value& json, | |
1306 const std::string& key, | |
1307 const std::string& defaultValue) | |
1308 { | |
1309 if (HasField(json, key, Json::stringValue)) | |
1310 { | |
1311 return json[key].asString(); | |
1312 } | |
1313 else | |
1314 { | |
1315 return defaultValue; | |
1316 } | |
1317 } | |
1318 | |
1319 | |
1320 bool Toolbox::GetJsonBooleanField(const ::Json::Value& json, | |
1321 const std::string& key, | |
1322 bool defaultValue) | |
1323 { | |
1324 if (HasField(json, key, Json::booleanValue)) | |
1325 { | |
1326 return json[key].asBool(); | |
1327 } | |
1328 else | |
1329 { | |
1330 return defaultValue; | |
1331 } | |
1332 } | |
1333 | |
1334 | |
1335 int Toolbox::GetJsonIntegerField(const ::Json::Value& json, | |
1336 const std::string& key, | |
1337 int defaultValue) | |
1338 { | |
1339 if (HasField(json, key, Json::intValue)) | |
1340 { | |
1341 return json[key].asInt(); | |
1342 } | |
1343 else | |
1344 { | |
1345 return defaultValue; | |
1346 } | |
1347 } | |
1348 | |
1349 | |
1350 unsigned int Toolbox::GetJsonUnsignedIntegerField(const ::Json::Value& json, | |
1351 const std::string& key, | |
1352 unsigned int defaultValue) | |
1353 { | |
1354 int v = GetJsonIntegerField(json, key, defaultValue); | |
1355 | |
1356 if (v < 0) | |
1357 { | |
1358 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
1359 } | |
1360 else | |
1361 { | |
1362 return static_cast<unsigned int>(v); | |
1363 } | |
1364 } | |
2140 | 1365 |
1366 | |
2141 | 1367 bool Toolbox::IsUuid(const std::string& str) |
1368 { | |
1369 if (str.size() != 36) | |
1370 { | |
1371 return false; | |
1372 } | |
1373 | |
1374 for (size_t i = 0; i < str.length(); i++) | |
1375 { | |
1376 if (i == 8 || i == 13 || i == 18 || i == 23) | |
1377 { | |
1378 if (str[i] != '-') | |
1379 return false; | |
1380 } | |
1381 else | |
1382 { | |
1383 if (!isalnum(str[i])) | |
1384 return false; | |
1385 } | |
1386 } | |
1387 | |
1388 return true; | |
1389 } | |
1390 | |
1391 | |
1392 bool Toolbox::StartsWithUuid(const std::string& str) | |
1393 { | |
1394 if (str.size() < 36) | |
1395 { | |
1396 return false; | |
1397 } | |
1398 | |
1399 if (str.size() == 36) | |
1400 { | |
1401 return IsUuid(str); | |
1402 } | |
1403 | |
1404 assert(str.size() > 36); | |
1405 if (!isspace(str[36])) | |
1406 { | |
1407 return false; | |
1408 } | |
1409 | |
1410 return IsUuid(str.substr(0, 36)); | |
1411 } | |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1412 |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1413 |
2367
2aff870c2c58
refactoring of BoostConfiguration.cmake
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2351
diff
changeset
|
1414 #if ORTHANC_ENABLE_LOCALE == 1 |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1415 static std::auto_ptr<std::locale> globalLocale_; |
2334 | 1416 |
1417 static bool SetGlobalLocale(const char* locale) | |
1418 { | |
1419 globalLocale_.reset(NULL); | |
1420 | |
1421 try | |
1422 { | |
1423 if (locale == NULL) | |
1424 { | |
1425 LOG(WARNING) << "Falling back to system-wide default locale"; | |
1426 globalLocale_.reset(new std::locale()); | |
1427 } | |
1428 else | |
1429 { | |
2351 | 1430 LOG(INFO) << "Using locale: \"" << locale << "\" for case-insensitive comparison of strings"; |
2334 | 1431 globalLocale_.reset(new std::locale(locale)); |
1432 } | |
1433 } | |
1434 catch (std::runtime_error&) | |
1435 { | |
1436 } | |
1437 | |
1438 return (globalLocale_.get() != NULL); | |
1439 } | |
3333
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1440 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1441 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1442 static void InitializeIcu() |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1443 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1444 #if ORTHANC_STATIC_ICU == 1 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1445 if (globalIcuData_.empty()) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1446 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1447 LOG(INFO) << "Setting up the ICU common data"; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1448 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1449 GzipCompressor compressor; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1450 compressor.Uncompress(globalIcuData_, |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1451 EmbeddedResources::GetFileResourceBuffer(EmbeddedResources::LIBICU_DATA), |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1452 EmbeddedResources::GetFileResourceSize(EmbeddedResources::LIBICU_DATA)); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1453 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1454 std::string md5; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1455 Toolbox::ComputeMD5(md5, globalIcuData_); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1456 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1457 if (md5 != ORTHANC_ICU_DATA_MD5 || |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1458 globalIcuData_.empty()) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1459 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1460 throw OrthancException(ErrorCode_InternalError, |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1461 "Cannot decode the ICU common data"); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1462 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1463 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1464 // "ICU data is designed to be 16-aligned" |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1465 // http://userguide.icu-project.org/icudata#TOC-Alignment |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1466 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1467 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1468 static const size_t ALIGN = 16; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1469 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1470 UErrorCode status = U_ZERO_ERROR; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1471 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1472 if (reinterpret_cast<intptr_t>(globalIcuData_.c_str()) % ALIGN == 0) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1473 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1474 // Data is already properly aligned |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1475 udata_setCommonData(globalIcuData_.c_str(), &status); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1476 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1477 else |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1478 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1479 std::string aligned; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1480 aligned.resize(globalIcuData_.size() + ALIGN - 1); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1481 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1482 intptr_t offset = reinterpret_cast<intptr_t>(aligned.c_str()) % ALIGN; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1483 if (offset != 0) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1484 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1485 offset = ALIGN - offset; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1486 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1487 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1488 if (offset + globalIcuData_.size() > aligned.size()) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1489 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1490 throw OrthancException(ErrorCode_InternalError, "Cannot align on 16-bytes boundary"); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1491 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1492 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1493 // We don't use "memcpy()", as it expects its data to be aligned |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1494 const uint8_t* p = reinterpret_cast<uint8_t*>(&globalIcuData_[0]); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1495 uint8_t* q = reinterpret_cast<uint8_t*>(&aligned[0]) + offset; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1496 for (size_t i = 0; i < globalIcuData_.size(); i++, p++, q++) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1497 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1498 *q = *p; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1499 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1500 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1501 globalIcuData_.swap(aligned); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1502 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1503 const uint8_t* data = reinterpret_cast<const uint8_t*>(globalIcuData_.c_str()) + offset; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1504 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1505 if (reinterpret_cast<intptr_t>(data) % ALIGN != 0) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1506 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1507 throw OrthancException(ErrorCode_InternalError, "Cannot align on 16-bytes boundary"); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1508 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1509 else |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1510 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1511 udata_setCommonData(data, &status); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1512 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1513 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1514 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1515 if (status != U_ZERO_ERROR) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1516 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1517 throw OrthancException(ErrorCode_InternalError, "Cannot initialize ICU"); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1518 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1519 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1520 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1521 if (Toolbox::DetectEndianness() != Endianness_Little) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1522 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1523 // TODO - The data table must be swapped (uint16_t) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1524 throw OrthancException(ErrorCode_NotImplemented); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1525 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1526 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1527 // "First-use of ICU from a single thread before the |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1528 // multi-threaded use of ICU begins", to make sure everything is |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1529 // properly initialized (should not be mandatory in our |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1530 // case). We let boost handle calls to "u_init()" and "u_cleanup()". |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1531 // http://userguide.icu-project.org/design#TOC-ICU-Initialization-and-Termination |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1532 uloc_getDefault(); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1533 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1534 #endif |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1535 } |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1536 |
2330
9c7a80c87ae9
"Locale" configuration option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2326
diff
changeset
|
1537 void Toolbox::InitializeGlobalLocale(const char* locale) |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1538 { |
3333
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1539 InitializeIcu(); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1540 |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1541 // Make Orthanc use English, United States locale |
2334 | 1542 // Linux: use "en_US.UTF-8" |
1543 // Windows: use "" | |
1544 // Wine: use NULL | |
1545 | |
1546 #if defined(__MINGW32__) | |
1547 // Visibly, there is no support of locales in MinGW yet | |
1548 // http://mingw.5.n7.nabble.com/How-to-use-std-locale-global-with-MinGW-correct-td33048.html | |
1549 static const char* DEFAULT_LOCALE = NULL; | |
1550 #elif defined(_WIN32) | |
1551 // For Windows: use default locale (using "en_US" does not work) | |
2333 | 1552 static const char* DEFAULT_LOCALE = ""; |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1553 #else |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1554 // For Linux & cie |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1555 static const char* DEFAULT_LOCALE = "en_US.UTF-8"; |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1556 #endif |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1557 |
2334 | 1558 bool ok; |
1559 | |
1560 if (locale == NULL) | |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1561 { |
2334 | 1562 ok = SetGlobalLocale(DEFAULT_LOCALE); |
1563 | |
1564 #if defined(__MINGW32__) | |
1565 LOG(WARNING) << "This is a MinGW build, case-insensitive comparison of " | |
1566 << "strings with accents will not work outside of Wine"; | |
1567 #endif | |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1568 } |
2334 | 1569 else |
1570 { | |
1571 ok = SetGlobalLocale(locale); | |
1572 } | |
1573 | |
1574 if (!ok && | |
1575 !SetGlobalLocale(NULL)) | |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1576 { |
2954
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2931
diff
changeset
|
1577 throw OrthancException(ErrorCode_InternalError, |
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2931
diff
changeset
|
1578 "Cannot initialize global locale"); |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1579 } |
2334 | 1580 |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1581 } |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1582 |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1583 |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1584 void Toolbox::FinalizeGlobalLocale() |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1585 { |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1586 globalLocale_.reset(); |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1587 } |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1588 |
2677
0196d07a900f
migrate OpenSSL initialization to Toolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2513
diff
changeset
|
1589 |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1590 std::string Toolbox::ToUpperCaseWithAccents(const std::string& source) |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1591 { |
3333
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1592 bool error = (globalLocale_.get() == NULL); |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1593 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1594 #if ORTHANC_STATIC_ICU == 1 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1595 if (globalIcuData_.empty()) |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1596 { |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1597 error = true; |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1598 } |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1599 #endif |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1600 |
2a38e00a0638
Size of the Orthanc static binaries are reduced by compressing ICU data
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3328
diff
changeset
|
1601 if (error) |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1602 { |
2954
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2931
diff
changeset
|
1603 throw OrthancException(ErrorCode_BadSequenceOfCalls, |
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2931
diff
changeset
|
1604 "No global locale was set, call Toolbox::InitializeGlobalLocale()"); |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1605 } |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1606 |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1607 /** |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1608 * A few notes about locales: |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1609 * |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1610 * (1) We don't use "case folding": |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1611 * http://www.boost.org/doc/libs/1_64_0/libs/locale/doc/html/conversions.html |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1612 * |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1613 * Characters are made uppercase one by one. This is because, in |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1614 * static builds, we are using iconv, which is visibly not |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1615 * supported correctly (TODO: Understand why). Case folding seems |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1616 * to be working correctly if using the default backend under |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1617 * Linux (ICU or POSIX?). If one wishes to use case folding, one |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1618 * would use: |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1619 * |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1620 * boost::locale::generator gen; |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1621 * std::locale::global(gen(DEFAULT_LOCALE)); |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1622 * return boost::locale::to_upper(source); |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1623 * |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1624 * (2) The function "boost::algorithm::to_upper_copy" does not |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1625 * make use of the "std::locale::global()". We therefore create a |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1626 * global variable "globalLocale_". |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1627 * |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1628 * (3) The variant of "boost::algorithm::to_upper_copy()" that |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1629 * uses std::string does not work properly. We need to apply it |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1630 * one wide strings (std::wstring). This explains the two calls to |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1631 * "utf_to_utf" in order to convert to/from std::wstring. |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1632 **/ |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1633 |
2907
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
1634 std::wstring w = boost::locale::conv::utf_to_utf<wchar_t>(source, boost::locale::conv::skip); |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1635 w = boost::algorithm::to_upper_copy<std::wstring>(w, *globalLocale_); |
2907
0204af4ece6a
Remove invalid characters from badly-encoded UTF-8 strings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2906
diff
changeset
|
1636 return boost::locale::conv::utf_to_utf<char>(w, boost::locale::conv::skip); |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
1637 } |
2373 | 1638 #endif |
2512
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1639 |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1640 |
2678 | 1641 void Toolbox::InitializeOpenSsl() |
1642 { | |
1643 #if ORTHANC_ENABLE_SSL == 1 | |
1644 // https://wiki.openssl.org/index.php/Library_Initialization | |
1645 SSL_library_init(); | |
1646 SSL_load_error_strings(); | |
1647 OpenSSL_add_all_algorithms(); | |
1648 ERR_load_crypto_strings(); | |
1649 #endif | |
1650 } | |
1651 | |
1652 | |
1653 void Toolbox::FinalizeOpenSsl() | |
1654 { | |
1655 #if ORTHANC_ENABLE_SSL == 1 | |
1656 // Finalize OpenSSL | |
1657 // https://wiki.openssl.org/index.php/Library_Initialization#Cleanup | |
1658 #ifdef FIPS_mode_set | |
1659 FIPS_mode_set(0); | |
1660 #endif | |
1661 ENGINE_cleanup(); | |
1662 CONF_modules_unload(1); | |
1663 EVP_cleanup(); | |
1664 CRYPTO_cleanup_all_ex_data(); | |
1665 ERR_remove_state(0); | |
1666 ERR_free_strings(); | |
1667 #endif | |
1668 } | |
1669 | |
1670 | |
2512
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1671 std::string Toolbox::GenerateUuid() |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1672 { |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1673 #ifdef WIN32 |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1674 UUID uuid; |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1675 UuidCreate ( &uuid ); |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1676 |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1677 unsigned char * str; |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1678 UuidToStringA ( &uuid, &str ); |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1679 |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1680 std::string s( ( char* ) str ); |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1681 |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1682 RpcStringFreeA ( &str ); |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1683 #else |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1684 uuid_t uuid; |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1685 uuid_generate_random ( uuid ); |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1686 char s[37]; |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1687 uuid_unparse ( uuid, s ); |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1688 #endif |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1689 return s; |
4dcafa8d6633
SystemToolbox::GenerateUuid moved to Toolbox::GenerateUuid
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1690 } |
2920
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1691 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1692 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1693 namespace |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1694 { |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1695 // Anonymous namespace to avoid clashes between compilation modules |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1696 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1697 class VariableFormatter |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1698 { |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1699 public: |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1700 typedef std::map<std::string, std::string> Dictionary; |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1701 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1702 private: |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1703 const Dictionary& dictionary_; |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1704 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1705 public: |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1706 VariableFormatter(const Dictionary& dictionary) : |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1707 dictionary_(dictionary) |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1708 { |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1709 } |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1710 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1711 template<typename Out> |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1712 Out operator()(const boost::smatch& what, |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1713 Out out) const |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1714 { |
2921
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1715 if (!what[1].str().empty()) |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1716 { |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1717 // Variable without a default value |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1718 Dictionary::const_iterator found = dictionary_.find(what[1]); |
2920
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1719 |
2921
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1720 if (found != dictionary_.end()) |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1721 { |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1722 const std::string& value = found->second; |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1723 out = std::copy(value.begin(), value.end(), out); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1724 } |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1725 } |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1726 else |
2920
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1727 { |
2921
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1728 // Variable with a default value |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1729 std::string key; |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1730 std::string defaultValue; |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1731 |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1732 if (!what[2].str().empty()) |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1733 { |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1734 key = what[2].str(); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1735 defaultValue = what[3].str(); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1736 } |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1737 else if (!what[4].str().empty()) |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1738 { |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1739 key = what[4].str(); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1740 defaultValue = what[5].str(); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1741 } |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1742 else if (!what[6].str().empty()) |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1743 { |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1744 key = what[6].str(); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1745 defaultValue = what[7].str(); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1746 } |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1747 else |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1748 { |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1749 throw OrthancException(ErrorCode_InternalError); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1750 } |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1751 |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1752 Dictionary::const_iterator found = dictionary_.find(key); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1753 |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1754 if (found == dictionary_.end()) |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1755 { |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1756 out = std::copy(defaultValue.begin(), defaultValue.end(), out); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1757 } |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1758 else |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1759 { |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1760 const std::string& value = found->second; |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1761 out = std::copy(value.begin(), value.end(), out); |
0a4428aad512
variable substitution with default value
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2920
diff
changeset
|
1762 } |
2920
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1763 } |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1764 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1765 return out; |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1766 } |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1767 }; |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1768 } |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1769 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1770 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1771 std::string Toolbox::SubstituteVariables(const std::string& source, |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1772 const std::map<std::string, std::string>& dictionary) |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1773 { |
2926
0bcf46cea4e4
fix for older versions of boost::regex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2921
diff
changeset
|
1774 const boost::regex pattern("\\$\\{([^:]*?)\\}|" // ${what[1]} |
0bcf46cea4e4
fix for older versions of boost::regex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2921
diff
changeset
|
1775 "\\$\\{([^:]*?):-([^'\"]*?)\\}|" // ${what[2]:-what[3]} |
0bcf46cea4e4
fix for older versions of boost::regex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2921
diff
changeset
|
1776 "\\$\\{([^:]*?):-\"([^\"]*?)\"\\}|" // ${what[4]:-"what[5]"} |
0bcf46cea4e4
fix for older versions of boost::regex
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2921
diff
changeset
|
1777 "\\$\\{([^:]*?):-'([^']*?)'\\}"); // ${what[6]:-'what[7]'} |
2920
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1778 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1779 VariableFormatter formatter(dictionary); |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1780 |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1781 return boost::regex_replace(source, pattern, formatter); |
ad0e7def3338
Toolbox::SubstituteVariables and SystemToolbox::GetEnvironmentVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2907
diff
changeset
|
1782 } |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1783 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1784 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1785 namespace Iso2022 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1786 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1787 /** |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1788 Returns whether the string s contains a single-byte control message |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1789 at index i |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1790 **/ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1791 static inline bool IsControlMessage1(const std::string& s, size_t i) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1792 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1793 if (i < s.size()) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1794 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1795 char c = s[i]; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1796 return |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1797 (c == '\x0f') || // Locking shift zero |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1798 (c == '\x0e'); // Locking shift one |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1799 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1800 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1801 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1802 return false; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1803 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1804 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1805 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1806 /** |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1807 Returns whether the string s contains a double-byte control message |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1808 at index i |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1809 **/ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1810 static inline size_t IsControlMessage2(const std::string& s, size_t i) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1811 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1812 if (i + 1 < s.size()) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1813 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1814 char c1 = s[i]; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1815 char c2 = s[i + 1]; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1816 return (c1 == 0x1b) && ( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1817 (c2 == '\x6e') || // Locking shift two |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1818 (c2 == '\x6f') || // Locking shift three |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1819 (c2 == '\x4e') || // Single shift two (alt) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1820 (c2 == '\x4f') || // Single shift three (alt) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1821 (c2 == '\x7c') || // Locking shift three right |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1822 (c2 == '\x7d') || // Locking shift two right |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1823 (c2 == '\x7e') // Locking shift one right |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1824 ); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1825 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1826 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1827 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1828 return false; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1829 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1830 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1831 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1832 /** |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1833 Returns whether the string s contains a triple-byte control message |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1834 at index i |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1835 **/ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1836 static inline size_t IsControlMessage3(const std::string& s, size_t i) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1837 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1838 if (i + 2 < s.size()) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1839 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1840 char c1 = s[i]; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1841 char c2 = s[i + 1]; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1842 char c3 = s[i + 2]; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1843 return ((c1 == '\x8e' && c2 == 0x1b && c3 == '\x4e') || |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1844 (c1 == '\x8f' && c2 == 0x1b && c3 == '\x4f')); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1845 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1846 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1847 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1848 return false; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1849 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1850 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1851 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1852 /** |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1853 This function returns true if the index i in the supplied string s: |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1854 - is valid |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1855 - contains the c character |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1856 This function returns false otherwise. |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1857 **/ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1858 static inline bool TestCharValue( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1859 const std::string& s, size_t i, char c) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1860 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1861 if (i < s.size()) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1862 return s[i] == c; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1863 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1864 return false; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1865 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1866 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1867 /** |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1868 This function returns true if the index i in the supplied string s: |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1869 - is valid |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1870 - has a c character that is >= cMin and <= cMax (included) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1871 This function returns false otherwise. |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1872 **/ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1873 static inline bool TestCharRange( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1874 const std::string& s, size_t i, char cMin, char cMax) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1875 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1876 if (i < s.size()) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1877 return (s[i] >= cMin) && (s[i] <= cMax); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1878 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1879 return false; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1880 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1881 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1882 /** |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1883 This function returns the total length in bytes of the escape sequence |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1884 located in string s at index i, if there is one, or 0 otherwise. |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1885 **/ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1886 static inline size_t GetEscapeSequenceLength(const std::string& s, size_t i) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1887 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1888 if (TestCharValue(s, i, 0x1b)) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1889 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1890 size_t j = i+1; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1891 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1892 // advance reading cursor while we are in a sequence |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1893 while (TestCharRange(s, j, '\x20', '\x2f')) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1894 ++j; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1895 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1896 // check there is a valid termination byte AND we're long enough (there |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1897 // must be at least one byte between 0x20 and 0x2f |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1898 if (TestCharRange(s, j, '\x30', '\x7f') && (j - i) >= 2) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1899 return j - i + 1; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1900 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1901 return 0; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1902 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1903 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1904 return 0; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1905 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1906 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1907 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1908 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1909 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1910 /** |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1911 This function will strip all ISO/IEC 2022 control codes and escape |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1912 sequences. |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1913 Please see https://en.wikipedia.org/wiki/ISO/IEC_2022 (as of 2019-02) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1914 for a list of those. |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1915 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1916 Please note that this operation is potentially destructive, because |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1917 it removes the character set information from the byte stream. |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1918 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1919 However, in the case where the encoding is unique, then suppressing |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1920 the escape sequences allows to provide us with a clean string after |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1921 conversion to utf-8 with boost. |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1922 **/ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1923 void Toolbox::RemoveIso2022EscapeSequences(std::string& dest, const std::string& src) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1924 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1925 // we need AT MOST the same size as the source string in the output |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1926 dest.clear(); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1927 if (dest.capacity() < src.size()) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1928 dest.reserve(src.size()); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1929 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1930 size_t i = 0; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1931 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1932 // uint8_t view to the string |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1933 while (i < src.size()) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1934 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1935 size_t j = i; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1936 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1937 // The i index will only be incremented if a message is detected |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1938 // in that case, the message is skipped and the index is set to the |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1939 // next position to read |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1940 if (Iso2022::IsControlMessage1(src, i)) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1941 i += 1; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1942 else if (Iso2022::IsControlMessage2(src, i)) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1943 i += 2; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1944 else if (Iso2022::IsControlMessage3(src, i)) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1945 i += 3; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1946 else |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1947 i += Iso2022::GetEscapeSequenceLength(src, i); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1948 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1949 // if the index was NOT incremented, this means there was no message at |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1950 // this location: we then may copy the character at this index and |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1951 // increment the index to point to the next read position |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1952 if (j == i) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1953 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1954 dest.push_back(src[i]); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1955 i++; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1956 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1957 } |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3203
diff
changeset
|
1958 } |
3322
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1959 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1960 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1961 void Toolbox::Utf8ToUnicodeCharacter(uint32_t& unicode, |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1962 size_t& length, |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1963 const std::string& utf8, |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1964 size_t position) |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1965 { |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1966 // https://en.wikipedia.org/wiki/UTF-8 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1967 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1968 static const uint8_t MASK_IS_1_BYTE = 0x80; // printf '0x%x\n' "$((2#10000000))" |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1969 static const uint8_t TEST_IS_1_BYTE = 0x00; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1970 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1971 static const uint8_t MASK_IS_2_BYTES = 0xe0; // printf '0x%x\n' "$((2#11100000))" |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1972 static const uint8_t TEST_IS_2_BYTES = 0xc0; // printf '0x%x\n' "$((2#11000000))" |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1973 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1974 static const uint8_t MASK_IS_3_BYTES = 0xf0; // printf '0x%x\n' "$((2#11110000))" |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1975 static const uint8_t TEST_IS_3_BYTES = 0xe0; // printf '0x%x\n' "$((2#11100000))" |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1976 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1977 static const uint8_t MASK_IS_4_BYTES = 0xf8; // printf '0x%x\n' "$((2#11111000))" |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1978 static const uint8_t TEST_IS_4_BYTES = 0xf0; // printf '0x%x\n' "$((2#11110000))" |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1979 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1980 static const uint8_t MASK_CONTINUATION = 0xc0; // printf '0x%x\n' "$((2#11000000))" |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1981 static const uint8_t TEST_CONTINUATION = 0x80; // printf '0x%x\n' "$((2#10000000))" |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1982 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1983 if (position >= utf8.size()) |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1984 { |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1985 throw OrthancException(ErrorCode_ParameterOutOfRange); |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1986 } |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1987 |
3324 | 1988 assert(sizeof(uint8_t) == sizeof(char)); |
1989 const uint8_t* buffer = reinterpret_cast<const uint8_t*>(utf8.c_str()) + position; | |
3322
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1990 |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1991 if ((buffer[0] & MASK_IS_1_BYTE) == TEST_IS_1_BYTE) |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1992 { |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1993 length = 1; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1994 unicode = buffer[0] & ~MASK_IS_1_BYTE; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1995 } |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1996 else if ((buffer[0] & MASK_IS_2_BYTES) == TEST_IS_2_BYTES && |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1997 position + 1 < utf8.size() && |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1998 (buffer[1] & MASK_CONTINUATION) == TEST_CONTINUATION) |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
1999 { |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2000 length = 2; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2001 uint32_t a = buffer[0] & ~MASK_IS_2_BYTES; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2002 uint32_t b = buffer[1] & ~MASK_CONTINUATION; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2003 unicode = (a << 6) | b; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2004 } |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2005 else if ((buffer[0] & MASK_IS_3_BYTES) == TEST_IS_3_BYTES && |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2006 position + 2 < utf8.size() && |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2007 (buffer[1] & MASK_CONTINUATION) == TEST_CONTINUATION && |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2008 (buffer[2] & MASK_CONTINUATION) == TEST_CONTINUATION) |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2009 { |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2010 length = 3; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2011 uint32_t a = buffer[0] & ~MASK_IS_3_BYTES; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2012 uint32_t b = buffer[1] & ~MASK_CONTINUATION; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2013 uint32_t c = buffer[2] & ~MASK_CONTINUATION; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2014 unicode = (a << 12) | (b << 6) | c; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2015 } |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2016 else if ((buffer[0] & MASK_IS_4_BYTES) == TEST_IS_4_BYTES && |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2017 position + 3 < utf8.size() && |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2018 (buffer[1] & MASK_CONTINUATION) == TEST_CONTINUATION && |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2019 (buffer[2] & MASK_CONTINUATION) == TEST_CONTINUATION && |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2020 (buffer[3] & MASK_CONTINUATION) == TEST_CONTINUATION) |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2021 { |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2022 length = 4; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2023 uint32_t a = buffer[0] & ~MASK_IS_4_BYTES; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2024 uint32_t b = buffer[1] & ~MASK_CONTINUATION; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2025 uint32_t c = buffer[2] & ~MASK_CONTINUATION; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2026 uint32_t d = buffer[3] & ~MASK_CONTINUATION; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2027 unicode = (a << 18) | (b << 12) | (c << 6) | d; |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2028 } |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2029 else |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2030 { |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2031 // This is not a valid UTF-8 encoding |
3324 | 2032 throw OrthancException(ErrorCode_BadFileFormat, "Invalid UTF-8 string"); |
3322
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2033 } |
b32b7c44a223
Toolbox::Utf8ToUnicodeCharacter()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3230
diff
changeset
|
2034 } |
0 | 2035 } |
2513
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2036 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2037 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2038 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2039 OrthancLinesIterator* OrthancLinesIterator_Create(const std::string& content) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2040 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2041 return reinterpret_cast<OrthancLinesIterator*>(new Orthanc::Toolbox::LinesIterator(content)); |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2042 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2043 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2044 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2045 bool OrthancLinesIterator_GetLine(std::string& target, |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2046 const OrthancLinesIterator* iterator) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2047 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2048 if (iterator != NULL) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2049 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2050 return reinterpret_cast<const Orthanc::Toolbox::LinesIterator*>(iterator)->GetLine(target); |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2051 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2052 else |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2053 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2054 return false; |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2055 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2056 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2057 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2058 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2059 void OrthancLinesIterator_Next(OrthancLinesIterator* iterator) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2060 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2061 if (iterator != NULL) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2062 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2063 reinterpret_cast<Orthanc::Toolbox::LinesIterator*>(iterator)->Next(); |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2064 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2065 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2066 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2067 |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2068 void OrthancLinesIterator_Free(OrthancLinesIterator* iterator) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2069 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2070 if (iterator != NULL) |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2071 { |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2072 delete reinterpret_cast<const Orthanc::Toolbox::LinesIterator*>(iterator); |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2073 } |
97a74f0eac7a
loading DICOM dictionaries in sandboxed environments
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2512
diff
changeset
|
2074 } |