feat: changes added comments and fixed time zone offsets

Author: prashantkoirala465

Clock.cpp

@@ -1,111 +1,118 @@
-#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;
-
+#include "Clock.h"         // Include the Clock class declaration so we know what functions and variables belong to Clock.
+#include "Display.h"       // Include the Display class for drawing digits and symbols on the screen.
+#include "Utility.h"       // Include Utility functions that help with time zones, weather data, and logging.
+#include <iostream>        // Include the iostream library for standard input/output operations.
+#include <ctime>           // Include ctime for working with time functions (e.g., getting the current time).
+#include <thread>          // Include thread to allow us to pause the program (sleep functionality).
+#include <chrono>          // Include chrono to work with time durations, such as seconds.
+#include <cstdio>          // Include cstdio for using printf, which prints formatted text.
+
+using namespace std;       // Allows us to use names from the std (standard) namespace without the std:: prefix.
 // 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),         // 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.
+    : userName(uName),         // Initialize the userName member with the passed value uName.
+      location(loc),           // Initialize the location member with loc.
+      timeFormat(format),      // Set the timeFormat (either 12 or 24) using format.
+      displaySeconds(dispSec)  // Determine whether to display seconds (true/false) from dispSec.
 {
     // 1. Calculate offsets for time zone and minutes.
+    // The timeZoneOffset tells us how many hours to add to UTC to get the local time.
     timeZoneOffset = Utility::getTimeZoneOffset(location);
+    // The minuteOffset handles cases where the offset is not a whole hour (like Kathmandu, which is +45 minutes).
     minuteOffset   = Utility::getMinutesOffset(location);
 
     // 2. Log the user’s preferences to a file.
+    // This function writes the user's choices (name, location, format, and seconds option) into a log file.
     Utility::logUserChoice(userName, location, timeFormat, displaySeconds);
 
-    // 3. Fetch the weather information for the location (this happens once).
+    // 3. Fetch the weather information for the location.
+    // This gets the current weather details (like temperature and description) and stores it in weatherInfo.
     weatherInfo = Utility::getWeatherInfo(location);
 }
