Form read write split

form/form/CMakeLists.txt

@@ -3,5 +3,5 @@
 # External dependencies: find_package( PHLEX )
 
 # Component(s) in the package:
-add_library(form form.cpp config.cpp)
+add_library(form form_reader.cpp form_writer.cpp config.cpp)
 target_link_libraries(form persistence)

form/form/form_reader.cpp

@@ -0,0 +1,37 @@
+// Copyright (C) 2025 ...
+
+#include "form_reader.hpp"
+
+#include <stdexcept>
+#include <typeinfo>
+
+namespace form::experimental {
+
+  form_reader_interface::form_reader_interface(config::output_item_config const& output_config,
+                                               config::tech_setting_config const& tech_config) :
+    m_pers(nullptr)
+  {
+    for (auto const& item : output_config.getItems()) {
+      m_product_to_config.emplace(item.product_name,
+                                  form::experimental::config::PersistenceItem(
+                                    item.product_name, item.file_name, item.technology));
+    }
+
+    m_pers = form::detail::experimental::createPersistenceReader();
+    m_pers->configureOutputItems(output_config);
+    m_pers->configureTechSettings(tech_config);
+  }
+
+  void form_reader_interface::read(std::string const& creator,
+                                   std::string const& segment_id,
+                                   product_with_name& pb)
+  {
+
+    auto it = m_product_to_config.find(pb.label);
+    if (it == m_product_to_config.end()) {
+      throw std::runtime_error("No configuration found for product: " + pb.label);
+    }
+
+    m_pers->read(creator, pb.label, segment_id, &pb.data, *pb.type);
+  }
+}

form/form/form_reader.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2025 ...
+
+#ifndef FORM_FORM_FORM_READER_HPP
+#define FORM_FORM_FORM_READER_HPP
+
+#include "form/config.hpp"
+#include "form/product_with_name.hpp"
+#include "persistence/ipersistence_reader.hpp"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+namespace form::experimental {
+
+  class form_reader_interface {
+  public:
+    form_reader_interface(config::output_item_config const& output_config,
+                          config::tech_setting_config const& tech_config);
+    ~form_reader_interface() = default;
+
+    void read(std::string const& creator,
+              std::string const& segment_id,
+              product_with_name& product);
+
+  private:
+    std::unique_ptr<form::detail::experimental::IPersistenceReader> m_pers;
+    std::map<std::string, form::experimental::config::PersistenceItem> m_product_to_config;
+  };
+}
+
+#endif // FORM_FORM_FORM_READER_HPP

form/form/form.cpp → form/form/form_writer.cpp

@@ -1,14 +1,14 @@
 // Copyright (C) 2025 ...
 
-#include "form.hpp"
+#include "form_writer.hpp"
 
 #include <stdexcept>
 #include <typeinfo>
 
 namespace form::experimental {
 
-  form_interface::form_interface(config::output_item_config const& output_config,
-                                 config::tech_setting_config const& tech_config) :
+  form_writer_interface::form_writer_interface(config::output_item_config const& output_config,
+                                               config::tech_setting_config const& tech_config) :
     m_pers(nullptr)
   {
     for (auto const& item : output_config.getItems()) {
@@ -17,14 +17,14 @@ namespace form::experimental {
                                     item.product_name, item.file_name, item.technology));
     }
 
-    m_pers = form::detail::experimental::createPersistence();
+    m_pers = form::detail::experimental::createPersistenceWriter();
     m_pers->configureOutputItems(output_config);
     m_pers->configureTechSettings(tech_config);
   }
 
-  void form_interface::write(std::string const& creator,
-                             std::string const& segment_id,
-                             product_with_name const& pb)
+  void form_writer_interface::write(std::string const& creator,
+                                    std::string const& segment_id,
+                                    product_with_name const& pb)
   {
 
     auto it = m_product_to_config.find(pb.label);
@@ -40,9 +40,9 @@ namespace form::experimental {
     m_pers->commitOutput(creator, segment_id);
   }
 
-  void form_interface::write(std::string const& creator,
-                             std::string const& segment_id,
-                             std::vector<product_with_name> const& products)
+  void form_writer_interface::write(std::string const& creator,
+                                    std::string const& segment_id,
+                                    std::vector<product_with_name> const& products)
   {
 
     if (products.empty())
@@ -69,16 +69,4 @@ namespace form::experimental {
     m_pers->commitOutput(creator, segment_id);
   }
 
-  void form_interface::read(std::string const& creator,
-                            std::string const& segment_id,
-                            product_with_name& pb)
-  {
-
-    auto it = m_product_to_config.find(pb.label);
-    if (it == m_product_to_config.end()) {
-      throw std::runtime_error("No configuration found for product: " + pb.label);
-    }
-
-    m_pers->read(creator, pb.label, segment_id, &pb.data, *pb.type);
-  }
 }

form/form/form_writer.hpp

@@ -0,0 +1,37 @@
+// Copyright (C) 2025 ...
+
+#ifndef FORM_FORM_FORM_WRITER_HPP
+#define FORM_FORM_FORM_WRITER_HPP
+
+#include "form/config.hpp"
+#include "form/product_with_name.hpp"
+#include "persistence/ipersistence_writer.hpp"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace form::experimental {
+
+  class form_writer_interface {
+  public:
+    form_writer_interface(config::output_item_config const& output_config,
+                          config::tech_setting_config const& tech_config);
+    ~form_writer_interface() = default;
+
+    void write(std::string const& creator,
+               std::string const& segment_id,
+               product_with_name const& product);
+
+    void write(std::string const& creator,
+               std::string const& segment_id,
+               std::vector<product_with_name> const& products);
+
+  private:
+    std::unique_ptr<form::detail::experimental::IPersistenceWriter> m_pers;
+    std::map<std::string, form::experimental::config::PersistenceItem> m_product_to_config;
+  };
+}
+
+#endif // FORM_FORM_FORM_WRITER_HPP

