[RF][HS3] Remove remnants of YAML IO

Author: guitargeek

roofit/doc/developers/roofit_hs3.md

@@ -16,15 +16,6 @@ with other statistical frameworks, and also ease of manipulation, it
 may be useful to store statistical models in text form. This library
 sets out to achieve exactly that, exporting to and importing from JSON.
 
-### Backend
-
-The default backend for this is the `nlohmann` JSON implementation,
-which ships with ROOT as a builtin dependency and will import from and
-export to JSON.
-In the past, RapidYAML (`RYML`) was supported, but the effort to keep
-this implementation up to date was too high. YML users could use YML to
-JSON converters to migrate.
-
 ### Usage
 
 The main class providing import from and export to JSON is the

roofit/hs3/inc/RooFitHS3/RooJSONFactoryWSTool.h

@@ -145,18 +145,12 @@ class RooJSONFactoryWSTool {
    readBinnedData(const RooFit::Detail::JSONNode &n, const std::string &namecomp, RooArgSet const &vars);
 
    bool importJSON(std::string const &filename);
-   bool importYML(std::string const &filename);
    bool importJSON(std::istream &os);
-   bool importYML(std::istream &os);
    bool exportJSON(std::string const &fileName);
-   bool exportYML(std::string const &fileName);
    bool exportJSON(std::ostream &os);
-   bool exportYML(std::ostream &os);
 
    std::string exportJSONtoString();
-   std::string exportYMLtoString();
    bool importJSONfromString(const std::string &s);
-   bool importYMLfromString(const std::string &s);
    void importJSONElement(const std::string &name, const std::string &jsonString);
    void importVariableElement(const RooFit::Detail::JSONNode &n);
 

roofit/hs3/src/RooJSONFactoryWSTool.cxx

@@ -2040,18 +2040,6 @@ bool RooJSONFactoryWSTool::importJSONfromString(const std::string &s)
    return importJSON(ss);
 }
 
-/**
- * @brief Import the workspace from a YML string.
- *
- * @param s The YML string containing the workspace data.
- * @return bool Returns true on successful import, false otherwise.
- */
-bool RooJSONFactoryWSTool::importYMLfromString(const std::string &s)
-{
-   std::stringstream ss(s);
-   return importYML(ss);
-}
-
 /**
  * @brief Export the workspace to a JSON string.
  *
@@ -2064,18 +2052,6 @@ std::string RooJSONFactoryWSTool::exportJSONtoString()
    return ss.str();
 }
 
-/**
- * @brief Export the workspace to a YML string.
- *
- * @return std::string The YML string representing the exported workspace.
- */
-std::string RooJSONFactoryWSTool::exportYMLtoString()
-{
-   std::stringstream ss;
-   exportYML(ss);
-   return ss.str();
-}
-
 /**
  * @brief Create a new JSON tree with version information.
  *
@@ -2131,35 +2107,6 @@ bool RooJSONFactoryWSTool::exportJSON(std::string const &filename)
    return this->exportJSON(out);
 }
 
-/**
- * @brief Export the workspace to YML format and write to the output stream.
- *
- * @param os The output stream to write the YML data to.
- * @return bool Returns true on successful export, false otherwise.
- */
-bool RooJSONFactoryWSTool::exportYML(std::ostream &os)
-{
-   std::unique_ptr<JSONTree> tree = createNewJSONTree();
-   JSONNode &n = tree->rootnode();
-   this->exportAllObjects(n);
-   n.writeYML(os);
-   return true;
-}
-
-/**
- * @brief Export the workspace to YML format and write to the specified file.
- *
- * @param filename The name of the YML file to create and write the data to.
- * @return bool Returns true on successful export, false otherwise.
- */
-bool RooJSONFactoryWSTool::exportYML(std::string const &filename)
-{
-   std::ofstream out(filename.c_str());
-   if (!out.is_open())
-      RooJSONFactoryWSTool::error("RooJSONFactoryWSTool() invalid output file '" + filename + "'.");
-   return this->exportYML(out);
-}
-
 bool RooJSONFactoryWSTool::hasAttribute(const std::string &obj, const std::string &attrib)
 {
    if (!_attributesNode)
@@ -2366,37 +2313,6 @@ bool RooJSONFactoryWSTool::importJSON(std::string const &filename)
    return this->importJSON(infile);
 }
 