-
 // The start() function contains an infinite loop that updates the clock every second.
 void Clock::start()
 {
-    while (true)  // Loop forever until the program is stopped.
+    while (true)  // This loop runs forever until you manually stop the program.
     {
         // Clear the console screen before re-drawing the time.
+        // This avoids printing new output on top of the old, creating a "refresh" effect.
         Display::clearScreen();
 
-        // Get the current UTC time.
-        time_t now = time(NULL);
-        tm *t = gmtime(&now);  // Convert to a UTC time structure.
+        // Get the current time in UTC (Coordinated Universal Time).
+        time_t now = time(NULL);  // time(NULL) returns the current time as a time_t type.
+        tm *t = gmtime(&now);     // Convert the time_t value into a tm structure (broken-down time in UTC).
 
         // Apply the time zone and minute offsets (to convert UTC to local time).
-        t->tm_hour += timeZoneOffset;
-        t->tm_min  += minuteOffset;
+        t->tm_hour += timeZoneOffset;  // Adjust the hours by adding the location's time zone offset.
+        t->tm_min  += minuteOffset;    // Adjust the minutes by adding any extra minutes (if applicable).
 
-        // mktime() fixes any values that might be out of normal range (like minutes over 59).
+        // mktime() fixes any out-of-range values.
+        // For example, if t->tm_min exceeds 59, mktime() will increment the hour accordingly.
         mktime(t);
 
-        // Extract the hour, minute, and second from the time structure.
+        // Extract the current hour, minute, and second from the tm 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.
+        // For 12-hour format, we need to adjust the hour and determine AM or PM.
         bool isPm = false;
         if (timeFormat == 12)
         {
-            isPm = (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.
+            isPm = (hour >= 12);      // If the hour is 12 or more, it's PM.
+            hour = hour % 12;         // Convert hour from 24-hour to 12-hour format.
+            if (hour == 0) hour = 12;   // In 12-hour format, 0 is represented as 12.
         }
 
         // -------------------- DISPLAY TIME --------------------
+        // The following lines call Display functions to draw each part of the clock.
+
         // 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.
+        Display::displayDigit(hour / 10, 10, 5);   // Display the tens digit of the hour at column 10, row 5.
+        Display::displayDigit(hour % 10, 18, 5);   // Display the ones digit of the hour at column 18, row 5.
 
         // Display a colon (:) between hours and minutes.
-        Display::displayColon(26, 5);
+        Display::displayColon(26, 5);              // Draw the colon at column 26, row 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.
+        Display::displayDigit(minute / 10, 34, 5);  // Draw the tens digit of the minute at column 34, row 5.
+        Display::displayDigit(minute % 10, 42, 5);  // Draw the ones digit of the minute at column 42, row 5.
 
-        // Optionally display seconds if the user chose to.
+        // Optionally display seconds if the user chose to show them.
         if (displaySeconds)
         {
-            Display::displayColon(50, 5);
-            Display::displayDigit(second / 10, 58, 5);
-            Display::displayDigit(second % 10, 66, 5);
+            Display::displayColon(50, 5);          // Draw another colon for seconds at column 50, row 5.
+            Display::displayDigit(second / 10, 58, 5); // Draw the tens digit of the seconds at column 58, row 5.
+            Display::displayDigit(second % 10, 66, 5); // Draw the ones digit of the seconds at column 66, row 5.
         }
 
-        // If 12-hour format is selected, display the AM/PM indicator.
+        // If the clock is in 12-hour format, display the AM/PM indicator.
         if (timeFormat == 12)
         {
-            Display::displayAmPm(isPm, 80, 5);
+            Display::displayAmPm(isPm, 80, 5);       // Draw either "AM" or "PM" at column 80, row 5.
         }
 
         // -------------------- DISPLAY DATE --------------------
-        // Get the local date (formatted according to location).
+        // Get the local date formatted based on the location.
         std::string localDate = Utility::getLocalDate(location);
 
-        // Move the cursor to a specific position (row 15, column 10) and print the date.
+        // Use ANSI escape sequences to move the cursor to row 15, column 10,
+        // then print the date in a specific color (here, yellow is used).
         printf("\033[%d;%dH", 15, 10);
         printf("\033[1;33mToday in %s: %s\033[0m\n", location.c_str(), localDate.c_str());
 
         // -------------------- DISPLAY WEATHER --------------------
-        // Move the cursor to row 17, column 10 and display the weather information.
+        // Move the cursor to row 17, column 10 and print the weather info.
         printf("\033[%d;%dH", 17, 10);
         printf("\033[1;32mWeather: %s\033[0m\n", weatherInfo.c_str());
 
-        fflush(stdout);  // Ensure all output is printed immediately.
+        fflush(stdout);  // Flush the output buffer to ensure everything is printed immediately.
 
-        // Pause the program for 1 second before updating the display.
+        // Pause for 1 second before the loop runs again.
         this_thread::sleep_for(chrono::seconds(1));
     }
 }

Clock.h

@@ -1,31 +1,31 @@
-#ifndef CLOCK_H
+#ifndef CLOCK_H              // If CLOCK_H is not defined, then define it.
 #define CLOCK_H
 
-#include <string>
+#include <string>           // Include string to use std::string.
 
-// The Clock class handles user settings, time calculation, and the display loop.
+// The Clock class handles user settings, time calculations, and updating the display continuously.
 class Clock
 {
 private:
-    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).
+    std::string userName;    // Stores the user’s name.
+    std::string location;    // Stores the location (e.g., London, Tokyo) for time zone and weather purposes.
+    int timeFormat;          // Stores the time format: 12 for 12-hour or 24 for 24-hour format.
+    bool displaySeconds;     // Indicates whether seconds should be displayed.
+    int timeZoneOffset;      // Stores the hour offset from UTC for the given location.
+    int minuteOffset;        // Stores any additional minute offset (for cities with non-whole hour offsets).
 
-    // Weather information fetched from the internet.
+    // Stores the weather information fetched from the internet.
     std::string weatherInfo;
 
 public:
-    // Constructor: Initializes the clock with the user’s preferences.
+    // Constructor: Initializes the Clock with the provided user settings.
     Clock(const std::string &userName,
           const std::string &location,
           int timeFormat,
           bool displaySeconds);
 
-    // Starts the continuous clock loop (updating the display every second).
+    // The start() method enters an infinite loop to continuously update the clock display.
     void start();
 };
 
