feat(cpp-object-oriented-modular-refactoring): step 3 - foundation-google-style

src/fesa/analysis/analysis_model.cpp

@@ -7,9 +7,9 @@ namespace fesa {
 
 Result<AnalysisModel> AnalysisModel::create(const Domain& domain) {
     if (domain.steps().empty()) {
-        return Result<AnalysisModel>::failure(Status::failure(
-            FailureCategory::input,
-            {{Severity::error,
+        return Result<AnalysisModel>::Failure(Status::Failure(
+            FailureCategory::kInput,
+            {{Severity::kError,
               "invalid-model-cardinality",
               {domain.sourcePath(), 0U},
               "STEP",
@@ -18,16 +18,16 @@ Result<AnalysisModel> AnalysisModel::create(const Domain& domain) {
     }
     if (domain.steps().size() > 1U) {
         const auto& secondStep = domain.steps()[1];
-        return Result<AnalysisModel>::failure(Status::failure(
-            FailureCategory::input,
-            {{Severity::error,
+        return Result<AnalysisModel>::Failure(Status::Failure(
+            FailureCategory::kInput,
+            {{Severity::kError,
               "unsupported-multiple-step",
               secondStep.location,
               "STEP",
               secondStep.name,
               "AnalysisModel does not support multiple steps."}}));
     }
-    return Result<AnalysisModel>::success(AnalysisModel{domain});
+    return Result<AnalysisModel>::Success(AnalysisModel{domain});
 }
 
 const Domain& AnalysisModel::domain() const noexcept {

src/fesa/analysis/analysis_state.cpp

@@ -16,9 +16,9 @@ Status shellCandidateFailure(
     const std::string& code,
     const std::string& identity,
     const std::string& message) {
-    return Status::failure(
-        FailureCategory::model,
-        {{Severity::error,
+    return Status::Failure(
+        FailureCategory::kModel,
+        {{Severity::kError,
           code,
           {},
           "ANALYSIS_STATE",
@@ -224,7 +224,7 @@ Status AnalysisState::commitShellResults(
     physicalStrainEnergy_ = candidate.physicalStrainEnergy;
     equilibrium_ = candidate.equilibrium;
     verificationMetrics_ = candidate.verificationMetrics;
-    return Status::ok();
+    return Status::Ok();
 }
 
 const std::vector<ShellResultRow>& AnalysisState::shellResults() const noexcept {

src/fesa/analysis/linear_static_analysis.cpp

@@ -7,7 +7,7 @@
 #include "fesa/io/abaqus/input_reader.hpp"
 #include "fesa/results/result_recovery.hpp"
 #include "fesa/results/results_writer.hpp"
-#include "fesa/solvers/linear/linear_solver.hpp"
+#include "fesa/solvers/linear/linear_solver.h"
 
 #include <utility>
 
@@ -15,31 +15,31 @@ namespace fesa {
 
 Status Analysis::run(const AnalysisRequest& request) {
     Status status = initialize(request);
-    if (!status.isOk()) {
+    if (!status.IsOk()) {
         return status;
     }
     status = buildAnalysisModel();
-    if (!status.isOk()) {
+    if (!status.IsOk()) {
         return status;
     }
     status = buildDofMapAndSparsePattern();
-    if (!status.isOk()) {
+    if (!status.IsOk()) {
         return status;
     }
     status = assembleAndPartitionStiffness();
-    if (!status.isOk()) {
+    if (!status.IsOk()) {
         return status;
     }
     status = factorize();
-    if (!status.isOk()) {
+    if (!status.IsOk()) {
         return status;
     }
     status = assembleLoadsAndEffectiveRhs();
-    if (!status.isOk()) {
+    if (!status.IsOk()) {
         return status;
     }
     status = substituteAndReconstruct();
-    if (!status.isOk()) {
+    if (!status.IsOk()) {
         return status;
     }
     return recoverAndWriteResults();
@@ -67,100 +67,100 @@ Status LinearStaticAnalysis::initialize(const AnalysisRequest& request) {
     request_ = request;
 
     const auto parsed = AbaqusInputReader{}.read(request_.inputPath);
-    if (!parsed.hasValue()) {
-        return parsed.status();
+    if (!parsed.HasValue()) {
+        return parsed.GetStatus();
     }
-    auto domain = AbaqusDomainMapper{}.map(parsed.value());
-    if (!domain.hasValue()) {
-        return domain.status();
+    auto domain = AbaqusDomainMapper{}.map(parsed.Value());
+    if (!domain.HasValue()) {
+        return domain.GetStatus();
     }
 
-    domain_ = std::make_unique<Domain>(std::move(domain.value()));
+    domain_ = std::make_unique<Domain>(std::move(domain.Value()));
     diagnostics_ = domain_->warnings();
-    sortDiagnostics(diagnostics_);
-    return Status::ok();
+    SortDiagnostics(diagnostics_);
+    return Status::Ok();
 }
 
 Status LinearStaticAnalysis::buildAnalysisModel() {
     auto model = AnalysisModel::create(*domain_);
-    if (!model.hasValue()) {
-        return model.status();
+    if (!model.HasValue()) {
+        return model.GetStatus();
     }
-    model_ = std::make_unique<AnalysisModel>(std::move(model.value()));
-    return Status::ok();
+    model_ = std::make_unique<AnalysisModel>(std::move(model.Value()));
+    return Status::Ok();
 }
 
 Status LinearStaticAnalysis::buildDofMapAndSparsePattern() {
     auto dofs = DofManager::create(*model_);
-    if (!dofs.hasValue()) {
-        return dofs.status();
+    if (!dofs.HasValue()) {
+        return dofs.GetStatus();
     }
-    dofs_ = std::make_unique<DofManager>(std::move(dofs.value()));
+    dofs_ = std::make_unique<DofManager>(std::move(dofs.Value()));
     state_ = std::make_unique<AnalysisState>(
         AnalysisState::create(*dofs_, {"Step-1", 0U}));
-    return Status::ok();
+    return Status::Ok();
 }
 
 Status LinearStaticAnalysis::assembleAndPartitionStiffness() {
     auto stiffness = SparseAssembler::assembleStiffness(
         *model_, *dofs_, parallelFor_);
-    if (!stiffness.hasValue()) {
-        return stiffness.status();
+    if (!stiffness.HasValue()) {
+        return stiffness.GetStatus();
     }
     fullStiffness_ =
-        std::make_unique<SparseMatrix>(std::move(stiffness.value()));
+        std::make_unique<SparseMatrix>(std::move(stiffness.Value()));
 
     auto partitioned = EssentialConstraints::partition(
         *fullStiffness_, *dofs_);
-    if (!partitioned.hasValue()) {
-        return partitioned.status();
+    if (!partitioned.HasValue()) {
+        return partitioned.GetStatus();
     }
     partitionedStiffness_ = std::make_unique<PartitionedStiffness>(
-        std::move(partitioned.value()));
-    return Status::ok();
+        std::move(partitioned.Value()));
+    return Status::Ok();
 }
 
 Status LinearStaticAnalysis::factorize() {
     // This call intentionally precedes all load assembly in Analysis::run.
-    return linearSolver_.factorize(partitionedStiffness_->kff);
+    return linearSolver_.Factorize(partitionedStiffness_->kff);
 }
 
 Status LinearStaticAnalysis::assembleLoadsAndEffectiveRhs() {
     auto fullLoad = LoadAssembler::assembleFullNodalLoad(*model_, *dofs_);
-    if (!fullLoad.hasValue()) {
-        return fullLoad.status();
+    if (!fullLoad.HasValue()) {
+        return fullLoad.GetStatus();
     }
-    state_->externalForce() = std::move(fullLoad.value());
+    state_->externalForce() = std::move(fullLoad.Value());
 
     auto rhs = LoadAssembler::effectiveFreeRhs(
         state_->externalForce(),
         partitionedStiffness_->kfc,
         dofs_->prescribedValues(),
         *dofs_);
-    if (!rhs.hasValue()) {
-        return rhs.status();
+    if (!rhs.HasValue()) {
+        return rhs.GetStatus();
     }
-    effectiveRhs_ = std::make_unique<Vector>(std::move(rhs.value()));
-    return Status::ok();
+    effectiveRhs_ = std::make_unique<Vector>(std::move(rhs.Value()));
+    return Status::Ok();
 }
 
 Status LinearStaticAnalysis::substituteAndReconstruct() {
     Vector freeDisplacement{dofs_->freeDofCount()};
     const Status solveStatus =
-        linearSolver_.solve(*effectiveRhs_, freeDisplacement);
-    if (!solveStatus.isOk()) {
+        linearSolver_.Solve(*effectiveRhs_, freeDisplacement);
+    if (!solveStatus.IsOk()) {
         return solveStatus;
     }
 
     state_->displacement() = EssentialConstraints::reconstructFull(
         freeDisplacement, dofs_->prescribedValues(), *dofs_);
-    return Status::ok();
+    return Status::Ok();
 }
 
 Status LinearStaticAnalysis::recoverAndWriteResults() {
     const Status recoveryStatus = ResultRecovery::recover(
         *model_, *dofs_, *fullStiffness_, *state_);
-    if (!recoveryStatus.isOk()) {
+    if (!recoveryStatus.IsOk()) {
         return recoveryStatus;
     }
     return resultsWriter_.write(