feat: added comments

Author: prashantkoirala465

Clock.cpp

@@ -1,103 +1,111 @@
-#include "Clock.h"
-#include "Display.h"
-#include "Utility.h"
-#include <iostream>
-#include <ctime>
-#include <thread>
-#include <chrono>
-#include <cstdio>   // for printf
+#include "Clock.h"         // Include the Clock class definition.
+#include "Display.h"       // Include the Display class (used to show digits, colon, AM/PM).
+#include "Utility.h"       // Include helper functions (for time zones, weather, and logging).
+#include <iostream>        // For input and output.
+#include <ctime>           // For working with time.
+#include <thread>          // For sleep functionality.
+#include <chrono>          // For time durations (e.g., seconds).
+#include <cstdio>          // For printf (printing formatted text).
 
 using namespace std;
 
+// Constructor for the Clock class.
+// It initializes user preferences and calculates the time offsets based on location.
 Clock::Clock(const std::string &uName,
              const std::string &loc,
              int format,
              bool dispSec)
-    : userName(uName),
-      location(loc),
-      timeFormat(format),
-      displaySeconds(dispSec)
+    : userName(uName),         // Initialize the user name.
+      location(loc),           // Initialize the location.
+      timeFormat(format),      // Set the time format (12-hour or 24-hour).
+      displaySeconds(dispSec)  // Determine if seconds should be displayed.
 {
-    // 1. Calculate offsets
+    // 1. Calculate offsets for time zone and minutes.
     timeZoneOffset = Utility::getTimeZoneOffset(location);
     minuteOffset   = Utility::getMinutesOffset(location);
 
-    // 2. Log user preferences
+    // 2. Log the user’s preferences to a file.
     Utility::logUserChoice(userName, location, timeFormat, displaySeconds);
 
-    // 3. Fetch weather once and store in weatherInfo
+    // 3. Fetch the weather information for the location (this happens once).
     weatherInfo = Utility::getWeatherInfo(location);
 }
 
+// The start() function contains an infinite loop that updates the clock every second.
 void Clock::start()
 {
-    while (true)
+    while (true)  // Loop forever until the program is stopped.
     {
-        // Clear screen
+        // Clear the console screen before re-drawing the time.
         Display::clearScreen();
 
-        // Get current UTC time
+        // Get the current UTC time.
         time_t now = time(NULL);
-        tm *t = gmtime(&now);
+        tm *t = gmtime(&now);  // Convert to a UTC time structure.
 
-        // Apply offset
+        // Apply the time zone and minute offsets (to convert UTC to local time).
         t->tm_hour += timeZoneOffset;
         t->tm_min  += minuteOffset;
 
-        // Let mktime() fix any out-of-range values
+        // mktime() fixes any values that might be out of normal range (like minutes over 59).
         mktime(t);
 
+        // Extract the hour, minute, and second from the time structure.
         int hour   = t->tm_hour;
         int minute = t->tm_min;
         int second = t->tm_sec;
 
+        // For 12-hour format, determine if it is AM or PM.
         bool isPm = false;
         if (timeFormat == 12)
         {
             isPm = (hour >= 12);
-            hour = hour % 12;
-            if (hour == 0) hour = 12;
+            hour = hour % 12;  // Convert to 12-hour format.
+            if (hour == 0) hour = 12; // In a 12-hour clock, 0 is represented as 12.
         }
 
         // -------------------- DISPLAY TIME --------------------
-        Display::displayDigit(hour / 10, 10, 5);
-        Display::displayDigit(hour % 10, 18, 5);
+        // Display the hour digits:
+        Display::displayDigit(hour / 10, 10, 5);   // Tens place of the hour.
+        Display::displayDigit(hour % 10, 18, 5);   // Ones place of the hour.
 
-        // Colon
+        // Display a colon (:) between hours and minutes.
         Display::displayColon(26, 5);
 
-        Display::displayDigit(minute / 10, 34, 5);
-        Display::displayDigit(minute % 10, 42, 5);
+        // Display the minute digits:
+        Display::displayDigit(minute / 10, 34, 5);  // Tens place of the minute.
+        Display::displayDigit(minute % 10, 42, 5);  // Ones place of the minute.
 
+        // Optionally display seconds if the user chose to.
         if (displaySeconds)
         {
             Display::displayColon(50, 5);
             Display::displayDigit(second / 10, 58, 5);
             Display::displayDigit(second % 10, 66, 5);
         }
 
-        // AM/PM label if 12-hour
+        // If 12-hour format is selected, display the AM/PM indicator.
         if (timeFormat == 12)
         {
             Display::displayAmPm(isPm, 80, 5);
         }
 
         // -------------------- DISPLAY DATE --------------------
-        // Get local date for the chosen location
+        // Get the local date (formatted according to location).
         std::string localDate = Utility::getLocalDate(location);
 
-        // Print the date in, say, row=15, col=10
+        // Move the cursor to a specific position (row 15, column 10) and print the date.
         printf("\033[%d;%dH", 15, 10);
         printf("\033[1;33mToday in %s: %s\033[0m\n", location.c_str(), localDate.c_str());
 
         // -------------------- DISPLAY WEATHER --------------------
-        // Print the stored weather info on row=17, col=10
+        // Move the cursor to row 17, column 10 and display the weather information.
         printf("\033[%d;%dH", 17, 10);
         printf("\033[1;32mWeather: %s\033[0m\n", weatherInfo.c_str());
 
-        fflush(stdout);
+        fflush(stdout);  // Ensure all output is printed immediately.
 
-        // Sleep for 1 second
+        // Pause the program for 1 second before updating the display.
         this_thread::sleep_for(chrono::seconds(1));
     }
 }

