logical: implement technical space properties transform

Author: mcraveiro

projects/dogen.logical/include/dogen.logical/types/transforms/technical_space_properties_transform.hpp

@@ -25,15 +25,52 @@
 #pragma once
 #endif
 
+#include <list>
+#include <boost/optional/optional.hpp>
+#include "dogen.identification/types/entities/logical_name_tree.hpp"
 #include "dogen.logical/types/entities/model.hpp"
 #include "dogen.logical/types/transforms/context.hpp"
+#include "dogen.logical/types/entities/element.hpp"
+#include "dogen.logical/types/entities/attribute.hpp"
+#include "dogen.logical/types/features/technical_space_properties.hpp"
+#include "dogen.logical/types/entities/structural/technical_space_properties.hpp"
 
 namespace dogen::logical::transforms {
 
 /**
  * @brief Reads technical space specific properties.
  */
 class technical_space_properties_transform final {
+private:
+    static boost::optional<entities::structural::technical_space_properties>
+    obtain_properties(
+        const features::technical_space_properties::feature_group& fg,
+        entities::element& e);
+
+    static std::unordered_map<identification::entities::logical_id,
+                              entities::structural::technical_space_properties>
+    obtain_properties(const variability::entities::feature_model& fm,
+        entities::model& m);
+
+private:
+    static void
+    walk_name_tree(const identification::entities::logical_name_tree& nt,
+        const bool is_top_level, const std::unordered_map<
+        identification::entities::logical_id,
+        entities::structural::technical_space_properties>& src_tsps,
+        entities::structural::technical_space_properties& dest_tsp);
+
+    static entities::structural::technical_space_properties
+    compute_properties(
+        const std::unordered_map<identification::entities::logical_id,
+        entities::structural::technical_space_properties>& src_tsps,
+        const std::list<logical::entities::attribute>& attrs);
+
+    static void populate_properties(
+        const std::unordered_map<identification::entities::logical_id,
+        entities::structural::technical_space_properties>& src_tsps,
+        entities::model& m);
+
 public:
     static void apply(const context& ctx, entities::model& m);
 };

projects/dogen.logical/src/types/transforms/technical_space_properties_transform.cpp

@@ -20,11 +20,17 @@
  */
 #include <boost/throw_exception.hpp>
 #include "dogen.utility/types/log/logger.hpp"
+#include "dogen.utility/types/io/unordered_map_io.hpp"
 #include "dogen.tracing/types/scoped_tracer.hpp"
 #include "dogen.variability/types/helpers/configuration_selector.hpp"
+#include "dogen.identification/io/entities/logical_id_io.hpp"
 #include "dogen.logical/io/entities/model_io.hpp"
+#include "dogen.logical/types/entities/structural/object.hpp"
+#include "dogen.logical/types/entities/structural/primitive.hpp"
+#include "dogen.logical/io/entities/structural/technical_space_properties_io.hpp"
 #include "dogen.logical/types/entities/structural/technical_space_properties.hpp"
-#include "dogen.logical/types/features/technical_space_properties.hpp"
+#include "dogen.logical/types/transforms/transformation_error.hpp"
+#include "dogen.logical/types/entities/elements_traversal.hpp"
 #include "dogen.logical/types/transforms/technical_space_properties_transform.hpp"
 
 namespace {
@@ -41,11 +47,161 @@ const std::string duplicate_id("Duplicate ID: ");
 
 namespace dogen::logical::transforms {
 
+boost::optional<entities::structural::technical_space_properties>
+technical_space_properties_transform::obtain_properties(
+    const features::technical_space_properties::feature_group& fg,
+    entities::element& e) {
+
+    const auto id(e.name().id());
+    BOOST_LOG_SEV(lg, debug) << "Procesing element: " << id;
+
+    /*
+     * If we do not have any configuration related to streaming
+     * operations, there is nothing to do.
+     */
+    const auto& cfg(*e.configuration());
+    const variability::helpers::configuration_selector s(cfg);
+    if (!s.has_configuration_point(fg.requires_manual_default_constructor) &&
+        !s.has_configuration_point(fg.requires_manual_move_constructor) &&
+        !s.has_configuration_point(fg.requires_stream_manipulators)) {
+        BOOST_LOG_SEV(lg, debug) << "No properties found.";
+        return boost::optional<
+            entities::structural::technical_space_properties>();
+    }
+
+    /*
+     * Create the properties and slot them into the results container.
+     */
+    entities::structural::technical_space_properties r;
+    const auto scfg(features::technical_space_properties::
+        make_static_configuration(fg, cfg));
+    r.requires_manual_default_constructor(
+        scfg.requires_manual_default_constructor);
+    r.requires_manual_move_constructor(
+        scfg.requires_manual_move_constructor);
+    r.requires_stream_manipulators(scfg.requires_stream_manipulators);
+
+    return r;
+}
+
+std::unordered_map<identification::entities::logical_id,
+                   entities::structural::technical_space_properties>
+technical_space_properties_transform::obtain_properties(
+    const variability::entities::feature_model& fm,
+    entities::model& m) {
+
+    const auto fg(features::technical_space_properties::make_feature_group(fm));
+    std::unordered_map<identification::entities::logical_id,
+                       entities::structural::technical_space_properties> r;
+
+    entities::elements_traversal(m,
+        [&](entities::element& e) {
+            const auto o(obtain_properties(fg, e));
+            if (!o)
+                return;
+
+            const auto id(e.name().id());
+            const auto pair(std::make_pair(id, *o));
+            const auto inserted(r.insert(pair).second);
+            if (!inserted) {
+                BOOST_LOG_SEV(lg, error) << duplicate_id << id;
+                BOOST_THROW_EXCEPTION(
+                    transformation_error(duplicate_id + id.value()));
+            }
+        });
+    BOOST_LOG_SEV(lg, debug) << "Streaming properties: " << r;
+    return r;
+}
+
+void technical_space_properties_transform::
+walk_name_tree(const identification::entities::logical_name_tree& nt,
+    const bool is_top_level, const std::unordered_map<
+    identification::entities::logical_id,
+    entities::structural::technical_space_properties>& src_tsps,
+    entities::structural::technical_space_properties& dest_tsp) {
+
+    for (const auto& c : nt.children())
+        walk_name_tree(c, false/*is_top_level*/, src_tsps, dest_tsp);
+
+    if (is_top_level && nt.is_current_simple_type())
+        dest_tsp.requires_manual_default_constructor(true);
+
+    const auto i(src_tsps.find(nt.current().id()));
+    if (i == src_tsps.end())
+        return;
+
+    const auto src_tsp(i->second);
+    if (src_tsp.requires_stream_manipulators())
+        dest_tsp.requires_stream_manipulators(true);
+
+    if (!is_top_level)
+        return;
+
+    if (src_tsp.requires_manual_default_constructor())
+        dest_tsp.requires_manual_default_constructor(true);
+
+    if (src_tsp.requires_manual_move_constructor())
+        dest_tsp.requires_manual_move_constructor(true);
+}
+
+entities::structural::technical_space_properties
+technical_space_properties_transform::compute_properties(
+    const std::unordered_map<identification::entities::logical_id,
+    entities::structural::technical_space_properties>& src_tsps,
+    const std::list<logical::entities::attribute>& attrs) {
+
+    entities::structural::technical_space_properties r;
+    for (const auto& attr : attrs) {
+        const auto& nt(attr.parsed_type());
+        walk_name_tree(nt, true/*is_top_level*/, src_tsps, r);
+    }
+    return r;
+}
+
+void technical_space_properties_transform::populate_properties(
+    const std::unordered_map<identification::entities::logical_id,
+    entities::structural::technical_space_properties>& src_tsps,
+    entities::model& m) {
+
+    using identification::entities::model_type;
+    auto& se(m.structural_elements());
+    for (auto& pair : se.objects()) {
+        /*
+         * We only need to generate the properties for elements of the
+         * target model.
+         */
+        auto& e(*pair.second);
+        if (e.provenance().model_type() != model_type::target)
+            continue;
+
+        const auto& attrs(e.local_attributes());
+        e.technical_space_properties(compute_properties(src_tsps, attrs));
+    }
+
+    for (auto& pair : se.primitives()) {
+        /*
+         * We only need to generate the properties for elements of the
+         * target model.
+         */
+        auto& p(*pair.second);
+        if (p.provenance().model_type() != model_type::target)
+            continue;
+
+        using logical::entities::attribute;
+        const std::list<attribute> attrs{ p.value_attribute() };
+        p.technical_space_properties(compute_properties(src_tsps, attrs));
+    }
+}
+
 void technical_space_properties_transform::
 apply(const context &ctx, entities::model &m) {
     tracing::scoped_transform_tracer stp(lg, "technical space properties",
         transform_id, m.name().qualified().dot(), *ctx.tracer(), m);
 
+    const auto& fm(*ctx.feature_model());
+    const auto src_tsps(obtain_properties(fm, m));
+    populate_properties(src_tsps, m);
+
     stp.end_transform(m);
 }