-/**
- * @brief Imports a YML file from the given input stream to the workspace.
- *
- * @param is The input stream containing the YML data.
- * @return bool Returns true on successful import, false otherwise.
- */
-bool RooJSONFactoryWSTool::importYML(std::istream &is)
-{
-   // import a YML file to the workspace
-   std::unique_ptr<JSONTree> tree = JSONTree::create(is);
-   JSONNode const &rootnode = tree->rootnode();
-   this->importAllNodes(rootnode);
-   importParameterStepWidths(*this->workspace(), rootnode);
-   return true;
-}
-
-/**
- * @brief Imports a YML file from the given filename to the workspace.
- *
- * @param filename The name of the YML file to import.
- * @return bool Returns true on successful import, false otherwise.
- */
-bool RooJSONFactoryWSTool::importYML(std::string const &filename)
-{
-   // import a YML file to the workspace
-   std::ifstream infile(filename.c_str());
-   if (!infile.is_open())
-      RooJSONFactoryWSTool::error("RooJSONFactoryWSTool() invalid input file '" + filename + "'.");
-   return this->importYML(infile);
-}
-
 void RooJSONFactoryWSTool::importJSONElement(const std::string &name, const std::string &jsonString)
 {
    // Create the JSON Tree from the string

roofit/jsoninterface/inc/RooFit/Detail/JSONInterface.h

@@ -210,17 +210,7 @@ class JSONTree {
    static std::unique_ptr<JSONTree> create(std::istream &is);
    static std::unique_ptr<JSONTree> create(std::string const &str);
 
-   static std::string getBackend();
-   static void setBackend(std::string const &name);
-
-   static bool hasBackend(std::string const &name);
-
 private:
-   // Internally, we store the backend type with an enum to be more memory efficient.
-   enum class Backend { NlohmannJson, Ryml };
-
-   static Backend &getBackendEnum();
-
    template <typename... Args>
    static std::unique_ptr<JSONTree> createImpl(Args &&...args);
 };

roofit/jsoninterface/src/JSONInterface.cxx

@@ -13,9 +13,6 @@
 #include <RooFit/Detail/JSONInterface.h>
 
 #include "JSONParser.h"
-#ifdef ROOFIT_WITH_RYML
-#include "RYMLParser.h"
-#endif
 
 #include <sstream>
 
@@ -79,13 +76,6 @@ std::ostream &operator<<(std::ostream &os, JSONNode const &s)
 template <typename... Args>
 std::unique_ptr<JSONTree> JSONTree::createImpl(Args &&...args)
 {
-   if (getBackendEnum() == Backend::Ryml) {
-#ifdef ROOFIT_WITH_RYML
-      return std::make_unique<TRYMLTree>(std::forward<Args>(args)...);
-#else
-      throw std::runtime_error("Requesting JSON tree with rapidyaml backend, which is currently unsupported.");
-#endif
-   }
    return std::make_unique<TJSONTree>(std::forward<Args>(args)...);
 }
 
@@ -105,46 +95,5 @@ std::unique_ptr<JSONTree> JSONTree::create(std::string const &str)
    return JSONTree::create(ss);
 }
 
-/// Check if ROOT was compiled with support for a certain JSON backend library.
-/// \param[in] name Name of the backend.
-bool JSONTree::hasBackend(std::string const &name)
-{
-   if (name == "rapidyaml") {
-#ifdef ROOFIT_WITH_RYML
-      return true;
-#else
-      return false;
-#endif
-   }
-   if (name == "nlohmann-json")
-      return true;
-   return false;
-}
-
-JSONTree::Backend &JSONTree::getBackendEnum()
-{
-   static Backend backend = Backend::NlohmannJson;
-   return backend;
-}
-
-/// Returns the name of the library that serves as the backend for the JSON
-/// interface, which is either `"nlohmann-json"` or `"rapidyaml"`.
-/// \return Backend name as a string.
-std::string JSONTree::getBackend()
-{
-   return getBackendEnum() == Backend::Ryml ? "rapidyaml" : "nlohmann-json";
-}
-
-/// Set the library that serves as the backend for the JSON interface. Note that the `"rapidyaml"` backend is only
-/// supported if rapidyaml was found on the system when ROOT was compiled. \param[in] name Name of the backend, can be
-/// either `"nlohmann-json"` or `"rapidyaml"`.
-void JSONTree::setBackend(std::string const &name)
-{
-   if (name == "rapidyaml")
-      getBackendEnum() = Backend::Ryml;
-   if (name == "nlohmann-json")
-      getBackendEnum() = Backend::NlohmannJson;
-}
-
 } // namespace Detail
 } // namespace RooFit