Mercurial > hg > orthanc

comparison Core/SerializationToolbox.cpp @ 2656:a6d3e45eeff5 jobs

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
SerializationToolbox
author Sebastien Jodogne <s.jodogne@gmail.com>
date Tue, 05 Jun 2018 18:25:23 +0200
parents
children 5eea2f11e8df
comparison
equal deleted inserted replaced
2655:c196d76cb8fa 2656:a6d3e45eeff5
1 /**
2 * Orthanc - A Lightweight, RESTful DICOM Store
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2018 Osimis S.A., Belgium
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.
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.
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
34 #include "PrecompiledHeaders.h"
35 #include "SerializationToolbox.h"
36
37 #include "OrthancException.h"
38
39 namespace Orthanc
40 {
41 namespace SerializationToolbox
42 {
43 std::string ReadString(const Json::Value& value,
44 const std::string& field)
45 {
46 if (value.type() != Json::objectValue ||
47 !value.isMember(field.c_str()) ||
48 value[field.c_str()].type() != Json::stringValue)
49 {
50 throw OrthancException(ErrorCode_BadFileFormat);
51 }
52 else
53 {
54 return value[field.c_str()].asString();
55 }
56 }
57
58
59 int ReadInteger(const Json::Value& value,
60 const std::string& field)
61 {
62 if (value.type() != Json::objectValue ||
63 !value.isMember(field.c_str()) ||
64 (value[field.c_str()].type() != Json::intValue &&
65 value[field.c_str()].type() != Json::uintValue))
66 {
67 throw OrthancException(ErrorCode_BadFileFormat);
68 }
69 else
70 {
71 return value[field.c_str()].asInt();
72 }
73 }
74
75
76 unsigned int ReadUnsignedInteger(const Json::Value& value,
77 const std::string& field)
78 {
79 int tmp = ReadInteger(value, field);
80
81 if (tmp < 0)
82 {
83 throw OrthancException(ErrorCode_BadFileFormat);
84 }
85 else
86 {
87 return static_cast<unsigned int>(tmp);
88 }
89 }
90
91
92 bool ReadBoolean(const Json::Value& value,
93 const std::string& field)
94 {
95 if (value.type() != Json::objectValue ||
96 !value.isMember(field.c_str()) ||
97 value[field.c_str()].type() != Json::booleanValue)
98 {
99 throw OrthancException(ErrorCode_BadFileFormat);
100 }
101 else
102 {
103 return value[field.c_str()].asBool();
104 }
105 }
106
107
108 void ReadArrayOfStrings(std::vector<std::string>& target,
109 const Json::Value& value,
110 const std::string& field)
111 {
112 if (value.type() != Json::objectValue ||
113 !value.isMember(field.c_str()) ||
114 value[field.c_str()].type() != Json::arrayValue)
115 {
116 throw OrthancException(ErrorCode_BadFileFormat);
117 }
118
119 target.clear();
120 target.resize(value.size());
121
122 const Json::Value arr = value[field.c_str()];
123
124 for (Json::Value::ArrayIndex i = 0; i < arr.size(); i++)
125 {
126 if (arr[i].type() != Json::stringValue)
127 {
128 throw OrthancException(ErrorCode_BadFileFormat);
129 }
130 else
131 {
132 target[i] = arr[i].asString();
133 }
134 }
135 }
136
137
138 void ReadListOfStrings(std::list<std::string>& target,
139 const Json::Value& value,
140 const std::string& field)
141 {
142 std::vector<std::string> tmp;
143 ReadArrayOfStrings(tmp, value, field);
144
145 target.clear();
146 for (size_t i = 0; i < tmp.size(); i++)
147 {
148 target.push_back(tmp[i]);
149 }
150 }
151
152
153 void ReadSetOfStrings(std::set<std::string>& target,
154 const Json::Value& value,
155 const std::string& field)
156 {
157 std::vector<std::string> tmp;
158 ReadArrayOfStrings(tmp, value, field);
159
160 target.clear();
161 for (size_t i = 0; i < tmp.size(); i++)
162 {
163 target.insert(tmp[i]);
164 }
165 }
166
167
168 void WriteArrayOfStrings(Json::Value& target,
169 const std::vector<std::string>& values,
170 const std::string& field)
171 {
172 if (target.type() != Json::objectValue ||
173 target.isMember(field.c_str()))
174 {
175 throw OrthancException(ErrorCode_BadFileFormat);
176 }
177
178 Json::Value tmp;
179
180 tmp = Json::arrayValue;
181 for (size_t i = 0; i < values.size(); i++)
182 {
183 tmp.append(values[i]);
184 }
185
186 target[field] = tmp;
187 }
188
189
190 void WriteSetOfStrings(Json::Value& target,
191 const std::set<std::string>& values,
192 const std::string& field)
193 {
194 Json::Value v = Json::arrayValue;
195
196 for (std::set<std::string>::const_iterator it = values.begin();
197 it != values.end(); ++it)
198 {
199 v.append(*it);
200 }
201
202 target[field] = v;
203 }
204 }
205 }