refactor: reference paths to headers explicitly

youwen5 · youwen5 · commit 63d9a4183efe · 2025-01-03T18:25:34.000-08:00
diff --git a/include/stateOfLab_s/components/thermometer.h b/include/stateOfLab_s/components/thermometer.h
@@ -1,28 +1,27 @@
 #ifndef THERMOMETER_H
 #define THERMOMETER_H
 
-#include "lab_component.h"
+#include "stateOfLab_s/lab_component.h"
 #include <iostream>
 
 class Thermometer : public LabComponent<double> {
 public:
-    // Constructor
-    explicit Thermometer(const std::string& id, double initial_angle = 0.0)
-        : LabComponent(id), angle(initial_angle) {}
+  // Constructor
+  explicit Thermometer(const std::string &id, double initial_angle = 0.0)
+      : LabComponent(id), angle(initial_angle) {}
 
-    // Override the updateComponent method
-    void updateComponent(const double& new_angle) override {
-        angle = new_angle;
-        std::cout << "Thermometer " << getID() << " updated to angle: " << angle << std::endl;
-    }
+  // Override the updateComponent method
+  void updateComponent(const double &new_angle) override {
+    angle = new_angle;
+    std::cout << "Thermometer " << getID() << " updated to angle: " << angle
+              << std::endl;
+  }
 
-    // Override the getComponentCurrently method
-    double getComponentCurrently() const override {
-        return angle;
-    }
+  // Override the getComponentCurrently method
+  double getComponentCurrently() const override { return angle; }
 
 private:
-    double angle; // Angle representing the state of the thermometer
+  double angle; // Angle representing the state of the thermometer
 };
 
-#endif // THERMOMETER_H
+#endif // THERMOMETER_H
diff --git a/include/stateOfLab_s/state_of_lab.h b/include/stateOfLab_s/state_of_lab.h
@@ -1,35 +1,38 @@
 #ifndef STATE_OF_LABS_H
 #define STATE_OF_LABS_H
 
-#include "lab_component.h"
-#include "thermometer.h"
+#include "stateOfLab_s/components/thermometer.h"
+#include "stateOfLab_s/lab_component.h"
 #include <map>
-#include <string>
 #include <memory>
-#include <tuple>
 #include <mutex>
 #include <stdexcept>
+#include <string>
+#include <tuple>
 
 // StateOfLabs class for managing lab components
 class StateOfLabs {
 public:
-    // Constructor
-    explicit StateOfLabs(const std::string& preset);
+  // Constructor
+  explicit StateOfLabs(const std::string &preset);
 
-    // Method to update a component's value (thread-safe)
-    void updateComponent(const std::string& id, double value);
+  // Method to update a component's value (thread-safe)
+  void updateComponent(const std::string &id, double value);
 
-    // Method to get a component's current value (thread-safe)
-    double getComponent(const std::string& id) const;
+  // Method to get a component's current value (thread-safe)
+  double getComponent(const std::string &id) const;
 
-    // Method to get the class name of a component
-    std::string getComponentClassName(const std::string& id) const;
+  // Method to get the class name of a component
+  std::string getComponentClassName(const std::string &id) const;
 
 private:
-    // Map of component ID to a tuple containing additional information
-    std::map<std::string, std::tuple<std::string, std::shared_ptr<LabComponentBase>, std::string>> lab_components;
+  // Map of component ID to a tuple containing additional information
+  std::map<
+      std::string,
+      std::tuple<std::string, std::shared_ptr<LabComponentBase>, std::string>>
+      lab_components;
 
-    mutable std::mutex mtx; // Mutex for thread-safe access
+  mutable std::mutex mtx; // Mutex for thread-safe access
 };
 
 #endif // STATE_OF_LABS_H
diff --git a/src/openCV_s/process_image.cpp b/src/openCV_s/process_image.cpp
@@ -1,4 +1,4 @@
-#include "process_image.h"
+#include "openCV_f/process_image.h"
 #include <iostream>
 
 ImageProcessor::ImageProcessor(const std::string &imagePath)
diff --git a/src/stateOfLab_s/state_of_lab.cpp b/src/stateOfLab_s/state_of_lab.cpp
@@ -1,69 +1,70 @@
-#include "state_of_lab.h"
+#include "stateOfLab_s/state_of_lab.h"
 #include <iostream>
 
