Merge pull request #31 from FAIRDataPipeline/dev

Dev

Author: RyanJField

.github/workflows/fdp_cpp_api.yaml

@@ -109,3 +109,27 @@ jobs:
           cmake -Bbuild -DFDPAPI_BUILD_TESTS=ON
       - name: Compile FDP-Cpp-API
         run: cmake --build build --config=Release
+  Build_GCC_4_8:
+    name: Build GCC 4.8
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+        with: 
+          python-version: "3.9"
+          architecture: "x64"
+      - name: Set up GCC
+        uses: egor-tensin/setup-gcc@v1
+        with:
+          version: 4.8
+          platform: x64
+      - name: Install Dependencies
+        run: |
+          sudo apt update
+          sudo apt install -y lcov libjsoncpp-dev curl libcurl4-openssl-dev libyaml-cpp-dev gcovr
+      - name: Configure Library
+        run: |
+          cmake -Bbuild
+      - name: Build Library
+        run: |
+          cmake --build build

.gitignore

@@ -5,4 +5,5 @@ build/
 test/data_store/
 data_store/
 .fair
-venv/
+venv/
+test/data/temp/

include/fdp/exceptions.hxx

@@ -7,34 +7,37 @@
 namespace FairDataPipeline {
 class config_parsing_error : public std::runtime_error {
 public:
-  config_parsing_error(const std::string& message)
-      : std::runtime_error(message) {}
+  using std::runtime_error::runtime_error;
 };
 
 class rest_apiquery_error : public std::runtime_error {
 public:
-  rest_apiquery_error(const std::string& message)
-      : std::runtime_error(message) {}
+  using std::runtime_error::runtime_error;
 };
 
 class json_parse_error : public std::runtime_error {
 public:
-  json_parse_error(const std::string& message) : std::runtime_error(message) {}
+  using std::runtime_error::runtime_error;
 };
 
 class validation_error : public std::runtime_error {
 public:
-  validation_error(const std::string& message) : std::runtime_error(message) {}
+  using std::runtime_error::runtime_error;
 };
 
 class sync_error : public std::runtime_error {
 public:
-  sync_error(const std::string& message) : std::runtime_error(message) {}
+  using std::runtime_error::runtime_error;
 };
 
 class write_error : public std::runtime_error {
 public:
-  write_error(const std::string& message) : std::runtime_error(message) {}
+  using std::runtime_error::runtime_error;
+};
+
+class toml_error : public std::runtime_error {
+public:
+  using std::runtime_error::runtime_error;
 };
 
 }; // namespace FairDataPipeline

include/fdp/objects/distribution.hxx

@@ -0,0 +1,52 @@
+#ifndef __FDP_DISTRIBUTION_HXX__
+#define __FDP_DISTRIBUTION_HXX__
+
+#include <string>
+#include <ghc/filesystem.hpp>
+
+namespace FairDataPipeline {
+    /**
+     * @brief Class for API objects
+     * 
+     */
+    class Distribution {
+
+        public:
+            Distribution(const std::string &name, double mu, double sigma):
+                _name(name),
+                _mu(mu),
+                _sigma(sigma),
+                _component("0"){};
+            Distribution(const std::string &name, double mu, double sigma, const std::string &component):
+                _name(name),
+                _mu(mu),
+                _sigma(sigma),
+                _component(component){};
+            explicit Distribution(const std::string &file_name);
+            Distribution(const std::string &file_name, const std::string &component);
+            virtual ~Distribution() = default;
+            std::string get_name() const {return _name;}
+            double get_mu() const {return _mu;}
+            double get_sigma() const {return _sigma;}
+            std::string get_component() const {return _component;}
+
+            std::string write_to_toml(std::string &file_name);
+            std::string write_to_toml(std::string &component, std::string &file_name);
+
+        private:
+            std::string _name;
+            double _mu;
+            double _sigma;
+            std::string _component;
+        
+        protected:
+            void read_from_toml(const ghc::filesystem::path &file_path, const std::string &component);
+            virtual bool isEqual(const Distribution& dist) const;
+            friend bool operator==(const Distribution& lhs, const Distribution& rhs){
+                return typeid(lhs) == typeid(rhs) && lhs.isEqual(rhs);
+            }
+    };
+
+}; // namespace FairDataPipeline
+
+#endif

