130 lines
4.6 KiB
C++
130 lines
4.6 KiB
C++
/*
|
|
*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);
|
|
}
|