/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2016,2017,2018, by the GROMACS development team, led by
+ * Copyright (c) 2016,2017,2018,2019, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
class ValueSerializer
{
- public:
- static void initSerializers();
+public:
+ static void initSerializers();
- static void serialize(const KeyValueTreeValue &value, ISerializer *serializer);
- static KeyValueTreeValue deserialize(ISerializer *serializer);
+ static void serialize(const KeyValueTreeValue& value, ISerializer* serializer);
+ static KeyValueTreeValue deserialize(ISerializer* serializer);
- private:
- ValueSerializer() = delete;
+private:
+ ValueSerializer() = delete;
- typedef void (*SerializerFunction)(const KeyValueTreeValue &value, ISerializer *serializer);
- typedef void (*DeserializerFunction)(KeyValueTreeValueBuilder *builder, ISerializer *serializer);
+ typedef void (*SerializerFunction)(const KeyValueTreeValue& value, ISerializer* serializer);
+ typedef void (*DeserializerFunction)(KeyValueTreeValueBuilder* builder, ISerializer* serializer);
- struct Serializer
- {
- unsigned char typeTag;
- SerializerFunction serialize;
- DeserializerFunction deserialize;
- };
+ struct Serializer
+ {
+ unsigned char typeTag;
+ SerializerFunction serialize;
+ DeserializerFunction deserialize;
+ };
- static Mutex s_initMutex;
- static std::map<std::type_index, Serializer> s_serializers;
- static std::map<unsigned char, DeserializerFunction> s_deserializers;
+ static Mutex s_initMutex;
+ static std::map<std::type_index, Serializer> s_serializers;
+ static std::map<unsigned char, DeserializerFunction> s_deserializers;
};
Mutex ValueSerializer::s_initMutex;
std::map<std::type_index, ValueSerializer::Serializer> ValueSerializer::s_serializers;
std::map<unsigned char, ValueSerializer::DeserializerFunction> ValueSerializer::s_deserializers;
-template <typename T>
+template<typename T>
struct SerializationTraits
{
};
-template <>
+template<>
struct SerializationTraits<KeyValueTreeObject>
{
- static void serialize(const KeyValueTreeObject &value, ISerializer *serializer)
+ static void serialize(const KeyValueTreeObject& value, ISerializer* serializer)
{
- int count = value.properties().size();
+ int count = value.properties().size();
serializer->doInt(&count);
- for (const auto &prop : value.properties())
+ for (const auto& prop : value.properties())
{
- serializer->doString(const_cast<std::string *>(&prop.key()));
+ serializer->doString(const_cast<std::string*>(&prop.key()));
ValueSerializer::serialize(prop.value(), serializer);
}
}
- static void deserialize(KeyValueTreeValueBuilder *value, ISerializer *serializer)
+ static void deserialize(KeyValueTreeValueBuilder* value, ISerializer* serializer)
{
KeyValueTreeObjectBuilder builder(value->createObject());
deserializeObject(&builder, serializer);
}
- static void deserializeObject(KeyValueTreeObjectBuilder *builder, ISerializer *serializer)
+ static void deserializeObject(KeyValueTreeObjectBuilder* builder, ISerializer* serializer)
{
int count;
std::string key;
}
};
-template <>
+template<>
struct SerializationTraits<KeyValueTreeArray>
{
- static void serialize(const KeyValueTreeArray &array, ISerializer *serializer)
+ static void serialize(const KeyValueTreeArray& array, ISerializer* serializer)
{
- int count = array.values().size();
+ int count = array.values().size();
serializer->doInt(&count);
- for (const auto &value : array.values())
+ for (const auto& value : array.values())
{
ValueSerializer::serialize(value, serializer);
}
}
- static void deserialize(KeyValueTreeValueBuilder *value, ISerializer *serializer)
+ static void deserialize(KeyValueTreeValueBuilder* value, ISerializer* serializer)
{
KeyValueTreeArrayBuilder builder(value->createArray());
int count;
}
};
-template <>
+template<>
struct SerializationTraits<std::string>
{
- static void serialize(const std::string &value, ISerializer *serializer)
+ static void serialize(const std::string& value, ISerializer* serializer)
{
- serializer->doString(const_cast<std::string *>(&value));
+ serializer->doString(const_cast<std::string*>(&value));
}
- static void deserialize(KeyValueTreeValueBuilder *builder, ISerializer *serializer)
+ static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
{
std::string value;
serializer->doString(&value);
}
};
-template <>
+template<>
struct SerializationTraits<bool>
{
- static void serialize(bool value, ISerializer *serializer)
- {
- serializer->doBool(&value);
- }
- static void deserialize(KeyValueTreeValueBuilder *builder, ISerializer *serializer)
+ static void serialize(bool value, ISerializer* serializer) { serializer->doBool(&value); }
+ static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
{
bool value;
serializer->doBool(&value);
}
};
-template <>
+template<>
struct SerializationTraits<int>
{
- static void serialize(int value, ISerializer *serializer)
- {
- serializer->doInt(&value);
- }
- static void deserialize(KeyValueTreeValueBuilder *builder, ISerializer *serializer)
+ static void serialize(int value, ISerializer* serializer) { serializer->doInt(&value); }
+ static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
{
int value;
serializer->doInt(&value);
}
};
-template <>
+template<>
struct SerializationTraits<int64_t>
{
- static void serialize(int64_t value, ISerializer *serializer)
- {
- serializer->doInt64(&value);
- }
- static void deserialize(KeyValueTreeValueBuilder *builder, ISerializer *serializer)
+ static void serialize(int64_t value, ISerializer* serializer) { serializer->doInt64(&value); }
+ static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
{
int64_t value;
serializer->doInt64(&value);
}
};
-template <>
+template<>
struct SerializationTraits<float>
{
- static void serialize(float value, ISerializer *serializer)
- {
- serializer->doFloat(&value);
- }
- static void deserialize(KeyValueTreeValueBuilder *builder, ISerializer *serializer)
+ static void serialize(float value, ISerializer* serializer) { serializer->doFloat(&value); }
+ static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
{
float value;
serializer->doFloat(&value);
}
};
-template <>
+template<>
struct SerializationTraits<double>
{
- static void serialize(double value, ISerializer *serializer)
- {
- serializer->doDouble(&value);
- }
- static void deserialize(KeyValueTreeValueBuilder *builder, ISerializer *serializer)
+ static void serialize(double value, ISerializer* serializer) { serializer->doDouble(&value); }
+ static void deserialize(KeyValueTreeValueBuilder* builder, ISerializer* serializer)
{
double value;
serializer->doDouble(&value);
};
//! Helper function for serializing values of a certain type.
-template <typename T>
-void serializeValueType(const KeyValueTreeValue &value, ISerializer *serializer)
+template<typename T>
+void serializeValueType(const KeyValueTreeValue& value, ISerializer* serializer)
{
SerializationTraits<T>::serialize(value.cast<T>(), serializer);
}
-#define SERIALIZER(tag, type) \
- { std::type_index(typeid(type)), \
- { tag, &serializeValueType<type>, &SerializationTraits<type>::deserialize } \
+#define SERIALIZER(tag, type) \
+ { \
+ std::type_index(typeid(type)), \
+ { \
+ tag, &serializeValueType<type>, &SerializationTraits<type>::deserialize \
+ } \
}
// static
SERIALIZER('f', float),
SERIALIZER('d', double),
};
- for (const auto &item : s_serializers)
+ for (const auto& item : s_serializers)
{
s_deserializers[item.second.typeTag] = item.second.deserialize;
}
}
-void ValueSerializer::serialize(const KeyValueTreeValue &value, ISerializer *serializer)
+void ValueSerializer::serialize(const KeyValueTreeValue& value, ISerializer* serializer)
{
auto iter = s_serializers.find(value.type());
- GMX_RELEASE_ASSERT(iter != s_serializers.end(),
- "Unknown value type for serializization");
+ GMX_RELEASE_ASSERT(iter != s_serializers.end(), "Unknown value type for serializization");
unsigned char typeTag = iter->second.typeTag;
serializer->doUChar(&typeTag);
iter->second.serialize(value, serializer);
}
-KeyValueTreeValue ValueSerializer::deserialize(ISerializer *serializer)
+KeyValueTreeValue ValueSerializer::deserialize(ISerializer* serializer)
{
unsigned char typeTag;
serializer->doUChar(&typeTag);
- auto iter = s_deserializers.find(typeTag);
- GMX_RELEASE_ASSERT(iter != s_deserializers.end(),
- "Unknown type tag for deserializization");
+ auto iter = s_deserializers.find(typeTag);
+ GMX_RELEASE_ASSERT(iter != s_deserializers.end(), "Unknown type tag for deserializization");
KeyValueTreeValueBuilder builder;
iter->second(&builder, serializer);
return builder.build();
}
-} // namespace
+} // namespace
//! \cond libapi
-void serializeKeyValueTree(const KeyValueTreeObject &root, ISerializer *serializer)
+void serializeKeyValueTree(const KeyValueTreeObject& root, ISerializer* serializer)
{
- GMX_RELEASE_ASSERT(!serializer->reading(),
- "Incorrect serializer direction");
+ GMX_RELEASE_ASSERT(!serializer->reading(), "Incorrect serializer direction");
ValueSerializer::initSerializers();
SerializationTraits<KeyValueTreeObject>::serialize(root, serializer);
}
-KeyValueTreeObject deserializeKeyValueTree(ISerializer *serializer)
+KeyValueTreeObject deserializeKeyValueTree(ISerializer* serializer)
{
- GMX_RELEASE_ASSERT(serializer->reading(),
- "Incorrect serializer direction");
+ GMX_RELEASE_ASSERT(serializer->reading(), "Incorrect serializer direction");
ValueSerializer::initSerializers();
KeyValueTreeBuilder builder;
KeyValueTreeObjectBuilder obj(builder.rootObject());
biod.pnpi.spb.ru / alexxy / gromacs.git / blobdiff