refactor:Serialisible concept

src/base/CMakeLists.txt

@@ -15,6 +15,8 @@ add_library(
   outputHandler.cpp
   outputHandler.h
   parserLibrary.cpp
+  serialiser.h
+  serialiser.cpp
   sysFunc.cpp
   sysFunc.h
   timer.cpp

src/base/geometry.cpp

@@ -34,3 +34,39 @@ int Geometry::indices(int i) const { return indices_[i]; }
 
 bool Geometry::operator==(const Geometry &rhs) const { return value_ == rhs.value_ && indices_ == rhs.indices_; }
 bool Geometry::operator!=(const Geometry &rhs) const { return !(rhs == *this); }
+
+namespace Serialisable
+{
+void serialiseOnto(const Geometry::GeometryType &e, std::string tag, SerialisedValue &node)
+{
+    switch (e)
+    {
+        case Geometry::GeometryType::AngleType:
+            node["tag"] = "angle";
+        case Geometry::GeometryType::DistanceType:
+            node["tag"] = "distance";
+        case Geometry::GeometryType::TorsionType:
+            node["tag"] = "torsion";
+        default:
+            throw std::runtime_error("Unhandled geometry type - can't convert to TOML value.\n");
+    }
+}
+}; // namespace Serialisable
+
+namespace Deserialisable
+{
+void deserialiseOnto(Geometry::GeometryType &e, const SerialisedValue &target)
+{
+    auto typeString = target.as_string();
+    if (typeString == "angle")
+        e = Geometry::GeometryType::AngleType;
+    else if (typeString == "distance")
+        e = Geometry::GeometryType::DistanceType;
+    else if (typeString == "torsion")
+        e = Geometry::GeometryType::TorsionType;
+    else
+        throw toml::type_error(
+            std::format("Unhandled geometry type '{}' - can't convert from TOML value.\n", std::string(typeString)),
+            target.location());
+}
+} // namespace Deserialisable

src/base/geometry.h

@@ -3,9 +3,9 @@
 
 #pragma once
 
+#include "base/serialiser.h"
 #include <format>
 #include <map>
-#include <toml11/toml.hpp>
 
 // Geometry Definition
 class Geometry
@@ -42,41 +42,12 @@ class Geometry
 };
 
 // TOML Conversion
-namespace toml
+namespace Serialisable
 {
-template <> struct from<Geometry::GeometryType>
-{
-    static Geometry::GeometryType from_toml(const toml::value &node)
-    {
-        auto typeString = node.as_string();
-        if (typeString == "angle")
-            return Geometry::GeometryType::AngleType;
-        else if (typeString == "distance")
-            return Geometry::GeometryType::DistanceType;
-        else if (typeString == "torsion")
-            return Geometry::GeometryType::TorsionType;
-        else
-            throw toml::type_error(
-                std::format("Unhandled geometry type '{}' - can't convert from TOML value.\n", std::string(typeString)),
-                node.location());
-    }
+void serialiseOnto(const Geometry::GeometryType &e, std::string tag, SerialisedValue &node);
 };
 
-template <> struct into<Geometry::GeometryType>
+namespace Deserialisable
 {
-    static toml::basic_value<toml::preserve_comments> into_toml(const Geometry::GeometryType &e)
-    {
-        switch (e)
-        {
-            case Geometry::GeometryType::AngleType:
-                return "angle";
-            case Geometry::GeometryType::DistanceType:
-                return "distance";
-            case Geometry::GeometryType::TorsionType:
-                return "torsion";
-            default:
-                throw std::runtime_error("Unhandled geometry type - can't convert to TOML value.\n");
-        }
-    }
-};
-} // namespace toml
+void deserialiseOnto(Geometry::GeometryType &e, const SerialisedValue &target);
+}

