2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 2016,2017,2018,2019,2021, by the GROMACS development team, led by
5 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
6 * and including many others, as listed in the AUTHORS file in the
7 * top-level source directory and at http://www.gromacs.org.
9 * GROMACS is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public License
11 * as published by the Free Software Foundation; either version 2.1
12 * of the License, or (at your option) any later version.
14 * GROMACS is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with GROMACS; if not, see
21 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 * If you want to redistribute modifications to GROMACS, please
25 * consider that scientific software is very special. Version
26 * control is crucial - bugs must be traceable. We will be happy to
27 * consider code for inclusion in the official distribution, but
28 * derived work must not be called official GROMACS. Details are found
29 * in the README & COPYING files - if they are missing, get the
30 * official version at http://www.gromacs.org.
32 * To help us fund GROMACS development, we humbly ask that you cite
33 * the research papers on the package. Check out http://www.gromacs.org.
37 #include "keyvaluetreeserializer.h"
41 #include "gromacs/utility/iserializer.h"
42 #include "gromacs/utility/keyvaluetree.h"
43 #include "gromacs/utility/keyvaluetreebuilder.h"
54 static void initSerializers();
56 static void serialize(const KeyValueTreeValue& value, ISerializer* serializer);
57 static KeyValueTreeValue deserialize(ISerializer* serializer);
60 ValueSerializer() = delete;
62 typedef void (*SerializerFunction)(const KeyValueTreeValue& value, ISerializer* serializer);
63 typedef void (*DeserializerFunction)(KeyValueTreeValueBuilder* builder, ISerializer* serializer);
67 unsigned char typeTag;
68 SerializerFunction serialize;
69 DeserializerFunction deserialize;
72 static std::mutex s_initMutex;
73 static std::map<std::type_index, Serializer> s_serializers;
74 static std::map<unsigned char, DeserializerFunction> s_deserializers;
77 std::mutex ValueSerializer::s_initMutex;
78 std::map<std::type_index, ValueSerializer::Serializer> ValueSerializer::s_serializers;
79 std::map<unsigned char, ValueSerializer::DeserializerFunction> ValueSerializer::s_deserializers;
82 struct SerializationTraits
87 struct SerializationTraits<KeyValueTreeObject>
89 static void serialize(const KeyValueTreeObject& value, ISerializer* serializer)
91 int count = value.properties().size();
92 serializer->doInt(&count);
93 for (const auto& prop : value.properties())
95 serializer->doString(const_cast<std::string*>(&prop.key()));
96 ValueSerializer::serialize(prop.value(), serializer);
99 static void deserialize(KeyValueTreeValueBuilder* value, ISerializer* serializer)
101 KeyValueTreeObjectBuilder builder(value->createObject());
102 deserializeObject(&builder, serializer);
104 static void deserializeObject(KeyValueTreeObjectBuilder* builder, ISerializer* serializer)
108 serializer->doInt(&count);
109 for (int i = 0; i < count; ++i)
111 serializer->doString(&key);
112 builder->addRawValue(key, ValueSerializer::deserialize(serializer));
118 struct SerializationTraits<KeyValueTreeArray>
120 static void serialize(const KeyValueTreeArray& array, ISerializer* serializer)
122 int count = array.values().size();
123 serializer->doInt(&count);
124 for (const auto& value : array.values())
126 ValueSerializer::serialize(value, serializer);
129 static void deserialize(KeyValueTreeValueBuilder* value, ISerializer* serializer)
131 KeyValueTreeArrayBuilder builder(value->createArray());
133 serializer->doInt(&count);
134 for (int i = 0; i < count; ++i)
136 builder.addRawValue(ValueSerializer::deserialize(serializer));
142 struct SerializationTraits<std::string>
144 static void serialize(const std::string& value, ISerializer* serializer)
146 serializer->doString(const_cast<std::string*>(&value));
148 static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
151 serializer->doString(&value);
152 builder->setValue<std::string>(value);
157 struct SerializationTraits<bool>
159 static void serialize(bool value, ISerializer* serializer) { serializer->doBool(&value); }
160 static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
163 serializer->doBool(&value);
164 builder->setValue<bool>(value);
169 struct SerializationTraits<int>
171 static void serialize(int value, ISerializer* serializer) { serializer->doInt(&value); }
172 static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
175 serializer->doInt(&value);
176 builder->setValue<int>(value);
181 struct SerializationTraits<int64_t>
183 static void serialize(int64_t value, ISerializer* serializer) { serializer->doInt64(&value); }
184 static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
187 serializer->doInt64(&value);
188 builder->setValue<int64_t>(value);
193 struct SerializationTraits<float>
195 static void serialize(float value, ISerializer* serializer) { serializer->doFloat(&value); }
196 static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
199 serializer->doFloat(&value);
200 builder->setValue<float>(value);
205 struct SerializationTraits<double>
207 static void serialize(double value, ISerializer* serializer) { serializer->doDouble(&value); }
208 static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
211 serializer->doDouble(&value);
212 builder->setValue<double>(value);
216 //! Helper function for serializing values of a certain type.
218 void serializeValueType(const KeyValueTreeValue& value, ISerializer* serializer)
220 SerializationTraits<T>::serialize(value.cast<T>(), serializer);
223 #define SERIALIZER(tag, type) \
225 std::type_index(typeid(type)), \
227 tag, &serializeValueType<type>, &SerializationTraits<type>::deserialize \
232 void ValueSerializer::initSerializers()
234 std::lock_guard<std::mutex> lock(s_initMutex);
235 if (!s_serializers.empty())
240 SERIALIZER('O', KeyValueTreeObject),
241 SERIALIZER('A', KeyValueTreeArray),
242 SERIALIZER('s', std::string),
243 SERIALIZER('b', bool),
244 SERIALIZER('i', int),
245 SERIALIZER('l', int64_t),
246 SERIALIZER('f', float),
247 SERIALIZER('d', double),
249 for (const auto& item : s_serializers)
251 s_deserializers[item.second.typeTag] = item.second.deserialize;
255 void ValueSerializer::serialize(const KeyValueTreeValue& value, ISerializer* serializer)
257 auto iter = s_serializers.find(value.type());
258 GMX_RELEASE_ASSERT(iter != s_serializers.end(), "Unknown value type for serializization");
259 unsigned char typeTag = iter->second.typeTag;
260 serializer->doUChar(&typeTag);
261 iter->second.serialize(value, serializer);
264 KeyValueTreeValue ValueSerializer::deserialize(ISerializer* serializer)
266 unsigned char typeTag = 0;
267 serializer->doUChar(&typeTag);
268 auto iter = s_deserializers.find(typeTag);
269 GMX_RELEASE_ASSERT(iter != s_deserializers.end(), "Unknown type tag for deserializization");
270 KeyValueTreeValueBuilder builder;
271 iter->second(&builder, serializer);
272 return builder.build();
278 void serializeKeyValueTree(const KeyValueTreeObject& root, ISerializer* serializer)
280 GMX_RELEASE_ASSERT(!serializer->reading(), "Incorrect serializer direction");
281 ValueSerializer::initSerializers();
282 SerializationTraits<KeyValueTreeObject>::serialize(root, serializer);
285 KeyValueTreeObject deserializeKeyValueTree(ISerializer* serializer)
287 GMX_RELEASE_ASSERT(serializer->reading(), "Incorrect serializer direction");
288 ValueSerializer::initSerializers();
289 KeyValueTreeBuilder builder;
290 KeyValueTreeObjectBuilder obj(builder.rootObject());
291 SerializationTraits<KeyValueTreeObject>::deserializeObject(&obj, serializer);
292 return builder.build();