store original axis name instead of axis0,1.

Base/Util/StringUtil.cpp

@@ -17,7 +17,6 @@
 #include <boost/algorithm/string.hpp>
 #include <cerrno>
 #include <charconv>
-#include <regex>
 #include <string>
 
 //! Returns string right-padded with blanks.

Device/IO/IOFactory.cpp

@@ -265,9 +265,10 @@ bool Util::RW::dataMatchesFile(const Datafield& data, const std::string& refFile
     std::unique_ptr<Datafield> refDat;
     try {
         refDat.reset(IO::readData2D(refFileName));
-    } catch (...) {
+    } catch (const std::exception& ex) {
         std::cerr << "File comparison: Could not read reference data from file " << refFileName
                   << std::endl;
+        std::cerr << "Error message: " << ex.what() << std::endl;
         return false;
     }
     ASSERT(refDat);

Device/IO/ParseUtil.cpp

@@ -21,18 +21,10 @@
 #include <functional>
 #include <iostream>
 #include <iterator>
+#include <regex>
 
 namespace {
 
-std::istringstream getAxisStringRepresentation(std::istream& input_stream)
-{
-    std::string line;
-    std::getline(input_stream, line);
-    const std::vector<std::string> to_replace = {",", "\"", "(", ")", "[", "]"};
-    Base::String::replaceItemsFromString(line, to_replace, " ");
-    return std::istringstream(line);
-}
-
 void readLineOfDoubles(std::vector<double>& buffer, std::istringstream& iss)
 {
     iss.imbue(std::locale::classic());
@@ -40,42 +32,59 @@ void readLineOfDoubles(std::vector<double>& buffer, std::istringstream& iss)
               back_inserter(buffer));
 }
 
+std::vector<double> parse_x_list(std::string text, const std::string& type)
+{
+    if (text.substr(0, 1) == ",") {
+        std::cerr << "Warning: file format from BornAgain <= 20 is obsolete" << std::endl;
+        size_t i = text.find_first_not_of(" ", 1);
+        text.erase(0, i);
+    }
+    if (text.substr(0, 1) == "[" && text.substr(text.size() - 1, 1) == "]")
+        text = text.substr(1, text.size() - 2);
+    std::vector<std::string> arr = Base::String::split(text, ",");
+    std::vector<double> result;
+    for (std::string e : arr) {
+        e = Base::String::trim(e);
+        if (e.empty())
+            continue;
+        double x;
+        if (!(Base::String::to_double(e, &x)))
+            throw std::runtime_error("Reading " + type + ": cannot read entry '" + e + "'");
+        result.push_back(x);
+    }
+    if (!result.size())
+        throw std::runtime_error("Reading " + type + ": found empty list");
+    return result;
+}
+
 } // namespace
 
 //! Creates axis of certain type from input stream
 Scale* Util::Parse::parseScale(std::istream& input_stream)
 {
-    auto iss = ::getAxisStringRepresentation(input_stream);
-    std::string type;
-    if (!(iss >> type))
-        throw std::runtime_error("Cannot read axis type from input");
-
+    std::string line;
+    std::getline(input_stream, line);
+    std::smatch matched;
+    std::regex_match(line, matched, std::regex("(\\w+)\\(\"(.*?)\",\\s*(.+?)\\)"));
+    if (matched.size() != 4)
+        throw std::runtime_error("Cannot read axis from input");
+    const std::string type = matched[1];
+    const std::string name = matched[2];
+    const std::string body = matched[3];
     if (type == "EquiDivision" || type == "FixedBinAxis" /* for compatibility with pre-21 */) {
-        std::string name;
-        size_t nbins;
-        if (!(iss >> name >> nbins))
-            throw std::runtime_error("Reading EquiDivision: cannot read name or size");
-        std::vector<double> boundaries;
-        ::readLineOfDoubles(boundaries, iss);
-        if (boundaries.size() != 2)
-            throw std::runtime_error("Reading EquiDivision: cannot read start or stop");
-        return newEquiDivision(name, nbins, boundaries[0], boundaries[1]);
+        std::vector<std::string> arr = Base::String::split(body, ",");
+        int nbins;
+        double xmi, xma;
+        if (!(Base::String::to_int(arr[0], &nbins) && Base::String::to_double(arr[1], &xmi)
+              && Base::String::to_double(arr[2], &xma)))
+            throw std::runtime_error("Reading EquiDivision: cannot read parameters");
+        return newEquiDivision(name, nbins, xmi, xma);
 
     } else if (type == "ListScan" || type == "DiscreteAxis" /* for compatibility with pre-21 */) {
-        std::string name;
-        if (!(iss >> name))
-            throw std::runtime_error("Reading ListScan: cannot read name");
-        std::vector<double> coordinates;
-        ::readLineOfDoubles(coordinates, iss);
-        return newListScan(name, coordinates);
+        return newListScan(name, parse_x_list(body, type));
 
     } else if (type == "Scale") {
-        std::string name;
-        if (!(iss >> name))
-            throw std::runtime_error("Reading Scale: cannot read name");
-        std::vector<double> coordinates;
-        ::readLineOfDoubles(coordinates, iss);
-        return newGenericScale(name, coordinates);
+        return newGenericScale(name, parse_x_list(body, type));
 
     } else
         throw std::runtime_error("Unknown axis type '" + type + "'");

Device/IO/ReadWriteINT.cpp

@@ -60,12 +60,10 @@ void Util::RW::writeBAInt(const Datafield& data, std::ostream& output_stream)
     output_stream << "# BornAgain Intensity Data\n\n";
 
     for (size_t i = 0; i < data.rank(); ++i) {
-        std::string axis_name = std::string("axis") + std::to_string(i);
-        std::unique_ptr<Scale> axis(data.axis(i).clone());
-        axis->setAxisName(axis_name);
+        const Scale& axis = data.axis(i);
         output_stream << std::endl;
         output_stream << "# axis-" << i << "\n";
-        output_stream << (*axis) << "\n";
+        output_stream << axis << "\n";
     }
     size_t n_columns = data.axis(data.rank() - 1).size();