form/form/product_with_name.hpp

@@ -0,0 +1,15 @@
+#ifndef FORM_FORM_PRODUCT_WITH_NAME_HPP
+#define FORM_FORM_PRODUCT_WITH_NAME_HPP
+
+#include <string>
+#include <typeinfo>
+
+namespace form::experimental {
+  struct product_with_name {
+    std::string label;
+    void const* data;
+    std::type_info const* type;
+  };
+}
+
+#endif // FORM_FORM_PRODUCT_WITH_NAME_HPP

form/form_module.cpp

@@ -5,7 +5,7 @@
 // FORM headers - these need to be available via CMake configuration
 // need to set up the build system to find these headers
 #include "form/config.hpp"
-#include "form/form.hpp"
+#include "form/form_writer.hpp"
 #include "form/technology.hpp"
 
 #include <cassert>
@@ -43,7 +43,8 @@ namespace {
       }
 
       // Initialize FORM interface
-      m_form_interface = std::make_unique<form::experimental::form_interface>(output_cfg, tech_cfg);
+      m_form_interface =
+        std::make_unique<form::experimental::form_writer_interface>(output_cfg, tech_cfg);
     }
 
     // This method is called by Phlex - signature must be: void(product_store const&)
@@ -102,7 +103,7 @@ namespace {
   private:
     std::string const m_output_file;
     int const m_technology;
-    std::unique_ptr<form::experimental::form_interface> m_form_interface;
+    std::unique_ptr<form::experimental::form_writer_interface> m_form_interface;
   };
 
 }

form/persistence/CMakeLists.txt

@@ -1,5 +1,5 @@
 # Copyright (C) 2025 ...
 
 # Component(s) in the package:
-add_library(persistence persistence.cpp)
+add_library(persistence persistence_reader.cpp persistence_writer.cpp persistence_utils.cpp)
 target_link_libraries(persistence core storage)

form/persistence/ipersistence_reader.hpp

@@ -0,0 +1,40 @@
+// Copyright (C) 2025 ...
+
+#ifndef FORM_PERSISTENCE_IPERSISTENCE_READER_HPP
+#define FORM_PERSISTENCE_IPERSISTENCE_READER_HPP
+
+#include <map>
+#include <memory>
+#include <string>
+#include <typeinfo>
+
+namespace form::experimental::config {
+  class output_item_config;
+  struct tech_setting_config;
+}
+
+namespace form::detail::experimental {
+
+  class IPersistenceReader {
+  public:
+    IPersistenceReader() {};
+    virtual ~IPersistenceReader() = default;
+
+    virtual void configureTechSettings(
+      form::experimental::config::tech_setting_config const& tech_config_settings) = 0;
+
+    virtual void configureOutputItems(
+      form::experimental::config::output_item_config const& outputItems) = 0;
+
+    virtual void read(std::string const& creator,
+                      std::string const& label,
+                      std::string const& id,
+                      void const** data,
+                      std::type_info const& type) = 0;
+  };
+
+  std::unique_ptr<IPersistenceReader> createPersistenceReader();
+
+} // namespace form::detail::experimental
+
+#endif // FORM_PERSISTENCE_IPERSISTENCE_READER_HPP

form/persistence/ipersistence.hpp → form/persistence/ipersistence_writer.hpp

@@ -1,7 +1,7 @@
 // Copyright (C) 2025 ...
 
-#ifndef FORM_PERSISTENCE_IPERSISTENCE_HPP
-#define FORM_PERSISTENCE_IPERSISTENCE_HPP
+#ifndef FORM_PERSISTENCE_IPERSISTENCE_WRITER_HPP
+#define FORM_PERSISTENCE_IPERSISTENCE_WRITER_HPP
 
 #include <map>
 #include <memory>
@@ -15,10 +15,10 @@ namespace form::experimental::config {
 
 namespace form::detail::experimental {
 
-  class IPersistence {
+  class IPersistenceWriter {
   public:
-    IPersistence() {};
-    virtual ~IPersistence() = default;
+    IPersistenceWriter() {};
+    virtual ~IPersistenceWriter() = default;
 
     virtual void configureTechSettings(
       form::experimental::config::tech_setting_config const& tech_config_settings) = 0;
@@ -33,16 +33,10 @@ namespace form::detail::experimental {
                                void const* data,
                                std::type_info const& type) = 0;
     virtual void commitOutput(std::string const& creator, std::string const& id) = 0;
-
-    virtual void read(std::string const& creator,
-                      std::string const& label,
-                      std::string const& id,
-                      void const** data,
-                      std::type_info const& type) = 0;
   };
 
-  std::unique_ptr<IPersistence> createPersistence();
+  std::unique_ptr<IPersistenceWriter> createPersistenceWriter();
 
 } // namespace form::detail::experimental
 
-#endif // FORM_PERSISTENCE_IPERSISTENCE_HPP
+#endif // FORM_PERSISTENCE_IPERSISTENCE_WRITER_HPP