-#endif
+#endif  // End of CLOCK_H definition.

DigitalClock

@@ -1,23 +1,25 @@
-#ifndef DISPLAY_H
+#ifndef DISPLAY_H           // If DISPLAY_H is not defined, then define it.
 #define DISPLAY_H
 
-#include <string>
+#include <string>          // Include string to use std::string in our class.
 
 // The Display class handles drawing the clock’s digits and symbols on the console.
 class Display
 {
 private:
     static const int HEIGHT = 7;  // Each digit or symbol is 7 lines tall.
 
-    // 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.
+    // ANSI escape codes for colored output:
+    // FG_COLOR sets the text to bold green.
+    static constexpr const char* FG_COLOR = "\033[1;32m";
+    // RESET_COLOR resets the text color to the terminal's default.
+    static constexpr const char* RESET_COLOR = "\033[0m";
 
     // ASCII art patterns for digits 0-9.
     static const std::string digits[10][HEIGHT];
     // Pattern for the colon.
     static const std::string colon[HEIGHT];
-    // Patterns for AM and PM.
+    // Patterns for the "AM" and "PM" indicators.
     static const std::string am[HEIGHT];
     static const std::string pm[HEIGHT];
 
@@ -35,4 +37,4 @@ class Display
     static void displayAmPm(bool isPm, int x, int y);
 };
 
-#endif
+#endif  // End of DISPLAY_H definition.

Display.h

@@ -1,7 +1,7 @@
-#ifndef INPUT_H
+#ifndef INPUT_H           // If INPUT_H is not defined, then define it.
 #define INPUT_H
 
-#include <string>
+#include <string>         // Include string to use std::string in our class.
 
 // The Input class provides functions to obtain and validate input from the user.
 class Input
@@ -15,4 +15,4 @@ class Input
     static std::string getLocationInput();
 };
 
-#endif
+#endif  // End of INPUT_H definition.

Input.h

@@ -12,11 +12,11 @@ using namespace std;
 // getTimeZoneOffset() returns the hour offset from UTC for a given location.
 int Utility::getTimeZoneOffset(const std::string &location)
 {
-    if (location == "London")    return 1;
-    if (location == "Berlin")    return 2;
-    if (location == "Tokyo")     return 9;
-    if (location == "Sydney")    return 10;
-    if (location == "Kathmandu") return 5;
+    if (location == "London")    return 0;   // UTC+1
+    if (location == "Berlin")    return 1;   // UTC+1
+    if (location == "Tokyo")     return 9;   // UTC+9
+    if (location == "Sydney")    return 11;  // UTC+11
+    if (location == "Kathmandu") return 5;   // UTC+5:45 (hour component)
     return -9999; // Invalid location indicator.
 }
 

Utility.cpp

@@ -1,7 +1,7 @@
-#ifndef UTILITY_H
+#ifndef UTILITY_H         // If UTILITY_H is not defined, define it.
 #define UTILITY_H
 
-#include <string>
+#include <string>        // Include string to work with std::string.
 
 // The Utility class provides helper functions for:
 // - Determining time zone offsets
@@ -16,17 +16,17 @@ class Utility
     // Returns any additional minute offset for the given location.
     static int getMinutesOffset(const std::string &location);
 
-    // Logs the user’s settings to a file.
+    // Logs the user’s settings (name, location, time format, seconds option) to a file.
     static void logUserChoice(const std::string &name,
                               const std::string &location,
                               int timeFormat,
                               bool displaySeconds);
 
-    // Fetches weather information (temperature and description) for the location.
+    // Fetches weather information (temperature and description) for the given location.
     static std::string getWeatherInfo(const std::string &location);
 
-    // Returns today's date formatted for the location.
+    // Returns today's date formatted for the given location.
     static std::string getLocalDate(const std::string &location);
 };
 
-#endif
+#endif  // End of UTILITY_H definition.