Fixed coding style issues with watch dog, and began implementing CLI features

lib/commandLineParser.cpp

@@ -0,0 +1,28 @@
+#include "commandLineParser.h"
+#include <iostream>
+
+CLI::CLI(int argc, char** argv){
+    if (argc > 0){
+        programName = argv[0];
+    }
+
+    for (int i = 1; i < argc; i++){
+        args.push_back(argv[i]);
+    }
+}
+
+void CLI::RunCommands(){
+    for (int i = 0; i < args.size(); i++){
+        
+    }    
+}
+
+void CLI::PrintHelp() const{
+    std::cout << "Usage:\n"
+              << " " << programName << " <input_file>\n"
+              << "Flags:\n"
+              << " --o, --output <outputFile>, optional output filename\n"
+              << " --w, --watch, enables watchdog\n"
+              << " --s, --stop, stops watchdog\n";
+}
+

lib/commandLineParser.h

@@ -0,0 +1,69 @@
+/** 
+ * @file commandLineParser.h
+ * @brief Parses command line
+ * @author Preston Shultz
+ * Sources: 
+ * 
+ */
+
+#ifndef COMMAND_LINE_PARSER_H
+#define COMMAND_LINE_PARSER_H
+
+#include <string>
+#include <vector>
+
+/**
+ * @brief CommandLine Helper class
+ *
+ * Parse input arguments, sets input and output files
+ * Lets user use commands with program
+ * 
+ * @author Preston Shultz (shultzp1@my.erau.edu)
+ */
+class CLI{
+public:
+    /**
+     * @brief Takes in argc and argv and converts it to vector
+     *
+     * CLI constructor
+     *
+     * @author Preston Shultz (shultzp1@my.erau.edu)
+     */
+    CLI(int argc, char **argv);
+
+    /**
+     * @brief Runs Commands
+     *
+     * @author Preston Shultz (shultzp1@my.erau.edu)
+     */
+    void RunCommands();
+
+    /**
+     * @brief Prints a list of commands that can be used
+     *
+     * @author Preston Shultz (shultzp1@my.erau.edu)
+     */
+    void PrintHelp() const;
+
+    /**
+     * @brief Returns input file
+     *
+     * @author Preston Shultz (shultzp1@my.erau.edu)
+     */
+    std::string GetInputFile() const {return inputFile;}
+
+    /**
+     * @brief Returns output file
+     *
+     * @author Preston Shultz (shultzp1@my.erau.edu)
+     */
+    std::string GetOutputFile() const {return outputFile;}
+
+private:
+    std::string programName;
+    std::vector<std::string> args;
+    std::string inputFile;
+    std::string outputFile;
+};
+
+#endif

lib/watchDog.cpp

@@ -1,64 +1,59 @@
-/*
+#include "watchdog.h"
- *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()
+
+void Watchdog::Start()
 {
-    //checks if file exist
+    //Checks if file exist
     if(!fs::exists(path))
     {
-        //returns and sets parameters to false if file doesnt exist
+        //Returns and sets parameters to false if file doesnt exist
         watching = false;
-        hasInitialTime = false;
+        has_initial_time = false;
         std::cout << "WatchDog: File does not exists: " << path << std::endl;
         return;
     }
-    //grabs intial write time
+    //Grabs intial write time
-    lastWriteTime = fs::last_write_time(path);
+    last_write_time = fs::last_write_time(path);
+    //Sets watchdog
     watching = true;
-    hasInitialTime = true;
+    has_initial_time = true;
     std::cout << "WatchDog: Started" << std::endl;
 }
-void WatchDog::stop(){
+
-    watching = false;
+bool Watchdog::CheckFile(){
-}
-bool WatchDog::checkFile(){
     //If not watching returns false
     if (!watching) return false;
 
     //Checking if file was deleted
     if(!fs::exists(path))
     {
-        if (hasInitialTime) {
+        if (has_initial_time) {
             std::cout << "WatchDog: File was delete: " << path << std::endl;
-            hasInitialTime = false;
+            has_initial_time = false;
             return true;
         }
         return false;
     }
     
-    //Built in function with file system to check last write tim
+    //Built in function with file system to check last write time
     fs::file_time_type currentWriteTime = fs::last_write_time(path);
 
     //File was just created
-    if(!hasInitialTime)
+    if(!has_initial_time)
     {
-        lastWriteTime = currentWriteTime;
+        last_write_time = currentWriteTime;
-        hasInitialTime = true;
+        has_initial_time = true;
         std::cout << "WatchDog: File created: " << path << std::endl;
         return true;
     }
 
     //File modified
-    if (currentWriteTime != lastWriteTime)
+    if (currentWriteTime != last_write_time)
     {
-        lastWriteTime = currentWriteTime;
+        last_write_time = currentWriteTime;
         std::cout << "WatchDog: File modifed at " 
-                  << timePointToString(lastWriteTime) << std::endl;
+                  << TimePointToString(last_write_time) << std::endl;
         return true;      
     }
 
@@ -66,62 +61,47 @@ bool WatchDog::checkFile(){
     return false;
 }
 
-std::string WatchDog::timePointToString(const fs::file_time_type& timePoint){
+std::string Watchdog::TimePointToString(const fs::file_time_type& timePoint){
-    /*
+    /** 
-     * https://en.cppreference.com/w/cpp/chrono.html
+     * Step 1: timePoint
-     * std::chrono -> name space, system_clock -> c++ clock(computers clock),
+     *   - This is the last write time of the file, returned by std::filesystem.
-     * ime_point -> exact instant on system clock, used to cast
+     *   - Its clock is platform-dependent (filesystem clock).
-     * 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 =
+     * Step 2: fs::file_time_type::clock::now()
-     * std::chrono::clock_cast<std::chrono::system_clock>(timePoint);
+     *   - Current time according to the filesystem clock.
-     * This solutions doesn't work as it only works with C++ 20 only :(
+     *
+     * 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.
      */
