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