Upgrade to toml11 4.5.0 (dev branch)

Author: mrexodia

src/project_parser.cpp

@@ -3,6 +3,7 @@
 #include "fs.hpp"
 #include <deque>
 #include <stdexcept>
+#include <sstream>
 #include <toml.hpp>
 
 namespace cmkr {
@@ -30,23 +31,23 @@ static MsvcRuntimeType parse_msvcRuntimeType(const std::string &name) {
     return msvc_last;
 }
 
-using TomlBasicValue = toml::basic_value<toml::discard_comments, tsl::ordered_map, std::vector>;
+using TomlBasicValue = toml::basic_value<toml::ordered_type_config>;
 
-static std::string format_key_message(const std::string &message, const toml::key &ky, const TomlBasicValue &value) {
+static std::string format_key_message(const std::string &message, const std::string &ky, const TomlBasicValue &value) {
     auto loc = value.location();
-    auto line_number_str = std::to_string(loc.line());
+    auto line_number_str = std::to_string(loc.first_line_number());
     auto line_width = line_number_str.length();
-    const auto &line_str = loc.line_str();
+    const auto &line_str = loc.first_line();
 
     std::ostringstream oss;
     oss << message << "\n";
-    oss << " --> " << loc.file_name() << ':' << loc.line() << '\n';
+    oss << " --> " << loc.file_name() << ':' << loc.first_line_number() << '\n';
 
     oss << std::string(line_width + 2, ' ') << "|\n";
     oss << ' ' << line_number_str << " | " << line_str << '\n';
 
     oss << std::string(line_width + 2, ' ') << '|';
-    auto key_start = line_str.substr(0, loc.column() - 1).rfind(ky);
+    auto key_start = line_str.substr(0, loc.first_column_number() - 1).rfind(ky);
     if (key_start == std::string::npos) {
         key_start = line_str.find(ky);
     }
@@ -57,29 +58,29 @@ static std::string format_key_message(const std::string &message, const toml::ke
     return oss.str();
 }
 
-static void throw_key_error(const std::string &error, const toml::key &ky, const TomlBasicValue &value) {
+static void throw_key_error(const std::string &error, const std::string &ky, const TomlBasicValue &value) {
     throw std::runtime_error(format_key_message("[error] " + error, ky, value));
 }
 
-static void print_key_warning(const std::string &message, const toml::key &ky, const TomlBasicValue &value) {
+static void print_key_warning(const std::string &message, const std::string &ky, const TomlBasicValue &value) {
     puts(format_key_message("[warning] " + message, ky, value).c_str());
 }
 
 class TomlChecker {
     const TomlBasicValue &m_v;
-    tsl::ordered_set<toml::key> m_visited;
-    tsl::ordered_set<toml::key> m_conditionVisited;
+    tsl::ordered_set<std::string> m_visited;
+    tsl::ordered_set<std::string> m_conditionVisited;
 
   public:
-    TomlChecker(const TomlBasicValue &v, const toml::key &ky) : m_v(toml::find(v, ky)) {
+    TomlChecker(const TomlBasicValue &v, const std::string &ky) : m_v(toml::find(v, ky)) {
     }
     explicit TomlChecker(const TomlBasicValue &v) : m_v(v) {
     }
     TomlChecker(const TomlChecker &) = delete;
     TomlChecker(TomlChecker &&) = delete;
 
     template <typename T>
-    void optional(const toml::key &ky, Condition<T> &destination) {
+    void optional(const std::string &ky, Condition<T> &destination) {
         // TODO: this algorithm in O(n) over the amount of keys, kinda bad
         const auto &table = m_v.as_table();
         for (const auto &itr : table) {
@@ -104,7 +105,7 @@ class TomlChecker {
     }
 
     template <typename T>
-    void optional(const toml::key &ky, T &destination) {
+    void optional(const std::string &ky, T &destination) {
         // TODO: this currently doesn't allow you to get an optional map<string, X>
         if (m_v.contains(ky)) {
             destination = toml::find<T>(m_v, ky);
@@ -113,26 +114,26 @@ class TomlChecker {
     }
 
     template <typename T>
-    void required(const toml::key &ky, T &destination) {
+    void required(const std::string &ky, T &destination) {
         destination = toml::find<T>(m_v, ky);
         visit(ky);
     }
 
-    bool contains(const toml::key &ky) {
+    bool contains(const std::string &ky) {
         visit(ky);
         return m_v.contains(ky);
     }
 
-    const TomlBasicValue &find(const toml::key &ky) {
+    const TomlBasicValue &find(const std::string &ky) {
         visit(ky);
         return toml::find(m_v, ky);
     }
 
-    void visit(const toml::key &ky) {
+    void visit(const std::string &ky) {
         m_visited.emplace(ky);
     }
 
-    bool visisted(const toml::key &ky) const {
+    bool visisted(const std::string &ky) const {
         return m_visited.contains(ky);
     }
 
@@ -171,7 +172,7 @@ class TomlChecker {
 class TomlCheckerRoot {
     const TomlBasicValue &m_root;
     std::deque<TomlChecker> m_checkers;
-    tsl::ordered_set<toml::key> m_visisted;
+    tsl::ordered_set<std::string> m_visisted;
     bool m_checked = false;
 
   public:
@@ -180,7 +181,7 @@ class TomlCheckerRoot {
     TomlCheckerRoot(const TomlCheckerRoot &) = delete;
     TomlCheckerRoot(TomlCheckerRoot &&) = delete;
 
-    bool contains(const toml::key &ky) {
+    bool contains(const std::string &ky) {
         m_visisted.emplace(ky);
         return m_root.contains(ky);
     }
@@ -190,7 +191,7 @@ class TomlCheckerRoot {
         return m_checkers.back();
     }
 
-    TomlChecker &create(const TomlBasicValue &v, const toml::key &ky) {
+    TomlChecker &create(const TomlBasicValue &v, const std::string &ky) {
         m_checkers.emplace_back(v, ky);
         return m_checkers.back();
     }
@@ -214,7 +215,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
     if (!fs::exists(toml_path)) {
         throw std::runtime_error("File not found '" + toml_path.string() + "'");
     }
-    const auto toml = toml::parse<toml::discard_comments, tsl::ordered_map, std::vector>(toml_path.string());
+    const auto toml = toml::parse<toml::ordered_type_config>(toml_path.string());
     if (toml.size() == 0) {
         throw std::runtime_error("Empty TOML '" + toml_path.string() + "'");
     }
@@ -431,11 +432,11 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                             throw_key_error("Unsupported option value '" + str + "'", str, value);
                         }
                     } else {
-                        throw_key_error(toml::concat_to_string("Unsupported value type: ", ovalue.type()), "value", value);
+                        throw_key_error(std::string("Unsupported value type: ") + toml::to_string(ovalue.type()), "value", value);
                     }
                 }
             } else {
-                throw_key_error(toml::concat_to_string("Unsupported value type: ", itr.second.type()), itr.first, itr.second);
+                throw_key_error(std::string("Unsupported value type: ") + toml::to_string(itr.second.type()), itr.first, itr.second);
             }
             options.push_back(o);
 
@@ -711,7 +712,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                 if (cond_itr.first.empty()) {
                     report = &t.find("msvc-runtime");
                 } else {
-                    report = &t.find(cond_itr.first).as_table().find("msvc-runtime").value();
+                    report = &t.find(cond_itr.first).as_table().at("msvc-runtime");
                 }
                 throw_key_error(error, cond_itr.second, *report);
             }
@@ -722,7 +723,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
         t.optional("alias", target.alias);
 
         if (t.contains("properties")) {
-            auto store_property = [&target](const toml::key &k, const TomlBasicValue &v, const std::string &condition) {
+            auto store_property = [&target](const std::string &k, const TomlBasicValue &v, const std::string &condition) {
                 if (v.is_array()) {
                     std::string property_list;
                     for (const auto &list_val : v.as_array()) {
@@ -840,7 +841,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
 
         for (const auto &p : v.find("packages").as_array()) {
             Vcpkg::Package package;
-            const auto &package_str = p.as_string().str;
+            const auto &package_str = p.as_string();
             const auto open_bracket = package_str.find('[');
             const auto close_bracket = package_str.find(']', open_bracket);
             if (open_bracket == std::string::npos && close_bracket == std::string::npos) {
@@ -923,7 +924,7 @@ bool is_root_path(const std::string &path) {
     if (!fs::exists(toml_path)) {
         return false;
     }
-    const auto toml = toml::parse<toml::discard_comments, tsl::ordered_map, std::vector>(toml_path.string());
+    const auto toml = toml::parse<toml::ordered_type_config>(toml_path.string());
     return toml.contains("project");
 }