lib/watchDog.cpp

@@ -0,0 +1,129 @@
+/*
+ *I don't know how threads work, so I might come back to see how they work.
+ *Right now you have to manually call the checkfile function to see if any changes have occured
+ */
+
+#include "watchDog.h"
+
+namespace fs = std::filesystem; //makes it easier to read
+void WatchDog::start()
+{
+    //checks if file exist
+    if(!fs::exists(path))
+    {
+        //returns and sets parameters to false if file doesnt exist
+        watching = false;
+        hasInitialTime = false;
+        std::cout << "WatchDog: File does not exists: " << path << std::endl;
+        return;
+    }
+    //grabs intial write time
+    lastWriteTime = fs::last_write_time(path);
+    watching = true;
+    hasInitialTime = true;
+    std::cout << "WatchDog: Started" << std::endl;
+}
+void WatchDog::stop(){
+    watching = false;
+}
+bool WatchDog::checkFile(){
+    //If not watching returns false
+    if (!watching) return false;
+
+    //Checking if file was deleted
+    if(!fs::exists(path))
+    {
+        if (hasInitialTime) {
+            std::cout << "WatchDog: File was delete: " << path << std::endl;
+            hasInitialTime = false;
+            return true;
+        }
+        return false;
+    }
+    
+    //Built in function with file system to check last write tim
+    fs::file_time_type currentWriteTime = fs::last_write_time(path);
+
+    //File was just created
+    if(!hasInitialTime)
+    {
+        lastWriteTime = currentWriteTime;
+        hasInitialTime = true;
+        std::cout << "WatchDog: File created: " << path << std::endl;
+        return true;
+    }
+
+    //File modified
+    if (currentWriteTime != lastWriteTime)
+    {
+        lastWriteTime = currentWriteTime;
+        std::cout << "WatchDog: File modifed at " 
+                  << timePointToString(lastWriteTime) << std::endl;
+        return true;      
+    }
+
+    //No change
+    return false;
+}
+
+std::string WatchDog::timePointToString(const fs::file_time_type& timePoint){
+    /*
+     * https://en.cppreference.com/w/cpp/chrono.html
+     * std::chrono -> name space, system_clock -> c++ clock(computers clock),
+     * ime_point -> exact instant on system clock, used to cast
+     * Comments: I had to use a lot of sources and googling to get this work
+     *           We can get rid of this or document my troubles, because tbh this time stuff confuses me
+     *
+     * std::chrono::system_clock::time_point systemTimePoint =
+     * std::chrono::clock_cast<std::chrono::system_clock>(timePoint);
+     * This solutions doesn't work as it only works with C++ 20 only :(
+     */
+
+    //Convert std::filesystem::file_time_type (timePoint) to std::chrono::system_clock::time_point 
+
+    /* 
+    * Step 1: timePoint
+    *   - This is the last write time of the file, returned by std::filesystem.
+    *   - Its clock is platform-dependent (filesystem clock).
+    *
+    * Step 2: fs::file_time_type::clock::now()
+    *   - Current time according to the filesystem clock.
+    *
+    * Step 3: std::chrono::system_clock::now()
+    *   - Current time according to the system clock (standard C++ clock).
+    *
+    * Conversion formula:
+    *   timePoint - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
+    *
+    * Explanation:
+    *   a) timePoint - fs::file_time_type::clock::now()
+    *      - Calculates the duration between the file's last write time and "now"
+    *        according to the filesystem clock.
+    *   b) + std::chrono::system_clock::now()
+    *      - Shifts that duration to align with the system clock timeline.
+    *   c) std::chrono::time_point_cast<std::chrono::system_clock::duration>(...)
+    *      - Ensures the resulting time_point uses the correct duration type
+    *        for std::chrono::system_clock.
+    *
+    * Result:
+    *   - systemTime is a std::chrono::system_clock::time_point representing
+    *     the same instant as timePoint, but compatible with system_clock.
+    */
+    std::chrono::system_clock::time_point systemTimePoint =
+        std::chrono::time_point_cast<std::chrono::system_clock::duration>(
+            timePoint - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
+        );
+    
+    //converts to seconds
+    std::time_t timeInSeconds = std::chrono::system_clock::to_time_t(systemTimePoint);
+
+    //Converts to local time, built in function
+    std::tm localTime = *std::localtime(&timeInSeconds);
+
+    // Format the time into a string using strftime
+    //https://en.cppreference.com/w/cpp/chrono/c/strftime.html
+    char buffer[20]; 
+    std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &localTime);
+
+    return std::string(buffer);
+}

lib/watchDog.h

@@ -0,0 +1,94 @@
+#ifndef WATCHDOG_H
+#define WATCHDOG_H
+
+#include <iostream>
+#include <string>
+/*
+ *https://en.cppreference.com/w/cpp/filesystem.html
+ *allow access to files platform independent
+ */
+#include <filesystem> 
+/*
+ *https://en.cppreference.com/w/cpp/chrono.html
+ *makes timestamps easier
+ *how to do lots of research to get this to work
+ */
+#include <chrono> 
+/**
+ * @brief watchdog class.
+ *
+ * Checks if a file is modified and displays date modified
+ *
+ * @author Preston Shultz (shultzp1@my.erau.edu)
+ */
+#include <ctime> //Convert time_t to std::tm for local time
+#include <iomanip> //Formats std::tim into "YYYY-MM-DD HH-MM-SS"
+
+
+class WatchDog{
+    public:
+        WatchDog(const std::string& path) : 
+        path(path), watching(false), hasInitialTime(false) {}
+
+        /**
+         * @brief watchdog class.
+         *
+         * Starts the watchdog to check of a file is modified
+         *
+         * @author Preston Shultz (shultzp1@my.erau.edu)
+         */
+        void start();
+        /**
+         * @brief watchdog class.
+         *
+         * Stops the watchdog
+         *
+         * @author Preston Shultz (shultzp1@my.erau.edu)
+         */
+        void stop(); //Disable
+
+        /**
+         * @brief watchdog class.
+         *
+         * Checks if a file has been modified
+         *
+         * @author Preston Shultz (shultzp1@my.erau.edu)
+         */
+        bool checkFile(); 
+
+        /**
+         * @brief watchdog class.
+         *
+         * Returns files last modified date
+         *
+         * @author Preston Shultz (shultzp1@my.erau.edu)
+         */
+        std::filesystem::file_time_type getLastWriteTime() 
+        const {return lastWriteTime;}
+
+        /**
+         * @brief watchdog class.
+         *
+         * Converts time point into a string
+         *
+         * @author Preston Shultz (shultzp1@my.erau.edu)
+         */
+        static std::string timePointToString(const std::filesystem::file_time_type& timePoint);
+
+        /**
+         * @brief watchdog class.
+         *
+         * Returns if the watchDog is on
+         *
+         * @author Preston Shultz (shultzp1@my.erau.edu)
+         */
+        bool isWatching() const{return watching;}
+
+    private:
+        std::string path; //file path
+        bool watching; //Is watchdog on?
+        std::filesystem::file_time_type lastWriteTime; 
+        bool hasInitialTime; //checks if initial time is given
+};
+
+#endif