feat(cpp-object-oriented-modular-refactoring): step 13 - element-definition-domain

src/fesa/model/domain.cpp

@@ -1,5 +1,7 @@
 #include "fesa/model/domain.h"
 
+#include <cstddef>
+#include <memory>
 #include <utility>
 
 namespace fesa {
@@ -12,25 +14,43 @@ const std::vector<Node>& Domain::Nodes() const noexcept {
   return definition_.nodes;
 }
 
-const std::vector<EulerBeam3DDefinition>& Domain::Elements() const noexcept {
-  return definition_.elements;
-}
-
-const std::vector<Mitc4ShellDefinition>& Domain::ShellElements()
+const DomainCollectionView<ElementDefinition>& Domain::Elements()
     const noexcept {
-  return definition_.shell_elements;
+  return elements_view_;
 }
 
-const std::vector<LinearElasticMaterial>& Domain::Materials() const noexcept {
-  return definition_.materials;
+const DomainCollectionView<EulerBeam3DDefinition>& Domain::BeamElements()
+    const noexcept {
+  return beam_elements_view_;
 }
 
-const std::vector<GeneralBeamSection>& Domain::Sections() const noexcept {
-  return definition_.sections;
+const DomainCollectionView<Mitc4ShellDefinition>& Domain::ShellElements()
+    const noexcept {
+  return shell_elements_view_;
 }
 
-const std::vector<ShellSection>& Domain::ShellSections() const noexcept {
-  return definition_.shell_sections;
+const DomainCollectionView<Material>& Domain::Materials() const noexcept {
+  return materials_view_;
+}
+
+const DomainCollectionView<LinearElasticMaterial>&
+Domain::LinearElasticMaterials() const noexcept {
+  return linear_materials_view_;
+}
+
+const DomainCollectionView<ElementProperty>& Domain::Properties()
+    const noexcept {
+  return properties_view_;
+}
+
+const DomainCollectionView<GeneralBeamSection>& Domain::Sections()
+    const noexcept {
+  return sections_view_;
+}
+
+const DomainCollectionView<ShellSection>& Domain::ShellSections()
+    const noexcept {
+  return shell_sections_view_;
 }
 
 const std::vector<ShellNodeInitialFrame>& Domain::ShellNodeInitialFrames()
@@ -63,6 +83,54 @@ const std::string& Domain::SourceContentIdentity() const noexcept {
 }
 
 Domain::Domain(ModelDefinition definition)
-    : definition_{std::move(definition)} {}
+    : definition_{std::move(definition)} {
+  materials_.reserve(definition_.materials.size());
+  for (auto& material : definition_.materials) {
+    auto owned = std::make_unique<LinearElasticMaterial>(std::move(material));
+    materials_view_.Add(*owned);
+    linear_materials_view_.Add(*owned);
+    materials_.push_back(std::move(owned));
+  }
+  definition_.materials.clear();
+
+  element_properties_.reserve(definition_.sections.size() +
+                              definition_.shell_sections.size());
+  for (auto& section : definition_.sections) {
+    auto owned = std::make_unique<GeneralBeamSection>(std::move(section));
+    properties_view_.Add(*owned);
+    sections_view_.Add(*owned);
+    element_properties_.push_back(std::move(owned));
+  }
+  const std::size_t beam_property_count = element_properties_.size();
+  definition_.sections.clear();
+  for (auto& section : definition_.shell_sections) {
+    auto owned = std::make_unique<ShellSection>(std::move(section));
+    properties_view_.Add(*owned);
+    shell_sections_view_.Add(*owned);
+    element_properties_.push_back(std::move(owned));
+  }
+  definition_.shell_sections.clear();
+
+  element_definitions_.reserve(definition_.elements.size() +
+                               definition_.shell_elements.size());
+  for (auto& element : definition_.elements) {
+    element.SynchronizeNodeIndices();
+    auto owned = std::make_unique<EulerBeam3DDefinition>(std::move(element));
+    elements_view_.Add(*owned);
+    beam_elements_view_.Add(*owned);
+    element_definitions_.push_back(std::move(owned));
+  }
+  definition_.elements.clear();
+  for (auto& element : definition_.shell_elements) {
+    element.SynchronizeNodeIndices();
+    element.SetPropertyIndex(
+        static_cast<EntityIndex>(beam_property_count + element.section_index));
+    auto owned = std::make_unique<Mitc4ShellDefinition>(std::move(element));
+    elements_view_.Add(*owned);
+    shell_elements_view_.Add(*owned);
+    element_definitions_.push_back(std::move(owned));
+  }
+  definition_.shell_elements.clear();
+}
 
 }  // namespace fesa

src/fesa/model/source_target_resolver.cpp

@@ -96,27 +96,17 @@ SourceTargetIndex SourceTargetIndex::FromDomain(const Domain& domain) {
     }
   }
 
-  for (std::size_t index = 0U; index < domain.Elements().size(); ++index) {
+  for (std::size_t index = 0U; index < domain.Elements().Size(); ++index) {
     const auto& element = domain.Elements()[index];
     entries.push_back({SourceEntityKind::kElement,
-                       element.source_id.instance_name, "", element.source_id,
-                       static_cast<EntityIndex>(index), declaration_order++});
-  }
-  for (std::size_t index = 0U; index < domain.ShellElements().size(); ++index) {
-    const auto& element = domain.ShellElements()[index];
-    entries.push_back({SourceEntityKind::kElement,
-                       element.source_id.instance_name, "", element.source_id,
+                       element.SourceId().instance_name, "", element.SourceId(),
                        static_cast<EntityIndex>(index), declaration_order++});
   }
   for (const auto& set : domain.ElementSets()) {
     for (const EntityIndex element_index : set.element_indices) {
       SourceEntityId source_id{set.instance_name.value_or(""), 0, ""};
-      if (domain.ShellElements().empty() &&
-          element_index < domain.Elements().size()) {
-        source_id = domain.Elements()[element_index].source_id;
-      } else if (domain.Elements().empty() &&
-                 element_index < domain.ShellElements().size()) {
-        source_id = domain.ShellElements()[element_index].source_id;
+      if (element_index < domain.Elements().Size()) {
+        source_id = domain.Elements()[element_index].SourceId();
       }
       entries.push_back({SourceEntityKind::kElement,
                          set.instance_name.value_or(source_id.instance_name),