feat(cpp-object-oriented-modular-refactoring): step 18 - load-hierarchy

src/fesa/model/domain.cpp

@@ -1,11 +1,66 @@
 #include "fesa/model/domain.h"
 
 #include <cstddef>
+#include <functional>
 #include <memory>
 #include <utility>
 
 namespace fesa {
 
+StepDefinition::StepDefinition(StaticStepDefinition definition)
+    : name_{std::move(definition.name)},
+      boundaries_{std::move(definition.boundaries)},
+      initial_increment_{definition.initial_increment},
+      time_period_{definition.time_period},
+      minimum_increment_{definition.minimum_increment},
+      maximum_increment_{definition.maximum_increment},
+      location_{std::move(definition.location)} {
+  loads_.reserve(definition.loads.size());
+  loads_view_.reserve(definition.loads.size());
+  for (std::size_t source_order = 0U; source_order < definition.loads.size();
+       ++source_order) {
+    auto& load = definition.loads[source_order];
+    auto owned = std::make_unique<ConcentratedNodalLoad>(
+        SourceTargetQuery{SourceEntityKind::kNode, "", load.target}, load.dof,
+        load.magnitude, source_order, std::move(load.location));
+    loads_view_.push_back(std::cref(*owned));
+    concentrated_loads_view_.Add(*owned);
+    loads_.push_back(std::move(owned));
+  }
+}
+
+const std::string& StepDefinition::Name() const noexcept { return name_; }
+
+const std::vector<BoundaryCondition>& StepDefinition::Boundaries()
+    const noexcept {
+  return boundaries_;
+}
+
+const LoadView& StepDefinition::Loads() const noexcept { return loads_view_; }
+
+const DomainCollectionView<ConcentratedNodalLoad>&
+StepDefinition::ConcentratedLoads() const noexcept {
+  return concentrated_loads_view_;
+}
+
+double StepDefinition::InitialIncrement() const noexcept {
+  return initial_increment_;
+}
+
+double StepDefinition::TimePeriod() const noexcept { return time_period_; }
+
+double StepDefinition::MinimumIncrement() const noexcept {
+  return minimum_increment_;
+}
+
+double StepDefinition::MaximumIncrement() const noexcept {
+  return maximum_increment_;
+}
+
+const SourceLocation& StepDefinition::Location() const noexcept {
+  return location_;
+}
+
 Result<Domain> Domain::Create(ModelDefinition definition) {
   return Result<Domain>::Success(Domain{std::move(definition)});
 }
@@ -66,8 +121,8 @@ const std::vector<ElementSet>& Domain::ElementSets() const noexcept {
   return definition_.element_sets;
 }
 
-const std::vector<StaticStepDefinition>& Domain::Steps() const noexcept {
-  return definition_.steps;
+const DomainCollectionView<StepDefinition>& Domain::Steps() const noexcept {
+  return steps_view_;
 }
 
 const std::vector<Diagnostic>& Domain::Warnings() const noexcept {
@@ -131,6 +186,15 @@ Domain::Domain(ModelDefinition definition)
     element_definitions_.push_back(std::move(owned));
   }
   definition_.shell_elements.clear();
+
+  step_definitions_.reserve(definition_.steps.size());
+  for (auto& step : definition_.steps) {
+    auto owned =
+        std::unique_ptr<StepDefinition>(new StepDefinition(std::move(step)));
+    steps_view_.Add(*owned);
+    step_definitions_.push_back(std::move(owned));
+  }
+  definition_.steps.clear();
 }
 
 }  // namespace fesa