-
-    //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
+    //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);
 

lib/watchDog.h

@@ -1,19 +1,25 @@
+/** 
+ * @file watchdog.h
+ * @brief file watcher
+ * @author Preston Shultz
+ * Sources: 
+ *  https://en.cppreference.com/w/cpp/filesystem.html
+ *  https://en.cppreference.com/w/cpp/chrono.html
+ *  Format the time into a string using strftime
+ *  https://en.cppreference.com/w/cpp/chrono/c/strftime.html 
+ */
+
 #ifndef WATCHDOG_H
 #define WATCHDOG_H
 
 #include <iostream>
-#include <string>
+#include <string> 
-/*
+#include <filesystem> //allow access to files platform independent
- *https://en.cppreference.com/w/cpp/filesystem.html
+#include <chrono>  //makes timestamps easier
- *allow access to files platform independent
+#include <ctime> //Convert time_t to std::tm for local time
- */
+#include <iomanip> //Formats std::tim into "YYYY-MM-DD HH-MM-SS"
-#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.
  *
@@ -21,74 +27,70 @@
  *
  * @author Preston Shultz (shultzp1@my.erau.edu)
  */
-#include <ctime> //Convert time_t to std::tm for local time
+class Watchdog{
-#include <iomanip> //Formats std::tim into "YYYY-MM-DD HH-MM-SS"
+public:
+    Watchdog(const std::string& path) : 
+    path(path), watching(false), has_initial_time(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() {watching = false;} //Disable
 
-class WatchDog{
+    /**
-    public:
+     * @brief watchdog class.
-        WatchDog(const std::string& path) : 
+     *
-        path(path), watching(false), hasInitialTime(false) {}
+     * Checks if a file has been modified
+     *
+     * @author Preston Shultz (shultzp1@my.erau.edu)
+     */
+    bool CheckFile(); 
 
-        /**
+    /**
-         * @brief watchdog class.
+     * @brief watchdog class.
-         *
+     *
-         * Starts the watchdog to check of a file is modified
+     * Returns files last modified date
-         *
+     *
-         * @author Preston Shultz (shultzp1@my.erau.edu)
+     * @author Preston Shultz (shultzp1@my.erau.edu)
-         */
+     */
-        void start();
+    std::filesystem::file_time_type GetLastWriteTime() 
-        /**
+    const {return last_write_time;}
-         * @brief watchdog class.
-         *
-         * Stops the watchdog
-         *
-         * @author Preston Shultz (shultzp1@my.erau.edu)
-         */
-        void stop(); //Disable
 
-        /**
+    /**
-         * @brief watchdog class.
+     * @brief watchdog class.
-         *
+     *
-         * Checks if a file has been modified
+     * Converts time point into a string
-         *
+     *
-         * @author Preston Shultz (shultzp1@my.erau.edu)
+     * @author Preston Shultz (shultzp1@my.erau.edu)
-         */
+     */
-        bool checkFile(); 
+    static std::string TimePointToString(const std::filesystem::file_time_type& timePoint);
 
-        /**
+    /**
-         * @brief watchdog class.
+     * @brief watchdog class.
-         *
+     *
-         * Returns files last modified date
+     * Returns if the watchDog is on
-         *
+     *
-         * @author Preston Shultz (shultzp1@my.erau.edu)
+     * @author Preston Shultz (shultzp1@my.erau.edu)
-         */
+     */
-        std::filesystem::file_time_type getLastWriteTime() 
+    bool IsWatching() const{return watching;}
-        const {return lastWriteTime;}
 
-        /**
+private:
-         * @brief watchdog class.
+    std::string path; //file path
-         *
+    bool watching; //Is watchdog on?
-         * Converts time point into a string
+    std::filesystem::file_time_type last_write_time; 
-         *
+    bool has_initial_time; //checks if initial time is given
-         * @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

src/main.cpp

@@ -39,18 +39,18 @@ void test_nodes() {
  *Preston: Test to see if watchdog works :)
  */
 void test_watchdog() {
-  WatchDog wd("test/input.md");
+  Watchdog wd("test/input.md");
-  wd.start();
+  wd.Start();
 
   std::cout << "Initial check (should do nothing if file unchanged):\n";
-  wd.checkFile();
+  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();
+  wd.CheckFile();
 
   std::cout << "Done testing.\n";
 }
@@ -78,4 +78,4 @@ void test_input(int argc, char **argv) {
   std::cout << std::endl;
 }
 
-int main(int argc, char **argv) { test_nodes(); }
+int main(int argc, char **argv) { test_watchdog(); }

test/input.md

@@ -1,6 +1,6 @@
 
 
-# Hello world in a h1 tag
+# Hello world in an h1 tag
 
 
 ## This is a h2 tag