-StateOfLabs::StateOfLabs(const std::string& preset) {
-    if (preset.empty()) {
-        throw std::invalid_argument("Error: You need a preset to construct StateOfLabs.");
-    }
+StateOfLabs::StateOfLabs(const std::string &preset) {
+  if (preset.empty()) {
+    throw std::invalid_argument(
+        "Error: You need a preset to construct StateOfLabs.");
+  }
 
-    if (preset == "frankhertz1") {
-        std::cout << "Initializing StateOfLabs with preset: frankhertz1" << std::endl;
+  if (preset == "frankhertz1") {
+    std::cout << "Initializing StateOfLabs with preset: frankhertz1"
+              << std::endl;
 
-        // Add a thermometer as an example component
-        lab_components["thermometer_1"] = std::make_tuple(
-            "Thermometer 1",
-            std::make_shared<Thermometer>("thermometer_1", 0.0),
-            "Thermometer"
-        );
-    } else {
-        throw std::invalid_argument("Error: Unknown preset provided.");
-    }
+    // Add a thermometer as an example component
+    lab_components["thermometer_1"] = std::make_tuple(
+        "Thermometer 1", std::make_shared<Thermometer>("thermometer_1", 0.0),
+        "Thermometer");
+  } else {
+    throw std::invalid_argument("Error: Unknown preset provided.");
+  }
 }
 
-void StateOfLabs::updateComponent(const std::string& id, double value) {
-    std::lock_guard<std::mutex> lock(mtx);
-    auto it = lab_components.find(id);
-    if (it != lab_components.end()) {
-        auto& [name, component, className] = it->second;
-        if (className == "Thermometer") {
-            auto thermometer = std::dynamic_pointer_cast<Thermometer>(component);
-            if (thermometer) {
-                thermometer->updateComponent(value);
-                return;
-            }
-        }
-        // Add other types as needed
-        throw std::runtime_error("Unsupported or mismatched component type: " + className);
-    } else {
-        throw std::runtime_error("Component not found.");
+void StateOfLabs::updateComponent(const std::string &id, double value) {
+  std::lock_guard<std::mutex> lock(mtx);
+  auto it = lab_components.find(id);
+  if (it != lab_components.end()) {
+    auto &[name, component, className] = it->second;
+    if (className == "Thermometer") {
+      auto thermometer = std::dynamic_pointer_cast<Thermometer>(component);
+      if (thermometer) {
+        thermometer->updateComponent(value);
+        return;
+      }
     }
+    // Add other types as needed
+    throw std::runtime_error("Unsupported or mismatched component type: " +
+                             className);
+  } else {
+    throw std::runtime_error("Component not found.");
+  }
 }
 
-double StateOfLabs::getComponent(const std::string& id) const {
-    std::lock_guard<std::mutex> lock(mtx);
-    auto it = lab_components.find(id);
-    if (it != lab_components.end()) {
-        auto& [name, component, className] = it->second;
-        if (className == "Thermometer") {
-            auto thermometer = std::dynamic_pointer_cast<Thermometer>(component);
-            if (thermometer) {
-                return thermometer->getComponentCurrently();
-            }
-        }
-        // Add handling for other types if needed
-        throw std::runtime_error("Unsupported or mismatched component type: " + className);
-    } else {
-        throw std::runtime_error("Component not found.");
+double StateOfLabs::getComponent(const std::string &id) const {
+  std::lock_guard<std::mutex> lock(mtx);
+  auto it = lab_components.find(id);
+  if (it != lab_components.end()) {
+    auto &[name, component, className] = it->second;
+    if (className == "Thermometer") {
+      auto thermometer = std::dynamic_pointer_cast<Thermometer>(component);
+      if (thermometer) {
+        return thermometer->getComponentCurrently();
+      }
     }
+    // Add handling for other types if needed
+    throw std::runtime_error("Unsupported or mismatched component type: " +
+                             className);
+  } else {
+    throw std::runtime_error("Component not found.");
+  }
 }
 
-
-std::string StateOfLabs::getComponentClassName(const std::string& id) const {
-    std::lock_guard<std::mutex> lock(mtx);
-    auto it = lab_components.find(id);
-    if (it != lab_components.end()) {
-        return std::get<2>(it->second);
-    } else {
-        throw std::runtime_error("Component not found.");
-    }
+std::string StateOfLabs::getComponentClassName(const std::string &id) const {
+  std::lock_guard<std::mutex> lock(mtx);
+  auto it = lab_components.find(id);
+  if (it != lab_components.end()) {
+    return std::get<2>(it->second);
+  } else {
+    throw std::runtime_error("Component not found.");
+  }
 }
diff --git a/src/websocket_s/websocket_server.cpp b/src/websocket_s/websocket_server.cpp
@@ -1,16 +1,15 @@
 #include "message.grpc.pb.h"
-#include "process_image.h"
+#include "openCV_f/process_image.h"
+#include "stateOfLab_s/state_of_lab.h"
 #include <boost/asio.hpp>
 #include <boost/beast.hpp>
 #include <cstdlib>
 #include <grpcpp/grpcpp.h>
 #include <iostream>
+#include <nlohmann/json.hpp>
 #include <opencv2/opencv.hpp>
 #include <sstream>
 #include <string>
-#include "message.grpc.pb.h"
-#include "state_of_lab.h"
-#include <nlohmann/json.hpp>
 
 // Namespace declarations
 namespace asio = boost::asio;
@@ -35,22 +34,22 @@ class MessageServiceImpl final : public MessageService::Service {
 
 // Function to run the gRPC server
 void RunGrpcServer() {
-    std::string serverAddress("192.168.2.136:50053");
-    MessageServiceImpl service;
-
-    grpc::ServerBuilder builder;
-    builder.AddListeningPort(serverAddress, grpc::InsecureServerCredentials());
-    builder.RegisterService(&service);
-
-    std::unique_ptr<grpc::Server> server(builder.BuildAndStart());
-    if (server) {
-        std::cout << "gRPC server listening on " << serverAddress << std::endl;
-    } else {
-        std::cerr << "Failed to start gRPC server!" << std::endl;
-        return;
-    }
+  std::string serverAddress("192.168.2.136:50053");
+  MessageServiceImpl service;
+
+  grpc::ServerBuilder builder;
+  builder.AddListeningPort(serverAddress, grpc::InsecureServerCredentials());
+  builder.RegisterService(&service);
+
+  std::unique_ptr<grpc::Server> server(builder.BuildAndStart());
+  if (server) {
+    std::cout << "gRPC server listening on " << serverAddress << std::endl;
+  } else {
+    std::cerr << "Failed to start gRPC server!" << std::endl;
+    return;
+  }
 
-    server->Wait();
+  server->Wait();
 }
 
 // WebSocket session function
@@ -65,16 +64,19 @@ void do_session(tcp::socket socket) {
 
       // Read WebSocket message
       ws.read(buffer);
-      std::string receivedMessage = boost::beast::buffers_to_string(buffer.data());
+      std::string receivedMessage =
+          boost::beast::buffers_to_string(buffer.data());
 
-      std::cout << "WebSocket received message: " << receivedMessage << std::endl;
+      std::cout << "WebSocket received message: " << receivedMessage
+                << std::endl;
 
       // Parse the received JSON message
       json request;
       try {
         request = json::parse(receivedMessage);
       } catch (const json::exception &e) {
-        std::string errorResponse = R"({"type":"error","payload":{"message":"Invalid JSON format"}})";
+        std::string errorResponse =
+            R"({"type":"error","payload":{"message":"Invalid JSON format"}})";
         ws.write(asio::buffer(errorResponse));
         continue;
       }
@@ -91,14 +93,12 @@ void do_session(tcp::socket socket) {
         std::string id = payload.value("id", "");
         double angle = 45.0; // Replace with actual logic to fetch the angle
 
-        response = {
-            {"type", "circular_thermometer_angle"},
-            {"payload", {{"id", id}, {"angle", angle}}}};
+        response = {{"type", "circular_thermometer_angle"},
+                    {"payload", {{"id", id}, {"angle", angle}}}};
       } else {
         // Handle unknown request types
-        response = {
-            {"type", "error"},
-            {"payload", {{"message", "Unknown request type"}}}};
+        response = {{"type", "error"},
+                    {"payload", {{"message", "Unknown request type"}}}};
       }
 
       // Send response back to the client
@@ -117,7 +117,8 @@ int main() {
 
     // Start WebSocket server
     asio::io_context ioc;
-    tcp::acceptor acceptor(ioc, tcp::endpoint(asio::ip::address_v4::any(), 8080));
+    tcp::acceptor acceptor(ioc,
+                           tcp::endpoint(asio::ip::address_v4::any(), 8080));
 
     std::cout << "WebSocket server listening on port 8080..." << std::endl;
 
@@ -128,8 +129,7 @@ int main() {
       // Pass the socket and shared labs instance to the session thread
       std::thread(&do_session, std::move(socket), labs).detach();
     }
-  } catch (const std::exception& e) {
+  } catch (const std::exception &e) {
     std::cout << "Server Error: " << e.what() << std::endl;
   }
 }
-

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#include "process_image.h"`
	`1`	`+#include "openCV_f/process_image.h"`
`2`	`2`	`#include <iostream>`
`3`	`3`
`4`	`4`	`ImageProcessor::ImageProcessor(const std::string &imagePath)`