Improved

Author: sajith

plant-care-better/main/src/main.cpp

@@ -3,9 +3,36 @@
 //
 
 #include <iostream>
+#include <mutex>
+#include <thread>
 
-int main()
+#include "sensors/MoistureSensor.h"
+#include "sensors/SunlightSensor.h"
+#include "caretaker/AloeCaretaker.h"
+#include "caretaker/CactusCaretaker.h"
+
+void run()
 {
+    std::mutex sensorMtx;
+    auto sunlightSensor = sensors::SunlightSensor(std::chrono::seconds(2), sensorMtx);
+    auto moistureSensor = sensors::MoistureSensor(std::chrono::seconds(2), sensorMtx);
+
+    caretaker::AloeCaretaker aloeCaretaker;
+    moistureSensor.subscribe(aloeCaretaker);
+    sunlightSensor.subscribe(aloeCaretaker);
+
+    caretaker::CactusCaretaker cactusCaretaker;
+    moistureSensor.subscribe(cactusCaretaker);
 
+    std::thread sunlightSensorThread(sunlightSensor);
+    std::thread moistureSensorThread(moistureSensor);
+
+    sunlightSensorThread.join();
+    moistureSensorThread.join();
+}
+
+int main()
+{
+    run();
     return 0;
 }

plant-care-better/sensors/include/sensors/MoistureSensor.h

@@ -16,17 +16,17 @@ namespace sensors
     class MoistureSensor
     {
         const std::chrono::seconds sleepTime;
-        std::mutex mtx;
+        std::mutex &mtx;
         std::set<interfaces::WaterDevice *> devices;
 
         const int min = 0;
         const int max = 10;
         const int threshold = 3;
 
     public:
-        MoistureSensor(const std::chrono::seconds, std::mutex);
+        MoistureSensor(const std::chrono::seconds, std::mutex&);
         void subscribe(interfaces::WaterDevice &);
-        void operator()();
+        [[noreturn]] void operator()();
 
     private:
         bool isAirTooDry();

plant-care-better/sensors/src/MoistureSensor.cpp

@@ -2,3 +2,65 @@
 // Created by sajith on 4/20/21.
 //
 
+#include <iostream>
+#include <random>
+#include <thread>
+
+#include "sensors/MoistureSensor.h"
+
+
+namespace sensors
+{
+    MoistureSensor::MoistureSensor(const std::chrono::seconds sleepTime, std::mutex &mtx) : sleepTime{sleepTime},
+
+                                                                                            mtx{mtx} {}
+
+    void MoistureSensor::subscribe(interfaces::WaterDevice &device)
+    {
+        devices.insert(&device);
+    }
+
+    [[noreturn]]void MoistureSensor::operator()()
+    {
+        for (;;)
+        {
+            std::unique_lock<std::mutex> lock(mtx);
+
+            if (isAirTooDry())
+            {
+                for (auto p: devices)
+                {
+                    p->sprinkleWater();
+                }
+            }
+
+            if (isSoilTooDry())
+            {
+                for (auto p: devices)
+                {
+                    p->pourWater();
+                }
+            }
+
+            lock.unlock();
+            std::this_thread::sleep_for(sleepTime);
+        }
+    }
+
+    bool MoistureSensor::isAirTooDry() { return getAirMoisture() < threshold; }
+
+    bool MoistureSensor::isSoilTooDry() { return getSoilMoisture() < threshold; }
+
+    int MoistureSensor::getAirMoisture()
+    {
+        static std::mt19937 generator;
+        return std::uniform_int_distribution<int>(min, max)(generator);
+    }
+
+    int MoistureSensor::getSoilMoisture()
+    {
+        static std::mt19937 generator;
+        return std::uniform_int_distribution<int>(min, max)(generator);
+    }
+}
+