diff --git a/.gitignore b/.gitignore index 267697e..3943bed 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,4 @@ /build /build/* parser +/.vscode diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 1eaa062..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "C_Cpp.errorSquiggles": "disabled" -} \ No newline at end of file diff --git a/MDtoHTMLUML.pdf b/MDtoHTMLUML.pdf new file mode 100644 index 0000000..4fe9f11 Binary files /dev/null and b/MDtoHTMLUML.pdf differ diff --git a/lib/watchDog.cpp b/lib/watchDog.cpp new file mode 100644 index 0000000..e9bec9e --- /dev/null +++ b/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(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(...) + * - 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( + 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); +} \ No newline at end of file diff --git a/lib/watchDog.h b/lib/watchDog.h new file mode 100644 index 0000000..148d087 --- /dev/null +++ b/lib/watchDog.h @@ -0,0 +1,94 @@ +#ifndef WATCHDOG_H +#define WATCHDOG_H + +#include +#include +/* + *https://en.cppreference.com/w/cpp/filesystem.html + *allow access to files platform independent + */ +#include +/* + *https://en.cppreference.com/w/cpp/chrono.html + *makes timestamps easier + *how to do lots of research to get this to work + */ +#include +/** + * @brief watchdog class. + * + * Checks if a file is modified and displays date modified + * + * @author Preston Shultz (shultzp1@my.erau.edu) + */ +#include //Convert time_t to std::tm for local time +#include //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 \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index f4f54ae..bd327c0 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -53,3 +53,28 @@ int main(int argc, char **argv) { return 0; } + +/** + *Preston: Test to see if watchdog works :) + */ + +// #include "../lib/watchDog.h" +// #include +// +// int main() { +// WatchDog wd("test/input.md"); +// wd.start(); +// +// std::cout << "Initial check (should do nothing if file unchanged):\n"; +// wd.checkFile(); +// +// std::cout << "Now, modify or create the file 'example.txt' manually and " +// "press Enter:\n"; +// std::cin.get(); // Wait for user to press Enter +// +// // Check again after manual change +// wd.checkFile(); +// +// std::cout << "Done testing.\n"; +// return 0; +// } diff --git a/test/input.md b/test/input.md index 54ed126..b37a30c 100644 --- a/test/input.md +++ b/test/input.md @@ -1,6 +1,6 @@ -# Hello world in an h1 tag +# Hello world in a h1 tag ## This is a h2 tag