Clock.h

@@ -3,27 +3,28 @@
 
 #include <string>
 
+// The Clock class handles user settings, time calculation, and the display loop.
 class Clock
 {
 private:
-    std::string userName;
-    std::string location;
-    int timeFormat;          // 12 or 24
-    bool displaySeconds;
-    int timeZoneOffset;
-    int minuteOffset;
+    std::string userName;    // User’s name.
+    std::string location;    // Location (e.g., London, Tokyo).
+    int timeFormat;          // Time format: 12 or 24 hours.
+    bool displaySeconds;     // Whether to show seconds.
+    int timeZoneOffset;      // Hour offset based on location.
+    int minuteOffset;        // Minute offset (for non-whole hour differences).
 
-    // Store fetched weather info
+    // Weather information fetched from the internet.
     std::string weatherInfo;
 
 public:
-    // Constructor
+    // Constructor: Initializes the clock with the user’s preferences.
     Clock(const std::string &userName,
           const std::string &location,
           int timeFormat,
           bool displaySeconds);
 
-    // Starts the clock loop (displays time continuously)
+    // Starts the continuous clock loop (updating the display every second).
     void start();
 };
 

DigitalClock

@@ -1,9 +1,10 @@
-#include "Display.h"
-#include <iostream>  // for std::cout
-#include <cstdio>    // for printf
+#include "Display.h"  // Include the Display class definition.
+#include <iostream>   // For standard I/O operations.
+#include <cstdio>     // For printf.
 using namespace std;
 