src/base/serialiser.cpp

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (c) 2026 Team Dissolve and contributors
+
+#include "base/serialiser.h"
+
+namespace Serialisable
+{
+void serialiseOnto(int a, std::string tag, SerialisedValue &target) { target[tag] = a; }
+void serialiseOnto(double a, std::string tag, SerialisedValue &target) { target[tag] = a; }
+void serialiseOnto(std::string a, std::string tag, SerialisedValue &target) { target[tag] = a; }
+} // namespace Serialisable
+
+namespace Deserialisable
+{
+void deserialiseOnto(bool &a, const SerialisedValue &target) { a = target.as_boolean(); }
+void deserialiseOnto(int &a, const SerialisedValue &target) { a = target.as_integer(); }
+void deserialiseOnto(long &a, const SerialisedValue &target) { a = target.as_integer(); }
+void deserialiseOnto(float &a, const SerialisedValue &target) { a = target.as_floating(); }
+void deserialiseOnto(double &a, const SerialisedValue &target) { a = target.as_floating(); }
+void deserialiseOnto(std::string &a, const SerialisedValue &target) { a = target.as_string(); }
+} // namespace Deserialisable

src/base/serialiser.h

@@ -3,252 +3,28 @@
 
 #pragma once
 
-#include "templates/keyedVector.h"
 #include "templates/orderedMap.h"
-#include "templates/resolvableKeyedVector.h"
-#include <map>
 #include <toml11/toml.hpp>
 #include <vector>
 
 // The type we use for the nodes of our serialisation tree
 using SerialisedValue = toml::basic_value<toml::discard_comments, dissolve::OrderedMap, std::vector>;
 
