1620 Compare Module and Data Source keyword

src/classes/CMakeLists.txt

@@ -28,6 +28,7 @@ add_library(
   configuration_sites.cpp
   configuration_upkeep.cpp
   coreData.cpp
+  dataSource.cpp
   distributor.cpp
   isotopeData.cpp
   isotopologue.cpp
@@ -81,6 +82,7 @@ add_library(
   changeStore.h
   configuration.h
   coreData.h
+  dataSource.h
   distributor.h
   empiricalFormula.h
   interactionPotential.h

src/classes/dataSource.cpp

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (c) 2023 Team Dissolve and contributors
+
+#include "classes/dataSource.h"
+#include "templates/optionalRef.h"
+#include <type_traits>
+
+// Return enum options for data source types
+EnumOptions<DataSource::DataSourceType> DataSource::dataSourceTypes()
+{
+    return EnumOptions<DataSource::DataSourceType>("DataSourceType", {{Internal, "Internal"}, {External, "External"}});
+}
+
+// Return data name (tag or filename)
+std::string_view DataSource::dataName() const { return dataName_; }
+
+// Return whether or not the data has been sourced and exists
+bool DataSource::dataExists() const
+{
+    return (!internalDataSource_.empty() && dataSourceType_ == Internal) ||
+           (!externalDataSource_.valueless_by_exception() && !data_.valueless_by_exception() && dataSourceType_ == External);
+}
+
+// Return data source type enum
+DataSource::DataSourceType DataSource::dataSourceType() const { return dataSourceType_; }
+
+// Return internal data source
+std::optional<std::string> DataSource::internalDataSource() const
+{
+    if (!internalDataSource_.empty())
+    {
+        return internalDataSource_;
+    }
+    return std::nullopt;
+}
+
+// Return external data source
+DataSource::Format &DataSource::externalDataSource() { return externalDataSource_; }
+
+// Function to source data (only required for internal data sources)
+bool DataSource::sourceData(GenericList &processingModuleData)
+{
+    if (!dataExists())
+    {
+        return false;
+    }
+
+    // For Internal data sources, try to locate the data now
+    if (dataSourceType_ == Internal)
+    {
+        if (std::holds_alternative<Data1D>(data_) || std::holds_alternative<SampledData1D>(data_))
+        {
+            // Locate target data from tag and cast to base
+            auto optData = processingModuleData.searchBase<Data1DBase, Data1D, SampledData1D>(internalDataSource_);
+            if (!optData)
+            {
+                return Messenger::error("No data with tag '{}' exists.\n", internalDataSource_);
+            }
+            // Set data
+            data_ = optData->get();
+        }
+        else
+        {
+            // For other data types just visit the variant
+            return std::visit(
+                [=](auto data)
+                {
+                    // Locate target data from tag
+                    auto optData = processingModuleData.search<const decltype(data)>(internalDataSource_);
+                    if (!optData)
+                    {
+                        return Messenger::error("No data with tag '{}' exists.\n", internalDataSource_);
+                    }
+                    // Set data
+                    data_ = optData->get();
+                    return true;
+                },
+                data_);
+        }
+    }
+
+    // Return whether or not variant contains value
+    return !data_.valueless_by_exception();
+}
+
+// Set internal data source
+void DataSource::addData(std::string_view internalDataSource)
+{
+    dataSourceType_ = Internal;
+    internalDataSource_ = internalDataSource;
+    // Set data name to be data tag
+    dataName_ = internalDataSource;
+}
+
+// Write through specified LineParser
+bool DataSource::serialise(LineParser &parser, std::string_view keywordName, std::string_view prefix) const
+{
+    if (!dataExists())
+    {
+        return false;
+    }
+
+    // Write source: internal/external
+    if (!parser.writeLineF("{}{}  ", prefix, dataSourceTypes().keyword(dataSourceType_)))
+    {
+        return false;
+    }
+
+    // For internal data sources just need to write the tag. Externals write the file and format
+    if (dataSourceType_ == Internal)
+    {
+        if (!parser.writeLineF("'{}'\n", internalDataSource_))
+            return false;
+    }
+    else
+    {
+        return std::visit(
+            [&](auto &data)
+            {
+                // Write filename and format
+                if (!data.writeFilenameAndFormat(parser, prefix))
+                {
+                    return false;
+                }
+
+                // Write extra keywords
+                if (!data.writeBlock(parser, prefix)) // Express as a serialisable value
+                {
+                    return false;
+                }
+
+                // Write extra keywords
+                if (!data.writeBlock(parser, prefix)) // Express as a serialisable value
+                {
+                    return false;
+                }
+
+                // End the block
+                if (!parser.writeLineF("End{}", dataSourceTypes().keyword(External)))
+                {
+                    return false;
+                }
+
+                return true;
+            },
+            externalDataSource_);
+    }
+
+    return true;
+}
+
+// Express as a serialisable value
+SerialisedValue DataSource::serialise() const
+{
+    SerialisedValue result;
+
+    result["dataSourceType"] = dataSourceTypes().keyword(dataSourceType_);
+    if (dataSourceType_ == Internal)
+    {
+        result["data"] = internalDataSource_;
+    }
+    else
+    {
+        result["data"] = std::visit([](auto &data) { return data.serialise(); }, externalDataSource_);
+    }
+
+    return result;
+}

src/classes/dataSource.h

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (c) 2023 Team Dissolve and contributors
+
+#pragma once
+
+#include "base/serialiser.h"
+#include "io/fileAndFormat.h"
+#include "io/import/data1D.h"
+#include "io/import/data2D.h"
+#include "io/import/data3D.h"
+#include "items/list.h"
+#include "keywords/dataSourceBase.h"
+#include "math/data1D.h"
+#include "math/data2D.h"
+#include "math/data3D.h"
+#include "math/sampledData1D.h"
+#include <variant>
+
+class DataSource
+{
+    public:
+    using DataType = std::variant<Data1D, SampledData1D, Data2D, Data3D>;
+    using Format = std::variant<Data1DImportFileFormat, Data2DImportFileFormat, Data3DImportFileFormat>;
+
+    public:
+    DataSource() = default;
+    ~DataSource() = default;
+
+    public:
+    // Data Source Types
+    enum DataSourceType
+    {
+        Internal,
+        External
+    };
+    // Return enum options for DataSourceType
+    static EnumOptions<DataSourceType> dataSourceTypes();
+    // Return data source type enum
+    DataSourceType dataSourceType() const;
+
+    /*
+     * Data
+     */
+    private:
+    // Name of data (tag or filename)
+    std::string dataName_;
+    // Type of data being stored
+    DataSourceType dataSourceType_;
+    // String to hold internal data tag (if internal)
+    std::string internalDataSource_;
+    // Variant to hold file and format of external data (if external)
+    Format externalDataSource_;
+    // Variant to hold data
+    DataType data_;
+
+    public:
+    // Return data name
+    std::string_view dataName() const;
+    // Return if data exists and has been initialised
+    bool dataExists() const;
+    // Return internal data source
+    std::optional<std::string> internalDataSource() const;
+    // Return external data source
+    Format &externalDataSource();
+    // Source specified data (only required for internal data sources)
+    bool sourceData(GenericList &processingModuleData);
+    // Set internal data source
+    void addData(std::string_view internalDataSource);
+    // Overloaded function to add external data
+    template <class D> void addData(D data, typename D::Formatter &fileAndFormat)
+    {
+        dataSourceType_ = External;
+        // Create format object in place in variant
+        externalDataSource_.emplace<typename D::Formatter>(fileAndFormat);
+        data_ = data;
+        // Set data name to be base filename
+        dataName_ = fileAndFormat.filename().substr(fileAndFormat.filename().find_last_of("/\\") + 1);
+    }
+    // Returns data in the requested type
+    template <class D> D data() const
+    {
+        assert(dataExists());
+        return std::get<D>(data_);
+    }
+
+    /*
+     * I/O
+     */
+    public:
+    // Write through specified LineParser
+    bool serialise(LineParser &parser, std::string_view keywordName, std::string_view prefix) const;
+    // Express as a serialisable value
+    SerialisedValue serialise() const;
+};