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

src/fesa/io/abaqus/domain_mapper.cpp

@@ -147,10 +147,10 @@ public:
             finalizeModel();
         }
         if (failure_) {
-            return Result<Domain>::failure(Status::failure(
+            return Result<Domain>::Failure(Status::Failure(
                 failure_->category, {std::move(failure_->diagnostic)}));
         }
-        sortDiagnostics(definition_.warnings);
+        SortDiagnostics(definition_.warnings);
         return Domain::create(std::move(definition_));
     }
 
@@ -177,7 +177,7 @@ private:
         if (!failure_) {
             failure_ = MappingFailure{
                 category,
-                {Severity::error,
+                {Severity::kError,
                  std::move(code),
                  location,
                  std::move(keyword),
@@ -194,7 +194,7 @@ private:
         std::string entityIdentity,
         std::string message) {
         return fail(
-            FailureCategory::input,
+            FailureCategory::kInput,
             std::move(code),
             location,
             std::move(keyword),
@@ -209,7 +209,7 @@ private:
         std::string entityIdentity,
         std::string message) {
         return fail(
-            FailureCategory::model,
+            FailureCategory::kModel,
             std::move(code),
             location,
             std::move(keyword),
@@ -1677,7 +1677,7 @@ private:
         // One warning per allowlisted keyword keeps no-op provenance stable;
         // subordinate variable rows remain attached to that keyword record.
         definition_.warnings.push_back({
-            Severity::warning,
+            Severity::kWarning,
             "ignored-input-keyword",
             block.location,
             block.canonicalName,
@@ -1781,15 +1781,15 @@ private:
                 definition_.nodes,
                 definition_.shellElements,
                 definition_.shellSections);
-            if (!geometry.hasValue()) {
-                const auto& status = geometry.status();
+            if (!geometry.HasValue()) {
+                const auto& status = geometry.GetStatus();
                 failure_ = MappingFailure{
-                    status.failureCategory().value_or(FailureCategory::model),
-                    status.diagnostics().front()};
+                    status.Category().value_or(FailureCategory::kModel),
+                    status.Diagnostics().front()};
                 return;
             }
             definition_.shellNodeInitialFrames =
-                std::move(geometry.value().nodalFrames);
+                std::move(geometry.Value().nodalFrames);
         }
         expandAssemblySets();
         if (failure_) {
@@ -2357,7 +2357,7 @@ private:
             for (std::size_t index = 0U;
                  index < definition_.nodes.size();
                  ++index) {
-                if (definition_.nodes[index].sourceId.sourceLabel == label) {
+                if (definition_.nodes[index].sourceId.source_label == label) {
                     matchingNodes.push_back(static_cast<EntityIndex>(index));
                 }
             }

src/fesa/io/abaqus/input_reader.cpp

@@ -86,14 +86,14 @@ Result<ParsedInput> failure(
     std::string keyword,
     std::string message) {
     Diagnostic diagnostic{
-        Severity::error,
+        Severity::kError,
         std::move(code),
         {sourcePath, line},
         std::move(keyword),
         "",
         std::move(message)};
-    return Result<ParsedInput>::failure(Status::failure(
-        FailureCategory::input, {std::move(diagnostic)}));
+    return Result<ParsedInput>::Failure(Status::Failure(
+        FailureCategory::kInput, {std::move(diagnostic)}));
 }
 
 } // namespace
@@ -210,7 +210,7 @@ Result<ParsedInput> AbaqusInputReader::read(
         ++lineNumber;
     }
 
-    return Result<ParsedInput>::success(std::move(parsed));
+    return Result<ParsedInput>::Success(std::move(parsed));
 }
 
 } // namespace fesa