-// We need a way at compile time to detect all the types of smart
-// pointers for things that can be serialised
-template <typename T>
-concept serialisablePointer = requires(T a, std::string tag, SerialisedValue target) { a->serialise(tag, target); };
-
-// An interface for classes that can be serialised into an input file
-class Serialisable
+namespace Serialisable
 {
-    public:
-    Serialisable() = default;
-    virtual ~Serialisable() = default;
-    // Express as a serialisable value
-    virtual void serialise(std::string tag, SerialisedValue &target) const = 0;
-    // Read values from a serialisable value
-    virtual void deserialise(const SerialisedValue &node) {}
-
-    /* Functions that hook into the toml11 library */
-    // Wrapper for deserialise that toml11 will check for
-    void from_toml(const toml::value &node) { deserialise(node); }
-    // Wrapper for serialise that toml11 will check for
-    SerialisedValue into_toml() const
-    {
-        SerialisedValue result;
-        serialise("inner", result);
-        return result["inner"];
-    }
-
-    // Perform an action on a child node in a table if the node exists.
-    // This cuts out quite a bit of boilerplate.
-    template <typename Lambda> static bool optionalOn(const SerialisedValue &node, std::string name, Lambda action)
-    {
-        if (node.contains(name))
-        {
-            auto child = toml::find(node, name);
-            if (!node.is_uninitialized())
-                action(child);
-            return true;
-        }
-
-        return false;
-    }
-    // Place the named value into the supplied object, but only if it exists
-    template <typename T, typename U> bool getIfPresent(const SerialisedValue &node, std::string name, U &destination)
-    {
-        if (!node.contains(name))
-            return false;
-        destination = toml::find<T>(node, name);
-        return true;
-    }
-    // A helper function to add elements of a vector to a node under the named heading
-    template <serialisablePointer T>
-    static void fromVectorToTable(const std::vector<T> &vector, std::string name, SerialisedValue &node)
-    {
-        fromVectorToTable(vector, name, node, [](const auto &item) { return item->name().data(); });
-    }
-    // A helper function to add elements of a vector to a node
-    template <typename T, typename Lambda>
-    static SerialisedValue fromVectorToTable(const std::vector<T> &vector, Lambda getName)
-    {
-        SerialisedValue group;
-        for (const auto &value : vector)
-            value->serialise(getName(value), group);
-        return group;
-    };
-    // A helper function to add elements of a KeyedVector to a node
-    template <typename KeyClass, typename ValueClass, typename Lambda>
-    static SerialisedValue fromVectorToTable(const KeyedVector<KeyClass, ValueClass> &keyedVector, Lambda getName)
-    {
-        SerialisedValue group;
-        for (const auto &[key, value] : keyedVector)
-            group[std::string(getName(key))] = value;
-        return group;
-    };
-    // A helper function to add elements of a ResolvableKeyedVector to a node
-    template <typename KeyClass, typename ValueClass>
-    static SerialisedValue fromVectorToTable(const ResolvableKeyedVector<KeyClass, ValueClass> &keyedVector)
-    {
-        SerialisedValue group;
-        for (const auto &[resolvable, value] : keyedVector)
-            group[std::string(resolvable.name())] = value;
-        return group;
-    }
-    template <typename KeyClass, typename ValueClass, typename Lambda>
-    static SerialisedValue fromVectorToTable(const ResolvableKeyedVector<KeyClass, ValueClass> &keyedVector, Lambda getInner)
-    {
-        SerialisedValue group;
-        for (const auto &[resolvable, value] : keyedVector)
-            group[std::string(resolvable.name())] = getInner(value);
-        return group;
-    }
-    // A helper function to add elements of a vector to a node under the named heading
-    template <typename T, typename Lambda>
-    static void fromVectorToTable(const std::vector<T> &vector, std::string name, SerialisedValue &node, Lambda getName)
-    {
-        if (vector.empty())
-            return;
-        node[name] = fromVectorToTable(vector, getName);
-    };
-    // A helper function to add elements of a vector to a node.  This
-    // is more generic than fromVectorToTable and the later could be
-    // be implemented in terms of this function, but the two template
-    // types conflict with the resolution of other overloads.  While
-    // this could be solved with C++20 Concepts, it's probably better
-    // to just remove the other overloads.  That should be another
-    // issue before TOML is merged.
-    template <typename T, typename Lambda, typename Lambda2>
-    static SerialisedValue fromVectorToMap(const std::vector<T> &vector, Lambda getName, Lambda2 getValue)
-    {
-        SerialisedValue group;
-        for (auto &value : vector)
-            group[getName(value)] = getValue(value);
-        return group;
-    };
-    // A helper function to add the elements of a vector to a node under a name
-    template <typename T>
-    static void fromVector(const std::vector<std::unique_ptr<T>> &vector, std::string name, SerialisedValue &node)
-    {
-        fromVector(vector, name, node,
-                   [](const auto &item)
-                   {
-                       SerialisedValue outer;
-                       item->serialise("inner", outer);
-                       return outer["inner"];
-                   });
-    }
-    // A helper function to add the elements of a vector to a node under a name
-    template <typename T>
-    static void fromVector(const std::vector<std::shared_ptr<T>> &vector, std::string name, SerialisedValue &node)
-    {
-        fromVector(vector, name, node, [](const auto &item) { return item->serialise(); });
-    }
-    // A helper function to add the elements of a vector to a node under a name
-    template <typename T> static void fromVector(const std::vector<T> &vector, std::string name, SerialisedValue &node)
-    {
-        fromVector(vector, name, node,
-                   [](const auto &item)
-                   {
-                       SerialisedValue outer;
-                       item.serialise("inner", outer);
-                       return outer["inner"];
-                   });
-    }
-    // A helper function to add the elements of a vector to a node under a name
-    template <typename T, typename Lambda>
-    static void fromVector(const std::vector<T> &vector, std::string name, SerialisedValue &node, Lambda toSerial)
-    {
-        if (vector.empty())
-            return;
-        node[name] = fromVector(vector, toSerial);
-    }
-    // A helper function to add the elements of a vector to a node under a name
-    template <typename T, typename Lambda> static SerialisedValue fromVector(const std::vector<T> &vector, Lambda toSerial)
-    {
-        SerialisedValue result = SerialisedValue::array_type{};
-        std::transform(vector.begin(), vector.end(), std::back_inserter(result), toSerial);
-        return result;
-    }
-    // A helper function to add the elements of a ranged object to a node under a name
-    template <std::ranges::input_range Range, typename Lambda>
-    static SerialisedValue fromRange(const Range &range, Lambda toSerial)
-    {
-        SerialisedValue result = SerialisedValue::array_type{};
-        std::ranges::transform(range, std::back_inserter(result), toSerial);
-        return result;
-    }
-    // A helper function to add the elements of a map to a node under a name
-    template <typename K, typename V> static void fromMap(const std::map<K, V> &map, std::string name, SerialisedValue &node)
-    {
-        SerialisedValue result;
-        for (auto &[key, value] : map)
-            if constexpr (serialisablePointer<V>)
-                value->serialise(std::format("{}", key), result);
-            else if constexpr (std::is_base_of_v<Serialisable, V>)
-                value.serialise(std::format("{}", key), result);
-            else
-                // We use the direct value (with casting) instead of
-                // value.serialise() to handle the case where the value
-                // is a raw type (e.g. int)
-                result[std::format("{}", key)] = value;
-        if (!map.empty())
-            node[name] = result;
-    }
-    // A helper function to add the elements of a map to a node under a name
-    // Only add values that pass the test lambda
-    template <typename K, typename V, typename Lambda>
-    static void fromMap(const std::map<K, V> &map, std::string name, SerialisedValue &node, Lambda filter)
-    {
-        SerialisedValue result;
-        bool changed = false;
-        for (auto &[key, value] : map)
-        {
-            if (!filter(key, value))
-                continue;
-            changed = true;
-            if constexpr (serialisablePointer<V>)
-                value->serialise(std::string(key), result);
-            else
-                // We use the direct value (with casting) instead of
-                // value.serialise() to handle the case where the value
-                // is a raw type (e.g. int)
-                result[std::string(key)] = value;
-        }
-        if (changed)
-            node[name] = result;
-    }
 
-    // Act over each value in a node table, if the key exists
-    template <typename Lambda> static void toMap(const SerialisedValue &node, Lambda action)
-    {
-        for (auto &[key, value] : node.as_table())
-            action(key, value);
-    }
+void serialiseOnto(const int a, std::string tag, SerialisedValue &target);
+void serialiseOnto(const double a, std::string tag, SerialisedValue &target);
+void serialiseOnto(const std::string a, std::string tag, SerialisedValue &target);
+} // namespace Serialisable
 