include/fdp/registry/data_io.hxx renamed to include/fdp/utilities/data_io.hxx

@@ -26,6 +26,7 @@
 #include "fdp/objects/metadata.hxx"
 #include "fdp/utilities/logging.hxx"
 #include "fdp/utilities/semver.hxx"
+#include "fdp/exceptions.hxx"
 
 namespace FairDataPipeline {
 
@@ -44,64 +45,53 @@ namespace FairDataPipeline {
  *    @snippet `test/test_filesystem.cxx TestTOMLPERead
  *
  *****************************************************************************/
-double read_point_estimate_from_toml(const ghc::filesystem::path var_address);
+double read_point_estimate_from_toml(const ghc::filesystem::path file_path);
+double read_point_estimate_from_toml(const ghc::filesystem::path file_path, const std::string &component);
+toml::value read_parameter_from_toml(const ghc::filesystem::path file_path,
+                                     const std::string &parameter);
+toml::value read_parameter_from_toml(const ghc::filesystem::path file_path,
+                                     const std::string &parameter,
+                                     const std::string &component);
+toml::value read_data_from_toml(const ghc::filesystem::path file_path);
+toml::value read_component_from_toml(const ghc::filesystem::path file_path, const std::string &component);
+
+ghc::filesystem::path write_toml_data(ghc::filesystem::path file_path, 
+                                      const std::string &component,
+                                      const toml::value &data);
 
 /**
  * @brief Create an estimate
  * 
  * @tparam T 
  * @param value 
- * @param data_product 
- * @param version_num 
- * @param config 
+ * @param file_path
  * @return ghc::filesystem::path 
  */
 template <typename T>
-ghc::filesystem::path create_estimate(T &value,
-                                      const ghc::filesystem::path &data_product,
-                                      const Versioning::version &version_num,
-                                      const Config *config
+ghc::filesystem::path write_toml_parameter(T &value,
+                                      const std::string &parameter,
+                                      const std::string &component,
+                                      const ghc::filesystem::path file_path
                                       ) {
-  const std::string param_name_ = data_product.stem().string();
-  const std::string namespace_ = config->get_default_output_namespace();
-  const ghc::filesystem::path data_store_ = config->get_data_store();
-  const toml::value data_{
-      {param_name_, {{"type", "point-estimate"}, {"value", value}}}};
-
-  const ghc::filesystem::path output_filename_ =
-      data_store_ / namespace_ / data_product.parent_path() /
-      std::string(version_num.to_string() + ".toml");
-  std::ofstream toml_out_;
-
-  if (!ghc::filesystem::exists(output_filename_.parent_path())) {
-    ghc::filesystem::create_directories(output_filename_.parent_path());
-  }
-
-  toml_out_.open(output_filename_.string());
 
-  if (!toml_out_) {
-    throw std::runtime_error("Failed to open TOML file for writing");
-  }
-
-  toml_out_ << toml::format(data_);
-
-  toml_out_.close();
+  const toml::value data_{
+      {component, {{"type", parameter}, {"value", value}}}};
+  return write_toml_data(file_path, component, data_);
+  
+}
 
- 
-  auto the_logger = logger::get_logger();
-  the_logger->debug() 
-      <<  "FileSystem:CreateEstimate: Wrote point estimate to '" << output_filename_.string() << "'";
 
-  return output_filename_;
+template <typename T>
+ghc::filesystem::path
+write_point_estimate(T &value, const std::string &component,
+                     const ghc::filesystem::path file_path) {
+  return write_toml_parameter(value, "point-estimate",
+                              component, file_path);
 }
 
-/**
- * @brief Get the first key of a given toml value
- * 
- * @param data_table 
- * @return std::string 
- */
-std::string get_first_key_(const toml::value data_table);
+std::string get_first_component(const ghc::filesystem::path &file_path);
+
+bool component_exists(const ghc::filesystem::path &file_path, const std::string &component);
 
 }; // namespace FairDataPipeline
 

include/fdp/utilities/logging.hxx

@@ -159,7 +159,7 @@ namespace FairDataPipeline {
                         Logger* _logger;
                         enum LOG_LEVEL _msg_lvl;
 
-                        std::ostringstream _oss;
+                        std::ostringstream _oss{""};
                 };
 
                 static sptr create( enum LOG_LEVEL lvl, Sink::sptr sink, std::string name="" );

src/fdp.cxx

@@ -9,7 +9,7 @@
 #include "fdp/objects/config.hxx"
 #include "fdp/objects/metadata.hxx"
 #include "fdp/registry/api.hxx"
-#include "fdp/registry/data_io.hxx"
+#include "fdp/utilities/data_io.hxx"
 #include "fdp/utilities/logging.hxx"
 
 namespace FairDataPipeline {

src/objects/distribution.cxx

@@ -0,0 +1,82 @@
+#include "fdp/objects/distribution.hxx"
+#include "fdp/exceptions.hxx"
+#include "fdp/utilities/data_io.hxx"
+
+#include <vector>
+
+namespace FairDataPipeline {
+Distribution::Distribution(const std::string &file_name) {
+  ghc::filesystem::path file_name_(file_name);
+  _component = get_first_component(ghc::filesystem::path(file_name_));
+  read_from_toml(file_name_, _component);
+}
+Distribution::Distribution(const std::string &file_name,
+                           const std::string &component)
+    : _component(component) {
+  ghc::filesystem::path file_name_(file_name);
+  read_from_toml(file_name_, _component);
+}
+
+void Distribution::read_from_toml(const ghc::filesystem::path &file_path,
+                                  const std::string &component) {
+  auto data_ = read_component_from_toml(file_path, component);
+  if (!data_.contains("type")) {
+    throw toml_error("Error Toml file: " + file_path.string() +
+                     " does not contain a type tag");
+  }
+
+  if (data_.at("type").as_string() != "distribution") {
+    throw toml_error("Error component: " + component +
+                     " does not contain a distribution");
+  }
+
+  std::vector<std::string> required_keys_{"distribution", "mu", "sigma"};
+
+  for (const auto &key : required_keys_) {
+    if (!data_.contains(key)) {
+      throw toml_error("Error component: " + component +
+                       " does not contain a " + key);
+    }
+  }
+
+  _name = data_.at("distribution").as_string();
+
+  if (data_.at("mu").is_floating()) {
+    _mu = data_.at("mu").as_floating();
+  } else if (data_.is_integer()) {
+    _mu = static_cast<double>(data_.at("mu").as_integer());
+  } else {
+    throw toml_error("Error mu value is not a number");
+  }
+
+  if (data_.at("sigma").is_floating()) {
+    _sigma = data_.at("sigma").as_floating();
+  } else if (data_.is_integer()) {
+    _sigma = static_cast<double>(data_.at("sigma").as_integer());
+  } else {
+    throw toml_error("Error sigma value is not a number");
+  }
+}
+
+std::string Distribution::write_to_toml(std::string &file_name) {
+  return write_to_toml(_component, file_name);
+}
+
+std::string Distribution::write_to_toml(std::string &component,
+                                        std::string &file_name) {
+  const toml::value data_{{component,
+                           {{"type", "distribution"},
+                            {"distribution", _name},
+                            {"mu", _mu},
+                            {"sigma", _sigma}}}};
+
+  return write_toml_data(ghc::filesystem::path(file_name), component, data_)
+      .string();
+}
+
+bool Distribution::isEqual(const Distribution &dist) const {
+  return this->_component == dist._component && this->_mu == dist._mu &&
+         this->_name == dist._name && this->_sigma == dist._sigma;
+}
+
+}; // namespace FairDataPipeline