-// Initialize static members:
+// -------------------- DIGIT PATTERNS --------------------
+// Each digit (0-9) is represented by a 7-line pattern of characters.
 const std::string Display::digits[10][HEIGHT] = {
     {
         " ██████╗ ",
@@ -97,6 +98,8 @@ const std::string Display::digits[10][HEIGHT] = {
     }
 };
 
+// -------------------- COLON AND AM/PM PATTERNS --------------------
+// Pattern for the colon ":" used between hour and minute.
 const std::string Display::colon[HEIGHT] = {
     "    ",
     "  ▀ ",
@@ -107,6 +110,7 @@ const std::string Display::colon[HEIGHT] = {
     "     "
 };
 
+// Pattern for "AM" displayed in large text.
 const std::string Display::am[HEIGHT] = {
     " █████╗ ███╗   ███╗",
     "██╔══██╗████╗ ████║",
@@ -117,6 +121,7 @@ const std::string Display::am[HEIGHT] = {
     "                   "
 };
 
+// Pattern for "PM" displayed in large text.
 const std::string Display::pm[HEIGHT] = {
     "██████╗ ███╗   ███╗",
     "██╔══██╗████╗ ████║",
@@ -127,23 +132,27 @@ const std::string Display::pm[HEIGHT] = {
     "                   "
 };
 
+// clearScreen() clears the console using ANSI escape codes.
 void Display::clearScreen()
 {
-    // ANSI escape codes to clear screen and move cursor to (0,0)
-    printf("\033[2J");
-    printf("\033[H");
+    printf("\033[2J"); // Clears the screen.
+    printf("\033[H");  // Moves the cursor to the top-left corner.
 }
 
+// displayDigit() prints a single digit (using its ASCII art) at the given x and y coordinates.
 void Display::displayDigit(int digit, int x, int y)
 {
-    // Print each line of the digit at the specified (x, y)
+    // Loop through each line of the digit pattern.
     for (int i = 0; i < HEIGHT; i++)
     {
+        // Move the cursor to the correct position.
         printf("\033[%d;%dH", y + i, x);
+        // Print the line with a set foreground color and then reset the color.
         printf("%s%s%s", FG_COLOR, digits[digit][i].c_str(), RESET_COLOR);
     }
 }
 
+// displayColon() prints the colon pattern at the specified coordinates.
 void Display::displayColon(int x, int y)
 {
     for (int i = 0; i < HEIGHT; i++)
@@ -153,9 +162,10 @@ void Display::displayColon(int x, int y)
     }
 }
 
+// displayAmPm() prints either "AM" or "PM" at the given coordinates based on the isPm flag.
 void Display::displayAmPm(bool isPm, int x, int y)
 {
-    const std::string* pattern = isPm ? pm : am;
+    const std::string* pattern = isPm ? pm : am; // Choose PM if true, else AM.
     for (int i = 0; i < HEIGHT; i++)
     {
         printf("\033[%d;%dH", y + i, x);

Display.cpp

@@ -3,34 +3,35 @@
 
 #include <string>
 
+// The Display class handles drawing the clock’s digits and symbols on the console.
 class Display
 {
 private:
-    static const int HEIGHT = 7;
+    static const int HEIGHT = 7;  // Each digit or symbol is 7 lines tall.
 
-    // Console color escape sequences
-    static constexpr const char* FG_COLOR = "\033[1;32m";   // Bold Green
-    static constexpr const char* RESET_COLOR = "\033[0m";   // Reset
+    // ANSI escape codes for colored output.
+    static constexpr const char* FG_COLOR = "\033[1;32m";   // Bold Green text.
+    static constexpr const char* RESET_COLOR = "\033[0m";     // Reset to default color.
 
-    // Digit patterns
+    // ASCII art patterns for digits 0-9.
     static const std::string digits[10][HEIGHT];
-    // Colon pattern
+    // Pattern for the colon.
     static const std::string colon[HEIGHT];
-    // AM/PM patterns
+    // Patterns for AM and PM.
     static const std::string am[HEIGHT];
     static const std::string pm[HEIGHT];
 
 public:
-    // Clears the screen
+    // Clears the console screen.
     static void clearScreen();
 
-    // Displays a single digit at x, y
+    // Displays a single digit at the (x, y) position.
     static void displayDigit(int digit, int x, int y);
 
-    // Displays colon ':' at x, y
+    // Displays a colon at the (x, y) position.
     static void displayColon(int x, int y);
 
-    // Displays either AM or PM at x, y
+    // Displays either "AM" or "PM" at the (x, y) position.
     static void displayAmPm(bool isPm, int x, int y);
 };
 

Display.h

@@ -1,9 +1,11 @@
-#include "Input.h"
-#include "Utility.h"
-#include <iostream>
-#include <limits>
+#include "Input.h"      // Include the Input class declaration.
+#include "Utility.h"    // Include Utility functions (for validating location).
+#include <iostream>     // For input/output operations.
+#include <limits>       // For clearing the input buffer.
 using namespace std;
 
+// getUserInput() prompts the user and reads an integer.
+// It ensures that the user only enters one of the allowed values (minVal or maxVal).
 int Input::getUserInput(const std::string &prompt, int minVal, int maxVal)
 {
     int input;
@@ -12,24 +14,27 @@ int Input::getUserInput(const std::string &prompt, int minVal, int maxVal)
         cout << prompt;
         cin >> input;
 
-        // Validate input
+        // Validate that input is correct (not a failure) and matches one of the allowed values.
         if (!cin.fail() && (input == minVal || input == maxVal))
         {
-            // Clear the buffer
+            // Clear any extra characters from the input.
             cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
             break;
         }
         else
         {
+            // Tell the user the input was invalid and prompt again.
             cout << "Invalid input. You can only select " << minVal << " or " << maxVal << "." << endl;
-            // Clear error flags and discard invalid input
+            // Clear the error state and discard the bad input.
             cin.clear();
             cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
         }
     }
     return input;
 }
 
+// getLocationInput() prompts the user to enter their location.
+// It uses Utility::getTimeZoneOffset to check if the location is valid.
 std::string Input::getLocationInput()
 {
     while (true)
@@ -38,7 +43,7 @@ std::string Input::getLocationInput()
         string location;
         cin >> location;
 
-        // Check if location is valid
+        // If the location returns a valid time zone offset, accept it.
         if (Utility::getTimeZoneOffset(location) != -9999)
         {
             return location;

Input.cpp

@@ -3,13 +3,15 @@
 
 #include <string>
 
+// The Input class provides functions to obtain and validate input from the user.
 class Input
 {
 public:
-    // Prompts the user and reads an integer that must be either minVal or maxVal
+    // Prompts the user with a message and reads an integer.
+    // The valid input must be either minVal or maxVal.
     static int getUserInput(const std::string &prompt, int minVal, int maxVal);
 
-    // Prompts for a location and validates it
+    // Prompts the user to enter their location and validates it.
     static std::string getLocationInput();
 };