-    // Act over each value in a node table, if the key exists
-    template <typename Lambda> static void toMap(const SerialisedValue &node, std::string key, Lambda action)
-    {
-        if (!node.contains(key))
-            return;
-
-        for (auto &[subKey, value] : toml::find<SerialisedValue::table_type>(node, key))
-            action(subKey, value);
-    }
-
-    // Act over each value in a node array
-    template <typename Lambda> static void toVector(const SerialisedValue &node, Lambda action)
-    {
-        for (auto &item : node.as_array())
-            action(item);
-    }
-
-    // Act over each value in a node table, if the key exists
-    template <typename Lambda> static void toVector(const SerialisedValue &node, std::string key, Lambda action)
-    {
-        if (!node.contains(key))
-            return;
+namespace Deserialisable
+{
 
-        toVector(node.at(key), action);
-    }
-};
+void deserialiseOnto(bool &a, const SerialisedValue &target);
+void deserialiseOnto(int &a, const SerialisedValue &target);
+void deserialiseOnto(long &a, const SerialisedValue &target);
+void deserialiseOnto(float &a, const SerialisedValue &target);
+void deserialiseOnto(double &a, const SerialisedValue &target);
+void deserialiseOnto(std::string &a, const SerialisedValue &target);
+} // namespace Deserialisable